From ece2db08da52ca8903ae673286c3053741fac6c7 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 25 May 2018 02:03:25 -0400 Subject: [PATCH 001/383] initial import --- .gitignore | 108 ++ .travis.yml | 19 + CHANGELOG.md | 0 LICENSE | 21 + MANIFEST.in | 4 + README.md | 0 setup.cfg | 7 + setup.py | 45 + tests/unit/__init__.py | 0 tests/unit/ftc.py | 43 + tests/unit/test_account.py | 105 ++ tests/unit/test_coinselection.py | 157 +++ tests/unit/test_hash.py | 21 + tests/unit/test_ledger.py | 0 tests/unit/test_mnemonic.py | 23 + tests/unit/test_script.py | 218 +++ tests/unit/test_transaction.py | 174 +++ tests/unit/test_wallet.py | 97 ++ torba/__init__.py | 2 + torba/account.py | 190 +++ torba/basecoin.py | 79 ++ torba/baseledger.py | 469 +++++++ torba/basenetwork.py | 221 +++ torba/basescript.py | 407 ++++++ torba/basetransaction.py | 287 ++++ torba/bcd_data_stream.py | 126 ++ torba/bip32.py | 329 +++++ torba/coin/__init__.py | 1 + torba/coin/btc.py | 43 + torba/coinselection.py | 95 ++ torba/constants.py | 3 + torba/hash.py | 180 +++ torba/manager.py | 83 ++ torba/mnemonic.py | 163 +++ torba/msqr.py | 96 ++ torba/stream.py | 144 ++ torba/util.py | 60 + torba/wallet.py | 164 +++ torba/words/chinese_simplified.txt | 2048 ++++++++++++++++++++++++++++ torba/words/english.txt | 2048 ++++++++++++++++++++++++++++ torba/words/japanese.txt | 2048 ++++++++++++++++++++++++++++ torba/words/portuguese.txt | 1654 ++++++++++++++++++++++ torba/words/spanish.txt | 2048 ++++++++++++++++++++++++++++ tox.ini | 12 + 44 files changed, 14042 insertions(+) create mode 100644 .gitignore create mode 100644 .travis.yml create mode 100644 CHANGELOG.md create mode 100644 LICENSE create mode 100644 MANIFEST.in create mode 100644 README.md create mode 100644 setup.cfg create mode 100644 setup.py create mode 100644 tests/unit/__init__.py create mode 100644 tests/unit/ftc.py create mode 100644 tests/unit/test_account.py create mode 100644 tests/unit/test_coinselection.py create mode 100644 tests/unit/test_hash.py create mode 100644 tests/unit/test_ledger.py create mode 100644 tests/unit/test_mnemonic.py create mode 100644 tests/unit/test_script.py create mode 100644 tests/unit/test_transaction.py create mode 100644 tests/unit/test_wallet.py create mode 100644 torba/__init__.py create mode 100644 torba/account.py create mode 100644 torba/basecoin.py create mode 100644 torba/baseledger.py create mode 100644 torba/basenetwork.py create mode 100644 torba/basescript.py create mode 100644 torba/basetransaction.py create mode 100644 torba/bcd_data_stream.py create mode 100644 torba/bip32.py create mode 100644 torba/coin/__init__.py create mode 100644 torba/coin/btc.py create mode 100644 torba/coinselection.py create mode 100644 torba/constants.py create mode 100644 torba/hash.py create mode 100644 torba/manager.py create mode 100644 torba/mnemonic.py create mode 100644 torba/msqr.py create mode 100644 torba/stream.py create mode 100644 torba/util.py create mode 100644 torba/wallet.py create mode 100644 torba/words/chinese_simplified.txt create mode 100644 torba/words/english.txt create mode 100644 torba/words/japanese.txt create mode 100644 torba/words/portuguese.txt create mode 100644 torba/words/spanish.txt create mode 100644 tox.ini diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..298830b77 --- /dev/null +++ b/.gitignore @@ -0,0 +1,108 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +env/ +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# dotenv +.env + +# virtualenv +.venv +venv/ +ENV/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ + + +# pycharm configuration +.idea/ + +bin/ +data/ diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 000000000..4056bc8b3 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,19 @@ +sudo: false +language: python + +python: + - "2.7" + - "3.6" + +install: pip install tox-travis coverage + +script: + - tox + +after_success: + - coverage combine tests/ + - bash <(curl -s https://codecov.io/bash) + +branches: + only: + - master diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 000000000..e69de29bb diff --git a/LICENSE b/LICENSE new file mode 100644 index 000000000..53ed0f582 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 LBRY Inc. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 000000000..731c2743e --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,4 @@ +include README.md +include CHANGELOG.md +include LICENSE +recursive-include torba *.txt *.py diff --git a/README.md b/README.md new file mode 100644 index 000000000..e69de29bb diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 000000000..96b5abc5a --- /dev/null +++ b/setup.cfg @@ -0,0 +1,7 @@ +[coverage:run] +branch = True + +[coverage:paths] +source = + torba + .tox/*/lib/python*/site-packages/torba diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..f8cfa7c17 --- /dev/null +++ b/setup.py @@ -0,0 +1,45 @@ +import os +import re +from setuptools import setup, find_packages + +init_file = open(os.path.join(os.path.dirname(__path__), 'torba', '__init__.py')).read() +version = re.search('\d+\.\d+\.\d+', init_file).group() + +setup( + name='torba', + version=version, + url='https://github.com/lbryio/torba', + license='MIT', + author='LBRY Inc.', + author_email='hello@lbry.io', + description='Wallet library for bitcoin based currencies.', + keywords='wallet,crypto,currency,money,bitcoin,lbry', + classifiers=( + 'Framework :: Twisted', + 'Intended Audience :: Developers', + 'Intended Audience :: System Administrators', + 'License :: OSI Approved :: MIT License', + 'Programming Language :: Python :: 2.7', + 'Programming Language :: Python :: 3', + 'Operating System :: OS Independent', + 'Topic :: Internet', + 'Topic :: Software Development :: Libraries :: Python Modules', + 'Topic :: System :: Distributed Computing', + 'Topic :: Utilities', + ), + packages=find_packages(exclude=('tests',)), + include_package_data=True, + python_requires='>=2.7,>=3.6', + install_requires=( + 'twisted', + 'ecdsa', + 'pbkdf2', + 'cryptography', + 'typing' + ), + extras_require={ + 'test': ( + 'mock', + ) + } +) diff --git a/tests/unit/__init__.py b/tests/unit/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/unit/ftc.py b/tests/unit/ftc.py new file mode 100644 index 000000000..c838a3f28 --- /dev/null +++ b/tests/unit/ftc.py @@ -0,0 +1,43 @@ +from six import int2byte +from binascii import unhexlify +from torba.baseledger import BaseLedger +from torba.basenetwork import BaseNetwork +from torba.basescript import BaseInputScript, BaseOutputScript +from torba.basetransaction import BaseTransaction, BaseInput, BaseOutput +from torba.basecoin import BaseCoin + + +class Ledger(BaseLedger): + network_class = BaseNetwork + + +class Input(BaseInput): + script_class = BaseInputScript + + +class Output(BaseOutput): + script_class = BaseOutputScript + + +class Transaction(BaseTransaction): + input_class = Input + output_class = Output + + +class FTC(BaseCoin): + name = 'Fakecoin' + symbol = 'FTC' + network = 'mainnet' + + ledger_class = Ledger + transaction_class = Transaction + + pubkey_address_prefix = int2byte(0x00) + script_address_prefix = int2byte(0x05) + extended_public_key_prefix = unhexlify('0488b21e') + extended_private_key_prefix = unhexlify('0488ade4') + + default_fee_per_byte = 50 + + def __init__(self, ledger, fee_per_byte=default_fee_per_byte): + super(FTC, self).__init__(ledger, fee_per_byte) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py new file mode 100644 index 000000000..a01aacbdd --- /dev/null +++ b/tests/unit/test_account.py @@ -0,0 +1,105 @@ +from binascii import hexlify +from twisted.trial import unittest + +from torba.coin.btc import BTC +from torba.manager import WalletManager +from torba.wallet import Account + + +class TestAccount(unittest.TestCase): + + def setUp(self): + ledger = WalletManager().get_or_create_ledger(BTC.get_id()) + self.coin = BTC(ledger) + + def test_generate_account(self): + account = Account.generate(self.coin, u"torba") + self.assertEqual(account.coin, self.coin) + self.assertIsNotNone(account.seed) + self.assertEqual(account.public_key.coin, self.coin) + self.assertEqual(account.private_key.public_key, account.public_key) + + self.assertEqual(len(account.receiving_keys.child_keys), 0) + self.assertEqual(len(account.receiving_keys.addresses), 0) + self.assertEqual(len(account.change_keys.child_keys), 0) + self.assertEqual(len(account.change_keys.addresses), 0) + + account.ensure_enough_addresses() + self.assertEqual(len(account.receiving_keys.child_keys), 20) + self.assertEqual(len(account.receiving_keys.addresses), 20) + self.assertEqual(len(account.change_keys.child_keys), 6) + self.assertEqual(len(account.change_keys.addresses), 6) + + def test_generate_account_from_seed(self): + account = Account.from_seed( + self.coin, + u"carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" + u"sent", + u"torba" + ) + self.assertEqual( + account.private_key.extended_key_string(), + 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + '6yz3jMbycrLrRMpeAJxR8qDg8' + ) + self.assertEqual( + account.public_key.extended_key_string(), + 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' + 'iW44g14WF52fYC5J483wqQ5ZP' + ) + self.assertEqual( + account.receiving_keys.generate_next_address(), + '1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP' + ) + private_key = account.get_private_key_for_address('1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') + self.assertEqual( + private_key.extended_key_string(), + 'xprv9xNEfQ296VTRaEUDZ8oKq74xw2U6kpj486vFUB4K1wT9U25GX4UwuzFgJN1YuRrqkQ5TTwCpkYnjNpSoHS' + 'BaEigNHPkoeYbuPMRo6mRUjxg' + ) + self.assertIsNone(account.get_private_key_for_address('BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX')) + + self.assertEqual( + hexlify(private_key.wif()), + b'1cc27be89ad47ef932562af80e95085eb0ab2ae3e5c019b1369b8b05ff2e94512f01' + ) + + def test_load_and_save_account(self): + account_data = { + 'seed': + "carbon smart garage balance margin twelve chest sword toast envelope bottom stomac" + "h absent", + 'encrypted': False, + 'private_key': + 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + '6yz3jMbycrLrRMpeAJxR8qDg8', + 'public_key': + 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' + 'iW44g14WF52fYC5J483wqQ5ZP', + 'receiving_gap': 10, + 'receiving_keys': [ + '0222345947a59dca4a3363ffa81ac87dd907d2b2feff57383eaeddbab266ca5f2d', + '03fdc9826d5d00a484188cba8eb7dba5877c0323acb77905b7bcbbab35d94be9f6' + ], + 'change_gap': 10, + 'change_keys': [ + '038836be4147836ed6b4df6a89e0d9f1b1c11cec529b7ff5407de57f2e5b032c83' + ] + } + + account = Account.from_dict(self.coin, account_data) + + self.assertEqual(len(account.receiving_keys.addresses), 2) + self.assertEqual( + account.receiving_keys.addresses[0], + '1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP' + ) + self.assertEqual(len(account.change_keys.addresses), 1) + self.assertEqual( + account.change_keys.addresses[0], + '1PUbu1D1f3c244JPRSJKBCxRqui5NT6geR' + ) + + self.maxDiff = None + account_data['coin'] = 'btc_mainnet' + self.assertDictEqual(account_data, account.to_dict()) diff --git a/tests/unit/test_coinselection.py b/tests/unit/test_coinselection.py new file mode 100644 index 000000000..d57ff172d --- /dev/null +++ b/tests/unit/test_coinselection.py @@ -0,0 +1,157 @@ +import unittest + +from torba.coin.btc import BTC +from torba.coinselection import CoinSelector, MAXIMUM_TRIES +from torba.constants import CENT +from torba.manager import WalletManager + +from .test_transaction import Output, get_output as utxo + + +NULL_HASH = b'\x00'*32 + + +def search(*args, **kwargs): + selection = CoinSelector(*args, **kwargs).branch_and_bound() + return [o.output.amount for o in selection] if selection else selection + + +class BaseSelectionTestCase(unittest.TestCase): + + def setUp(self): + ledger = WalletManager().get_or_create_ledger(BTC.get_id()) + self.coin = BTC(ledger) + + def estimates(self, *args): + txos = args if isinstance(args[0], Output) else args[0] + return [txo.get_estimator(self.coin) for txo in txos] + + +class TestCoinSelectionTests(BaseSelectionTestCase): + + def test_empty_coins(self): + self.assertIsNone(CoinSelector([], 0, 0).select()) + + def test_skip_binary_search_if_total_not_enough(self): + fee = utxo(CENT).get_estimator(self.coin).fee + big_pool = self.estimates(utxo(CENT+fee) for _ in range(100)) + selector = CoinSelector(big_pool, 101 * CENT, 0) + self.assertIsNone(selector.select()) + self.assertEqual(selector.tries, 0) # Never tried. + # check happy path + selector = CoinSelector(big_pool, 100 * CENT, 0) + self.assertEqual(len(selector.select()), 100) + self.assertEqual(selector.tries, 201) + + def test_exact_match(self): + fee = utxo(CENT).get_estimator(self.coin).fee + utxo_pool = self.estimates( + utxo(CENT + fee), + utxo(CENT), + utxo(CENT - fee) + ) + selector = CoinSelector(utxo_pool, CENT, 0) + match = selector.select() + self.assertEqual([CENT + fee], [c.output.amount for c in match]) + self.assertTrue(selector.exact_match) + + def test_random_draw(self): + utxo_pool = self.estimates( + utxo(2 * CENT), + utxo(3 * CENT), + utxo(4 * CENT) + ) + selector = CoinSelector(utxo_pool, CENT, 0, '\x00') + match = selector.select() + self.assertEqual([2 * CENT], [c.output.amount for c in match]) + self.assertFalse(selector.exact_match) + + +class TestOfficialBitcoinCoinSelectionTests(BaseSelectionTestCase): + + # Bitcoin implementation: + # https://github.com/bitcoin/bitcoin/blob/master/src/wallet/coinselection.cpp + # + # Bitcoin implementation tests: + # https://github.com/bitcoin/bitcoin/blob/master/src/wallet/test/coinselector_tests.cpp + # + # Branch and Bound coin selection white paper: + # https://murch.one/wp-content/uploads/2016/11/erhardt2016coinselection.pdf + + def setUp(self): + ledger = WalletManager().get_or_create_ledger(BTC.get_id()) + self.coin = BTC(ledger, 0) + + def make_hard_case(self, utxos): + target = 0 + utxo_pool = [] + for i in range(utxos): + amount = 1 << (utxos+i) + target += amount + utxo_pool.append(utxo(amount)) + utxo_pool.append(utxo(amount + (1 << (utxos-1-i)))) + return self.estimates(utxo_pool), target + + def test_branch_and_bound_coin_selection(self): + utxo_pool = self.estimates( + utxo(1 * CENT), + utxo(2 * CENT), + utxo(3 * CENT), + utxo(4 * CENT) + ) + + # Select 1 Cent + self.assertEqual([1 * CENT], search(utxo_pool, 1 * CENT, 0.5 * CENT)) + + # Select 2 Cent + self.assertEqual([2 * CENT], search(utxo_pool, 2 * CENT, 0.5 * CENT)) + + # Select 5 Cent + self.assertEqual([3 * CENT, 2 * CENT], search(utxo_pool, 5 * CENT, 0.5 * CENT)) + + # Select 11 Cent, not possible + self.assertIsNone(search(utxo_pool, 11 * CENT, 0.5 * CENT)) + + # Select 10 Cent + utxo_pool += self.estimates(utxo(5 * CENT)) + self.assertEqual( + [4 * CENT, 3 * CENT, 2 * CENT, 1 * CENT], + search(utxo_pool, 10 * CENT, 0.5 * CENT) + ) + + # Negative effective value + # Select 10 Cent but have 1 Cent not be possible because too small + # TODO: bitcoin has [5, 3, 2] + self.assertEqual( + [4 * CENT, 3 * CENT, 2 * CENT, 1 * CENT], + search(utxo_pool, 10 * CENT, 5000) + ) + + # Select 0.25 Cent, not possible + self.assertIsNone(search(utxo_pool, 0.25 * CENT, 0.5 * CENT)) + + # Iteration exhaustion test + utxo_pool, target = self.make_hard_case(17) + selector = CoinSelector(utxo_pool, target, 0) + self.assertIsNone(selector.branch_and_bound()) + self.assertEqual(selector.tries, MAXIMUM_TRIES) # Should exhaust + utxo_pool, target = self.make_hard_case(14) + self.assertIsNotNone(search(utxo_pool, target, 0)) # Should not exhaust + + # Test same value early bailout optimization + utxo_pool = self.estimates([ + utxo(7 * CENT), + utxo(7 * CENT), + utxo(7 * CENT), + utxo(7 * CENT), + utxo(2 * CENT) + ] + [utxo(5 * CENT)]*50000) + self.assertEqual( + [7 * CENT, 7 * CENT, 7 * CENT, 7 * CENT, 2 * CENT], + search(utxo_pool, 30 * CENT, 5000) + ) + + # Select 1 Cent with pool of only greater than 5 Cent + utxo_pool = self.estimates(utxo(i * CENT) for i in range(5, 21)) + for _ in range(100): + self.assertIsNone(search(utxo_pool, 1 * CENT, 2 * CENT)) diff --git a/tests/unit/test_hash.py b/tests/unit/test_hash.py new file mode 100644 index 000000000..896337eba --- /dev/null +++ b/tests/unit/test_hash.py @@ -0,0 +1,21 @@ +import mock +from unittest import TestCase +from torba.hash import aes_decrypt, aes_encrypt + + +class TestAESEncryptDecrypt(TestCase): + + @mock.patch('os.urandom', side_effect=lambda i: b'f'*i) + def test_encrypt(self, _): + self.assertEqual(aes_encrypt( + b'bubblegum', b'The Times 03/Jan/2009 Chancellor on brink of second bailout for banks'), + b'OWsqm2goP4wXAPFyDde0IP2rPxRaESGr9NUlPn4y2nZrywQJo7pZCPt9ixYa7Ye9tzSpirF03Qd5OyI75xlGjd' + b'4khKCvcX6tcViLmhIGUPY=' + ) + + def test_decrypt(self): + self.assertEqual(aes_decrypt( + b'bubblegum', b'WeW99mQgRExAEzPjJOAC/MdTJaHgz3hT+kazFbvVQqF/KFva48ulVMOewU7JWD0ufWJIxtAIQ' + b'bGtlbvbq5w74bsCCJLrtNTHBhenkms8XccJXTr/UF/ZYTF1Prz8b0AQ'), + b'The Times 03/Jan/2009 Chancellor on brink of second bailout for banks' + ) diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/unit/test_mnemonic.py b/tests/unit/test_mnemonic.py new file mode 100644 index 000000000..c8fd6aacd --- /dev/null +++ b/tests/unit/test_mnemonic.py @@ -0,0 +1,23 @@ +import unittest +from binascii import hexlify + +from torba.mnemonic import Mnemonic + + +class TestMnemonic(unittest.TestCase): + + def test_mnemonic_to_seed(self): + seed = Mnemonic.mnemonic_to_seed(mnemonic=u'foobar', passphrase=u'torba') + self.assertEqual( + hexlify(seed), + b'475a419db4e991cab14f08bde2d357e52b3e7241f72c6d8a2f92782367feeee9f403dc6a37c26a3f02ab9' + b'dec7f5063161eb139cea00da64cd77fba2f07c49ddc' + ) + + def test_make_seed_decode_encode(self): + iters = 10 + m = Mnemonic('en') + for _ in range(iters): + seed = m.make_seed() + i = m.mnemonic_decode(seed) + self.assertEqual(m.mnemonic_encode(i), seed) diff --git a/tests/unit/test_script.py b/tests/unit/test_script.py new file mode 100644 index 000000000..ddb2073d4 --- /dev/null +++ b/tests/unit/test_script.py @@ -0,0 +1,218 @@ +from binascii import hexlify, unhexlify +from twisted.trial import unittest + +from torba.bcd_data_stream import BCDataStream +from torba.basescript import Template, ParseError, tokenize, push_data +from torba.basescript import PUSH_SINGLE, PUSH_MANY, OP_HASH160, OP_EQUAL +from torba.basescript import BaseInputScript, BaseOutputScript + + +def parse(opcodes, source): + template = Template('test', opcodes) + s = BCDataStream() + for t in source: + if isinstance(t, bytes): + s.write_many(push_data(t)) + elif isinstance(t, int): + s.write_uint8(t) + else: + raise ValueError() + s.reset() + return template.parse(tokenize(s)) + + +class TestScriptTemplates(unittest.TestCase): + + def test_push_data(self): + self.assertEqual(parse( + (PUSH_SINGLE('script_hash'),), + (b'abcdef',) + ), { + 'script_hash': b'abcdef' + } + ) + self.assertEqual(parse( + (PUSH_SINGLE('first'), PUSH_SINGLE('last')), + (b'Satoshi', b'Nakamoto') + ), { + 'first': b'Satoshi', + 'last': b'Nakamoto' + } + ) + self.assertEqual(parse( + (OP_HASH160, PUSH_SINGLE('script_hash'), OP_EQUAL), + (OP_HASH160, b'abcdef', OP_EQUAL) + ), { + 'script_hash': b'abcdef' + } + ) + + def test_push_data_many(self): + self.assertEqual(parse( + (PUSH_MANY('names'),), + (b'amit',) + ), { + 'names': [b'amit'] + } + ) + self.assertEqual(parse( + (PUSH_MANY('names'),), + (b'jeremy', b'amit', b'victor') + ), { + 'names': [b'jeremy', b'amit', b'victor'] + } + ) + self.assertEqual(parse( + (OP_HASH160, PUSH_MANY('names'), OP_EQUAL), + (OP_HASH160, b'grin', b'jack', OP_EQUAL) + ), { + 'names': [b'grin', b'jack'] + } + ) + + def test_push_data_mixed(self): + self.assertEqual(parse( + (PUSH_SINGLE('CEO'), PUSH_MANY('Devs'), PUSH_SINGLE('CTO'), PUSH_SINGLE('State')), + (b'jeremy', b'lex', b'amit', b'victor', b'jack', b'grin', b'NH') + ), { + 'CEO': b'jeremy', + 'CTO': b'grin', + 'Devs': [b'lex', b'amit', b'victor', b'jack'], + 'State': b'NH' + } + ) + + def test_push_data_many_separated(self): + self.assertEqual(parse( + (PUSH_MANY('Chiefs'), OP_HASH160, PUSH_MANY('Devs')), + (b'jeremy', b'grin', OP_HASH160, b'lex', b'jack') + ), { + 'Chiefs': [b'jeremy', b'grin'], + 'Devs': [b'lex', b'jack'] + } + ) + + def test_push_data_many_not_separated(self): + with self.assertRaisesRegexp(ParseError, 'consecutive PUSH_MANY'): + parse((PUSH_MANY('Chiefs'), PUSH_MANY('Devs')), (b'jeremy', b'grin', b'lex', b'jack')) + + +class TestRedeemPubKeyHash(unittest.TestCase): + + def redeem_pubkey_hash(self, sig, pubkey): + # this checks that factory function correctly sets up the script + src1 = BaseInputScript.redeem_pubkey_hash(unhexlify(sig), unhexlify(pubkey)) + self.assertEqual(src1.template.name, 'pubkey_hash') + self.assertEqual(hexlify(src1.values['signature']), sig) + self.assertEqual(hexlify(src1.values['pubkey']), pubkey) + # now we test that it will round trip + src2 = BaseInputScript(src1.source) + self.assertEqual(src2.template.name, 'pubkey_hash') + self.assertEqual(hexlify(src2.values['signature']), sig) + self.assertEqual(hexlify(src2.values['pubkey']), pubkey) + return hexlify(src1.source) + + def test_redeem_pubkey_hash_1(self): + self.assertEqual( + self.redeem_pubkey_hash( + b'30450221009dc93f25184a8d483745cd3eceff49727a317c9bfd8be8d3d04517e9cdaf8dd502200e' + b'02dc5939cad9562d2b1f303f185957581c4851c98d497af281118825e18a8301', + b'025415a06514230521bff3aaface31f6db9d9bbc39bf1ca60a189e78731cfd4e1b' + ), + b'4830450221009dc93f25184a8d483745cd3eceff49727a317c9bfd8be8d3d04517e9cdaf8dd502200e02d' + b'c5939cad9562d2b1f303f185957581c4851c98d497af281118825e18a830121025415a06514230521bff3' + b'aaface31f6db9d9bbc39bf1ca60a189e78731cfd4e1b' + ) + + +class TestRedeemScriptHash(unittest.TestCase): + + def redeem_script_hash(self, sigs, pubkeys): + # this checks that factory function correctly sets up the script + src1 = BaseInputScript.redeem_script_hash( + [unhexlify(sig) for sig in sigs], + [unhexlify(pubkey) for pubkey in pubkeys] + ) + subscript1 = src1.values['script'] + self.assertEqual(src1.template.name, 'script_hash') + self.assertEqual([hexlify(v) for v in src1.values['signatures']], sigs) + self.assertEqual([hexlify(p) for p in subscript1.values['pubkeys']], pubkeys) + self.assertEqual(subscript1.values['signatures_count'], len(sigs)) + self.assertEqual(subscript1.values['pubkeys_count'], len(pubkeys)) + # now we test that it will round trip + src2 = BaseInputScript(src1.source) + subscript2 = src2.values['script'] + self.assertEqual(src2.template.name, 'script_hash') + self.assertEqual([hexlify(v) for v in src2.values['signatures']], sigs) + self.assertEqual([hexlify(p) for p in subscript2.values['pubkeys']], pubkeys) + self.assertEqual(subscript2.values['signatures_count'], len(sigs)) + self.assertEqual(subscript2.values['pubkeys_count'], len(pubkeys)) + return hexlify(src1.source) + + def test_redeem_script_hash_1(self): + self.assertEqual( + self.redeem_script_hash([ + b'3045022100fec82ed82687874f2a29cbdc8334e114af645c45298e85bb1efe69fcf15c617a0220575' + b'e40399f9ada388d8e522899f4ec3b7256896dd9b02742f6567d960b613f0401', + b'3044022024890462f731bd1a42a4716797bad94761fc4112e359117e591c07b8520ea33b02201ac68' + b'9e35c4648e6beff1d42490207ba14027a638a62663b2ee40153299141eb01', + b'30450221009910823e0142967a73c2d16c1560054d71c0625a385904ba2f1f53e0bc1daa8d02205cd' + b'70a89c6cf031a8b07d1d5eb0d65d108c4d49c2d403f84fb03ad3dc318777a01' + ], [ + b'0372ba1fd35e5f1b1437cba0c4ebfc4025b7349366f9f9c7c8c4b03a47bd3f68a4', + b'03061d250182b2db1ba144167fd8b0ef3fe0fc3a2fa046958f835ffaf0dfdb7692', + b'02463bfbc1eaec74b5c21c09239ae18dbf6fc07833917df10d0b43e322810cee0c', + b'02fa6a6455c26fb516cfa85ea8de81dd623a893ffd579ee2a00deb6cdf3633d6bb', + b'0382910eae483ce4213d79d107bfc78f3d77e2a31ea597be45256171ad0abeaa89' + ]), + b'00483045022100fec82ed82687874f2a29cbdc8334e114af645c45298e85bb1efe69fcf15c617a0220575e' + b'40399f9ada388d8e522899f4ec3b7256896dd9b02742f6567d960b613f0401473044022024890462f731bd' + b'1a42a4716797bad94761fc4112e359117e591c07b8520ea33b02201ac689e35c4648e6beff1d42490207ba' + b'14027a638a62663b2ee40153299141eb014830450221009910823e0142967a73c2d16c1560054d71c0625a' + b'385904ba2f1f53e0bc1daa8d02205cd70a89c6cf031a8b07d1d5eb0d65d108c4d49c2d403f84fb03ad3dc3' + b'18777a014cad53210372ba1fd35e5f1b1437cba0c4ebfc4025b7349366f9f9c7c8c4b03a47bd3f68a42103' + b'061d250182b2db1ba144167fd8b0ef3fe0fc3a2fa046958f835ffaf0dfdb76922102463bfbc1eaec74b5c2' + b'1c09239ae18dbf6fc07833917df10d0b43e322810cee0c2102fa6a6455c26fb516cfa85ea8de81dd623a89' + b'3ffd579ee2a00deb6cdf3633d6bb210382910eae483ce4213d79d107bfc78f3d77e2a31ea597be45256171' + b'ad0abeaa8955ae' + ) + + +class TestPayPubKeyHash(unittest.TestCase): + + def pay_pubkey_hash(self, pubkey_hash): + # this checks that factory function correctly sets up the script + src1 = BaseOutputScript.pay_pubkey_hash(unhexlify(pubkey_hash)) + self.assertEqual(src1.template.name, 'pay_pubkey_hash') + self.assertEqual(hexlify(src1.values['pubkey_hash']), pubkey_hash) + # now we test that it will round trip + src2 = BaseOutputScript(src1.source) + self.assertEqual(src2.template.name, 'pay_pubkey_hash') + self.assertEqual(hexlify(src2.values['pubkey_hash']), pubkey_hash) + return hexlify(src1.source) + + def test_pay_pubkey_hash_1(self): + self.assertEqual( + self.pay_pubkey_hash(b'64d74d12acc93ba1ad495e8d2d0523252d664f4d'), + b'76a91464d74d12acc93ba1ad495e8d2d0523252d664f4d88ac' + ) + + +class TestPayScriptHash(unittest.TestCase): + + def pay_script_hash(self, script_hash): + # this checks that factory function correctly sets up the script + src1 = BaseOutputScript.pay_script_hash(unhexlify(script_hash)) + self.assertEqual(src1.template.name, 'pay_script_hash') + self.assertEqual(hexlify(src1.values['script_hash']), script_hash) + # now we test that it will round trip + src2 = BaseOutputScript(src1.source) + self.assertEqual(src2.template.name, 'pay_script_hash') + self.assertEqual(hexlify(src2.values['script_hash']), script_hash) + return hexlify(src1.source) + + def test_pay_pubkey_hash_1(self): + self.assertEqual( + self.pay_script_hash(b'63d65a2ee8c44426d06050cfd71c0f0ff3fc41ac'), + b'a91463d65a2ee8c44426d06050cfd71c0f0ff3fc41ac87' + ) diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py new file mode 100644 index 000000000..fcdd2d736 --- /dev/null +++ b/tests/unit/test_transaction.py @@ -0,0 +1,174 @@ +from binascii import hexlify, unhexlify +from twisted.trial import unittest + +from torba.account import Account +from torba.coin.btc import BTC, Transaction, Output, Input +from torba.constants import CENT, COIN +from torba.manager import WalletManager +from torba.wallet import Wallet + + +NULL_HASH = b'\x00'*32 +FEE_PER_BYTE = 50 +FEE_PER_CHAR = 200000 + + +def get_output(amount=CENT, pubkey_hash=NULL_HASH): + return Transaction() \ + .add_outputs([Output.pay_pubkey_hash(amount, pubkey_hash)]) \ + .outputs[0] + + +def get_input(): + return Input.spend(get_output()) + + +def get_transaction(txo=None): + return Transaction() \ + .add_inputs([get_input()]) \ + .add_outputs([txo or Output.pay_pubkey_hash(CENT, NULL_HASH)]) + + +def get_wallet_and_coin(): + ledger = WalletManager().get_or_create_ledger(BTC.get_id()) + coin = BTC(ledger) + return Wallet('Main', [coin], [Account.generate(coin, u'torba')]), coin + + +class TestSizeAndFeeEstimation(unittest.TestCase): + + def setUp(self): + self.wallet, self.coin = get_wallet_and_coin() + + def io_fee(self, io): + return self.coin.get_input_output_fee(io) + + def test_output_size_and_fee(self): + txo = get_output() + self.assertEqual(txo.size, 46) + self.assertEqual(self.io_fee(txo), 46 * FEE_PER_BYTE) + + def test_input_size_and_fee(self): + txi = get_input() + self.assertEqual(txi.size, 148) + self.assertEqual(self.io_fee(txi), 148 * FEE_PER_BYTE) + + def test_transaction_size_and_fee(self): + tx = get_transaction() + base_size = tx.size - 1 - tx.inputs[0].size + self.assertEqual(tx.size, 204) + self.assertEqual(tx.base_size, base_size) + self.assertEqual(self.coin.get_transaction_base_fee(tx), FEE_PER_BYTE * base_size) + + +class TestTransactionSerialization(unittest.TestCase): + + def test_genesis_transaction(self): + raw = unhexlify( + '01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04' + 'ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e20' + '6272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01' + '000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4c' + 'ef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000' + ) + tx = Transaction(raw) + self.assertEqual(tx.version, 1) + self.assertEqual(tx.locktime, 0) + self.assertEqual(len(tx.inputs), 1) + self.assertEqual(len(tx.outputs), 1) + + coinbase = tx.inputs[0] + self.assertEqual(coinbase.output_txid, NULL_HASH) + self.assertEqual(coinbase.output_index, 0xFFFFFFFF) + self.assertEqual(coinbase.sequence, 4294967295) + self.assertTrue(coinbase.is_coinbase) + self.assertEqual(coinbase.script, None) + self.assertEqual( + coinbase.coinbase[8:], + b'The Times 03/Jan/2009 Chancellor on brink of second bailout for banks' + ) + + out = tx.outputs[0] + self.assertEqual(out.amount, 5000000000) + self.assertEqual(out.index, 0) + self.assertTrue(out.script.is_pay_pubkey) + self.assertFalse(out.script.is_pay_pubkey_hash) + self.assertFalse(out.script.is_pay_script_hash) + + tx._reset() + self.assertEqual(tx.raw, raw) + + def test_coinbase_transaction(self): + raw = unhexlify( + '01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4e03' + '1f5a070473319e592f4254432e434f4d2f4e59412ffabe6d6dcceb2a9d0444c51cabc4ee97a1a000036ca0' + 'cb48d25b94b78c8367d8b868454b0100000000000000c0309b21000008c5f8f80000ffffffff0291920b5d' + '0000000017a914e083685a1097ce1ea9e91987ab9e94eae33d8a13870000000000000000266a24aa21a9ed' + 'e6c99265a6b9e1d36c962fda0516b35709c49dc3b8176fa7e5d5f1f6197884b400000000' + ) + tx = Transaction(raw) + self.assertEqual(tx.version, 1) + self.assertEqual(tx.locktime, 0) + self.assertEqual(len(tx.inputs), 1) + self.assertEqual(len(tx.outputs), 2) + + coinbase = tx.inputs[0] + self.assertEqual(coinbase.output_txid, NULL_HASH) + self.assertEqual(coinbase.output_index, 0xFFFFFFFF) + self.assertEqual(coinbase.sequence, 4294967295) + self.assertTrue(coinbase.is_coinbase) + self.assertEqual(coinbase.script, None) + self.assertEqual( + coinbase.coinbase[9:22], + b'/BTC.COM/NYA/' + ) + + out = tx.outputs[0] + self.assertEqual(out.amount, 1561039505) + self.assertEqual(out.index, 0) + self.assertFalse(out.script.is_pay_pubkey) + self.assertFalse(out.script.is_pay_pubkey_hash) + self.assertTrue(out.script.is_pay_script_hash) + self.assertFalse(out.script.is_return_data) + + out1 = tx.outputs[1] + self.assertEqual(out1.amount, 0) + self.assertEqual(out1.index, 1) + self.assertEqual( + hexlify(out1.script.values['data']), + b'aa21a9ede6c99265a6b9e1d36c962fda0516b35709c49dc3b8176fa7e5d5f1f6197884b4' + ) + self.assertTrue(out1.script.is_return_data) + self.assertFalse(out1.script.is_pay_pubkey) + self.assertFalse(out1.script.is_pay_pubkey_hash) + self.assertFalse(out1.script.is_pay_script_hash) + + tx._reset() + self.assertEqual(tx.raw, raw) + + +class TestTransactionSigning(unittest.TestCase): + + def test_sign(self): + ledger = WalletManager().get_or_create_ledger(BTC.get_id()) + coin = BTC(ledger) + wallet = Wallet('Main', [coin], [Account.from_seed( + coin, u'carbon smart garage balance margin twelve chest sword toast envelope bottom stom' + u'ach absent', u'torba' + )]) + account = wallet.default_account + + address1 = account.receiving_keys.generate_next_address() + address2 = account.receiving_keys.generate_next_address() + pubkey_hash1 = account.coin.address_to_hash160(address1) + pubkey_hash2 = account.coin.address_to_hash160(address2) + + tx = Transaction() \ + .add_inputs([Input.spend(get_output(2*COIN, pubkey_hash1))]) \ + .add_outputs([Output.pay_pubkey_hash(int(1.9*COIN), pubkey_hash2)]) \ + .sign(account) + + self.assertEqual( + hexlify(tx.inputs[0].script.values['signature']), + b'304402203d463519290d06891e461ea5256c56097ccdad53379b1bb4e51ec5abc6e9fd02022034ed15b9d7c678716c4aa7c0fd26c688e8f9db8075838f2839ab55d551b62c0a01' + ) diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py new file mode 100644 index 000000000..992a6dee6 --- /dev/null +++ b/tests/unit/test_wallet.py @@ -0,0 +1,97 @@ +from twisted.trial import unittest + +from torba.coin.btc import BTC +from torba.manager import WalletManager +from torba.wallet import Account, Wallet, WalletStorage + +from .ftc import FTC + + +class TestWalletCreation(unittest.TestCase): + + def setUp(self): + self.manager = WalletManager() + self.btc_ledger = self.manager.get_or_create_ledger(BTC.get_id()) + self.ftc_ledger = self.manager.get_or_create_ledger(FTC.get_id()) + + def test_create_wallet_and_accounts(self): + wallet = Wallet() + self.assertEqual(wallet.name, 'Wallet') + self.assertEqual(wallet.coins, []) + self.assertEqual(wallet.accounts, []) + + account1 = wallet.generate_account(self.btc_ledger) + account2 = wallet.generate_account(self.btc_ledger) + account3 = wallet.generate_account(self.ftc_ledger) + self.assertEqual(wallet.default_account, account1) + self.assertEqual(len(wallet.coins), 2) + self.assertEqual(len(wallet.accounts), 3) + self.assertIsInstance(wallet.coins[0], BTC) + self.assertIsInstance(wallet.coins[1], FTC) + + self.assertEqual(len(account1.receiving_keys.addresses), 0) + self.assertEqual(len(account1.change_keys.addresses), 0) + self.assertEqual(len(account2.receiving_keys.addresses), 0) + self.assertEqual(len(account2.change_keys.addresses), 0) + self.assertEqual(len(account3.receiving_keys.addresses), 0) + self.assertEqual(len(account3.change_keys.addresses), 0) + account1.ensure_enough_addresses() + account2.ensure_enough_addresses() + account3.ensure_enough_addresses() + self.assertEqual(len(account1.receiving_keys.addresses), 20) + self.assertEqual(len(account1.change_keys.addresses), 6) + self.assertEqual(len(account2.receiving_keys.addresses), 20) + self.assertEqual(len(account2.change_keys.addresses), 6) + self.assertEqual(len(account3.receiving_keys.addresses), 20) + self.assertEqual(len(account3.change_keys.addresses), 6) + + def test_load_and_save_wallet(self): + wallet_dict = { + 'name': 'Main Wallet', + 'accounts': [ + { + 'coin': 'btc_mainnet', + 'seed': + "carbon smart garage balance margin twelve chest sword toast envelope bottom stomac" + "h absent", + 'encrypted': False, + 'private_key': + 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + '6yz3jMbycrLrRMpeAJxR8qDg8', + 'public_key': + 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' + 'iW44g14WF52fYC5J483wqQ5ZP', + 'receiving_gap': 10, + 'receiving_keys': [ + '0222345947a59dca4a3363ffa81ac87dd907d2b2feff57383eaeddbab266ca5f2d', + '03fdc9826d5d00a484188cba8eb7dba5877c0323acb77905b7bcbbab35d94be9f6' + ], + 'change_gap': 10, + 'change_keys': [ + '038836be4147836ed6b4df6a89e0d9f1b1c11cec529b7ff5407de57f2e5b032c83' + ] + } + ] + } + + storage = WalletStorage(default=wallet_dict) + wallet = Wallet.from_storage(storage, self.manager) + self.assertEqual(wallet.name, 'Main Wallet') + self.assertEqual(len(wallet.coins), 1) + self.assertIsInstance(wallet.coins[0], BTC) + self.assertEqual(len(wallet.accounts), 1) + account = wallet.default_account + self.assertIsInstance(account, Account) + + self.assertEqual(len(account.receiving_keys.addresses), 2) + self.assertEqual( + account.receiving_keys.addresses[0], + '1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP' + ) + self.assertEqual(len(account.change_keys.addresses), 1) + self.assertEqual( + account.change_keys.addresses[0], + '1PUbu1D1f3c244JPRSJKBCxRqui5NT6geR' + ) + wallet_dict['coins'] = {'btc_mainnet': {'fee_per_byte': 50}} + self.assertDictEqual(wallet_dict, wallet.to_dict()) diff --git a/torba/__init__.py b/torba/__init__.py new file mode 100644 index 000000000..bc9d27d55 --- /dev/null +++ b/torba/__init__.py @@ -0,0 +1,2 @@ +__path__ = __import__('pkgutil').extend_path(__path__, __name__) +__version__ = '0.0.1' diff --git a/torba/account.py b/torba/account.py new file mode 100644 index 000000000..ea480c505 --- /dev/null +++ b/torba/account.py @@ -0,0 +1,190 @@ +import itertools +from typing import Dict, Generator +from binascii import hexlify, unhexlify + +from torba.basecoin import BaseCoin +from torba.mnemonic import Mnemonic +from torba.bip32 import PrivateKey, PubKey, from_extended_key_string +from torba.hash import double_sha256, aes_encrypt, aes_decrypt + + +class KeyChain: + + def __init__(self, parent_key, child_keys, gap): + self.coin = parent_key.coin + self.parent_key = parent_key # type: PubKey + self.child_keys = child_keys + self.minimum_gap = gap + self.addresses = [ + self.coin.public_key_to_address(key) + for key in child_keys + ] + + @property + def has_gap(self): + if len(self.addresses) < self.minimum_gap: + return False + for address in self.addresses[-self.minimum_gap:]: + if self.coin.ledger.is_address_old(address): + return False + return True + + def generate_next_address(self): + child_key = self.parent_key.child(len(self.child_keys)) + self.child_keys.append(child_key.pubkey_bytes) + self.addresses.append(child_key.address) + return child_key.address + + def ensure_enough_addresses(self): + starting_length = len(self.addresses) + while not self.has_gap: + self.generate_next_address() + return self.addresses[starting_length:] + + +class Account: + + def __init__(self, coin, seed, encrypted, private_key, public_key, + receiving_keys=None, receiving_gap=20, + change_keys=None, change_gap=6): + self.coin = coin # type: BaseCoin + self.seed = seed # type: str + self.encrypted = encrypted # type: bool + self.private_key = private_key # type: PrivateKey + self.public_key = public_key # type: PubKey + self.keychains = ( + KeyChain(public_key.child(0), receiving_keys or [], receiving_gap), + KeyChain(public_key.child(1), change_keys or [], change_gap) + ) + self.receiving_keys, self.change_keys = self.keychains + + @classmethod + def generate(cls, coin, password): # type: (BaseCoin, unicode) -> Account + seed = Mnemonic().make_seed() + return cls.from_seed(coin, seed, password) + + @classmethod + def from_seed(cls, coin, seed, password): # type: (BaseCoin, unicode, unicode) -> Account + private_key = cls.get_private_key_from_seed(coin, seed, password) + return cls( + coin=coin, seed=seed, encrypted=False, + private_key=private_key, + public_key=private_key.public_key + ) + + @staticmethod + def get_private_key_from_seed(coin, seed, password): # type: (BaseCoin, unicode, unicode) -> PrivateKey + return PrivateKey.from_seed(coin, Mnemonic.mnemonic_to_seed(seed, password)) + + @classmethod + def from_dict(cls, coin, d): # type: (BaseCoin, Dict) -> Account + if not d['encrypted']: + private_key = from_extended_key_string(coin, d['private_key']) + public_key = private_key.public_key + else: + private_key = d['private_key'] + public_key = from_extended_key_string(coin, d['public_key']) + return cls( + coin=coin, + seed=d['seed'], + encrypted=d['encrypted'], + private_key=private_key, + public_key=public_key, + receiving_keys=[unhexlify(k) for k in d['receiving_keys']], + receiving_gap=d['receiving_gap'], + change_keys=[unhexlify(k) for k in d['change_keys']], + change_gap=d['change_gap'] + ) + + def to_dict(self): + return { + 'coin': self.coin.get_id(), + 'seed': self.seed, + 'encrypted': self.encrypted, + 'private_key': self.private_key if self.encrypted else + self.private_key.extended_key_string(), + 'public_key': self.public_key.extended_key_string(), + 'receiving_keys': [hexlify(k).decode('iso-8859-1') for k in self.receiving_keys.child_keys], + 'receiving_gap': self.receiving_keys.minimum_gap, + 'change_keys': [hexlify(k).decode('iso-8859-1') for k in self.change_keys.child_keys], + 'change_gap': self.change_keys.minimum_gap + } + + def decrypt(self, password): + assert self.encrypted, "Key is not encrypted." + secret = double_sha256(password) + self.seed = aes_decrypt(secret, self.seed) + self.private_key = from_extended_key_string(self.coin, aes_decrypt(secret, self.private_key)) + self.encrypted = False + + def encrypt(self, password): + assert not self.encrypted, "Key is already encrypted." + secret = double_sha256(password) + self.seed = aes_encrypt(secret, self.seed) + self.private_key = aes_encrypt(secret, self.private_key.extended_key_string()) + self.encrypted = True + + @property + def addresses(self): + return itertools.chain(self.receiving_keys.addresses, self.change_keys.addresses) + + def get_private_key_for_address(self, address): + assert not self.encrypted, "Cannot get private key on encrypted wallet account." + for a, keychain in enumerate(self.keychains): + for b, match in enumerate(keychain.addresses): + if address == match: + return self.private_key.child(a).child(b) + + def ensure_enough_addresses(self): + return [ + address + for keychain in self.keychains + for address in keychain.ensure_enough_addresses() + ] + + def addresses_without_history(self): + for address in self.addresses: + if not self.coin.ledger.has_address(address): + yield address + + def get_least_used_receiving_address(self, max_transactions=1000): + return self._get_least_used_address( + self.receiving_keys.addresses, + self.receiving_keys, + max_transactions + ) + + def get_least_used_change_address(self, max_transactions=100): + return self._get_least_used_address( + self.change_keys.addresses, + self.change_keys, + max_transactions + ) + + def _get_least_used_address(self, addresses, keychain, max_transactions): + ledger = self.coin.ledger + address = ledger.get_least_used_address(addresses, max_transactions) + if address: + return address + address = keychain.generate_next_address() + ledger.subscribe_history(address) + return address + + def get_unspent_utxos(self): + return [ + utxo + for address in self.addresses + for utxo in self.coin.ledger.get_unspent_outputs(address) + ] + + def get_balance(self): + return sum(utxo.amount for utxo in self.get_unspent_utxos()) + + +class AccountsView: + + def __init__(self, accounts): + self._accounts_generator = accounts + + def __iter__(self): # type: () -> Generator[Account] + return self._accounts_generator() diff --git a/torba/basecoin.py b/torba/basecoin.py new file mode 100644 index 000000000..2b8c04502 --- /dev/null +++ b/torba/basecoin.py @@ -0,0 +1,79 @@ +import six +from typing import Dict, Type +from torba.hash import hash160, double_sha256, Base58 + + +class CoinRegistry(type): + coins = {} # type: Dict[str, Type[BaseCoin]] + + def __new__(mcs, name, bases, attrs): + cls = super(CoinRegistry, mcs).__new__(mcs, name, bases, attrs) # type: Type[BaseCoin] + if not (name == 'BaseCoin' and not bases): + coin_id = cls.get_id() + assert coin_id not in mcs.coins, 'Coin with id "{}" already registered.'.format(coin_id) + mcs.coins[coin_id] = cls + assert cls.ledger_class.coin_class is None, ( + "Ledger ({}) which this coin ({}) references is already referenced by another " + "coin ({}). One to one relationship between a coin and a ledger is strictly and " + "automatically enforced. Make sure that coin_class=None in the ledger and that " + "another Coin isn't already referencing this Ledger." + ).format(cls.ledger_class.__name__, name, cls.ledger_class.coin_class.__name__) + # create back reference from ledger to the coin + cls.ledger_class.coin_class = cls + return cls + + @classmethod + def get_coin_class(mcs, coin_id): # type: (str) -> Type[BaseCoin] + return mcs.coins[coin_id] + + +class BaseCoin(six.with_metaclass(CoinRegistry)): + + name = None + symbol = None + network = None + + ledger_class = None # type: Type[BaseLedger] + transaction_class = None # type: Type[BaseTransaction] + + secret_prefix = None + pubkey_address_prefix = None + script_address_prefix = None + extended_public_key_prefix = None + extended_private_key_prefix = None + + def __init__(self, ledger, fee_per_byte): + self.ledger = ledger + self.fee_per_byte = fee_per_byte + + @classmethod + def get_id(cls): + return '{}_{}'.format(cls.symbol.lower(), cls.network.lower()) + + def to_dict(self): + return {'fee_per_byte': self.fee_per_byte} + + def get_input_output_fee(self, io): + """ Fee based on size of the input / output. """ + return self.fee_per_byte * io.size + + def get_transaction_base_fee(self, tx): + """ Fee for the transaction header and all outputs; without inputs. """ + return self.fee_per_byte * tx.base_size + + def hash160_to_address(self, h160): + raw_address = self.pubkey_address_prefix + h160 + return Base58.encode(bytearray(raw_address + double_sha256(raw_address)[0:4])) + + @staticmethod + def address_to_hash160(address): + bytes = Base58.decode(address) + prefix, pubkey_bytes, addr_checksum = bytes[0], bytes[1:21], bytes[21:] + return pubkey_bytes + + def public_key_to_address(self, public_key): + return self.hash160_to_address(hash160(public_key)) + + @staticmethod + def private_key_to_wif(private_key): + return b'\x1c' + private_key + b'\x01' diff --git a/torba/baseledger.py b/torba/baseledger.py new file mode 100644 index 000000000..7a25af41e --- /dev/null +++ b/torba/baseledger.py @@ -0,0 +1,469 @@ +import os +import hashlib +from binascii import hexlify, unhexlify +from typing import List, Dict, Type +from operator import itemgetter + +from twisted.internet import threads, defer, task, reactor + +from torba.account import Account, AccountsView +from torba.basecoin import BaseCoin +from torba.basetransaction import BaseTransaction +from torba.basenetwork import BaseNetwork +from torba.stream import StreamController, execute_serially +from torba.util import hex_to_int, int_to_hex, rev_hex, hash_encode +from torba.hash import double_sha256, pow_hash + + +class Address: + + def __init__(self, pubkey_hash): + self.pubkey_hash = pubkey_hash + self.transactions = [] # type: List[BaseTransaction] + + def __iter__(self): + return iter(self.transactions) + + def __len__(self): + return len(self.transactions) + + def add_transaction(self, transaction): + self.transactions.append(transaction) + + def get_unspent_utxos(self): + inputs, outputs, utxos = [], [], [] + for tx in self: + for txi in tx.inputs: + inputs.append((txi.output_txid, txi.output_index)) + for txo in tx.outputs: + if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == self.pubkey_hash: + outputs.append((txo, txo.transaction.hash, txo.index)) + for output in set(outputs): + if output[1:] not in inputs: + yield output[0] + + +class BaseLedger: + + # coin_class is automatically set by BaseCoin metaclass + # when it creates the Coin classes, there is a 1..1 relationship + # between a coin and a ledger (at the class level) but a 1..* relationship + # at instance level. Only one Ledger instance should exist per coin class, + # but many coin instances can exist linking back to the single Ledger instance. + coin_class = None # type: Type[BaseCoin] + network_class = None # type: Type[BaseNetwork] + + verify_bits_to_target = True + + def __init__(self, accounts, config=None, network=None, db=None): + self.accounts = accounts # type: AccountsView + self.config = config or {} + self.db = db + self.addresses = {} # type: Dict[str, Address] + self.transactions = {} # type: Dict[str, BaseTransaction] + self.headers = Headers(self) + self._on_transaction_controller = StreamController() + self.on_transaction = self._on_transaction_controller.stream + self.network = network or self.network_class(self.config) + self.network.on_header.listen(self.process_header) + self.network.on_status.listen(self.process_status) + + @property + def transaction_class(self): + return self.coin_class.transaction_class + + @classmethod + def from_json(cls, json_dict): + return cls(json_dict) + + @defer.inlineCallbacks + def load(self): + txs = yield self.db.get_transactions() + for tx_hash, raw, height in txs: + self.transactions[tx_hash] = self.transaction_class(raw, height) + txios = yield self.db.get_transaction_inputs_and_outputs() + for tx_hash, address_hash, input_output, amount, height in txios: + tx = self.transactions[tx_hash] + address = self.addresses.get(address_hash) + if address is None: + address = self.addresses[address_hash] = Address(self.coin_class.address_to_hash160(address_hash)) + tx.add_txio(address, input_output, amount) + address.add_transaction(tx) + + def is_address_old(self, address, age_limit=2): + age = -1 + for tx in self.get_transactions(address, []): + if tx.height == 0: + tx_age = 0 + else: + tx_age = self.headers.height - tx.height + 1 + if tx_age > age: + age = tx_age + return age > age_limit + + def add_transaction(self, address, transaction): # type: (str, BaseTransaction) -> None + if address not in self.addresses: + self.addresses[address] = Address(self.coin_class.address_to_hash160(address)) + self.addresses[address].add_transaction(transaction) + self.transactions.setdefault(hexlify(transaction.id), transaction) + self._on_transaction_controller.add(transaction) + + def has_address(self, address): + return address in self.addresses + + def get_transaction(self, tx_hash, *args): + return self.transactions.get(tx_hash, *args) + + def get_transactions(self, address, *args): + return self.addresses.get(address, *args) + + def get_status(self, address): + hashes = [ + '{}:{}:'.format(hexlify(tx.hash), tx.height).encode() + for tx in self.get_transactions(address, []) if tx.height is not None + ] + if hashes: + return hexlify(hashlib.sha256(b''.join(hashes)).digest()) + + def has_transaction(self, tx_hash): + return tx_hash in self.transactions + + def get_least_used_address(self, addresses, max_transactions=100): + transaction_counts = [] + for address in addresses: + transactions = self.get_transactions(address, []) + tx_count = len(transactions) + if tx_count == 0: + return address + elif tx_count >= max_transactions: + continue + else: + transaction_counts.append((address, tx_count)) + if transaction_counts: + transaction_counts.sort(key=itemgetter(1)) + return transaction_counts[0] + + def get_unspent_outputs(self, address): + if address in self.addresses: + return list(self.addresses[address].get_unspent_utxos()) + return [] + + @defer.inlineCallbacks + def start(self): + first_connection = self.network.on_connected.first + self.network.start() + yield first_connection + self.headers.touch() + yield self.update_headers() + yield self.network.subscribe_headers() + yield self.update_accounts() + + def stop(self): + return self.network.stop() + + @execute_serially + @defer.inlineCallbacks + def update_headers(self): + while True: + height_sought = len(self.headers) + headers = yield self.network.get_headers(height_sought) + print("received {} headers starting at {} height".format(headers['count'], height_sought)) + #log.info("received {} headers starting at {} height".format(headers['count'], height_sought)) + if headers['count'] <= 0: + break + yield self.headers.connect(height_sought, unhexlify(headers['hex'])) + + @defer.inlineCallbacks + def process_header(self, response): + header = response[0] + if self.update_headers.is_running: + return + if header['height'] == len(self.headers): + # New header from network directly connects after the last local header. + yield self.headers.connect(len(self.headers), unhexlify(header['hex'])) + elif header['height'] > len(self.headers): + # New header is several heights ahead of local, do download instead. + yield self.update_headers() + + @execute_serially + def update_accounts(self): + return defer.DeferredList([ + self.update_account(a) for a in self.accounts + ]) + + @defer.inlineCallbacks + def update_account(self, account): # type: (Account) -> defer.Defferred + # Before subscribing, download history for any addresses that don't have any, + # this avoids situation where we're getting status updates to addresses we know + # need to update anyways. Continue to get history and create more addresses until + # all missing addresses are created and history for them is fully restored. + account.ensure_enough_addresses() + addresses = list(account.addresses_without_history()) + while addresses: + yield defer.DeferredList([ + self.update_history(a) for a in addresses + ]) + addresses = account.ensure_enough_addresses() + + # By this point all of the addresses should be restored and we + # can now subscribe all of them to receive updates. + yield defer.DeferredList([ + self.subscribe_history(address) + for address in account.addresses + ]) + + @defer.inlineCallbacks + def update_history(self, address): + history = yield self.network.get_history(address) + for hash in map(itemgetter('tx_hash'), history): + transaction = self.get_transaction(hash) + if not transaction: + raw = yield self.network.get_transaction(hash) + transaction = self.transaction_class(unhexlify(raw)) + self.add_transaction(address, transaction) + + @defer.inlineCallbacks + def subscribe_history(self, address): + status = yield self.network.subscribe_address(address) + if status != self.get_status(address): + yield self.update_history(address) + + def process_status(self, response): + address, status = response + if status != self.get_status(address): + task.deferLater(reactor, 0, self.update_history, address) + + def broadcast(self, tx): + return self.network.broadcast(hexlify(tx.raw)) + + +class Headers: + + def __init__(self, ledger): + self.ledger = ledger + self._size = None + self._on_change_controller = StreamController() + self.on_changed = self._on_change_controller.stream + + @property + def path(self): + wallet_path = self.ledger.config.get('wallet_path', '') + filename = '{}_headers'.format(self.ledger.coin_class.get_id()) + return os.path.join(wallet_path, filename) + + def touch(self): + if not os.path.exists(self.path): + with open(self.path, 'wb'): + pass + + @property + def height(self): + return len(self) - 1 + + def sync_read_length(self): + return os.path.getsize(self.path) // self.ledger.header_size + + def sync_read_header(self, height): + if 0 <= height < len(self): + with open(self.path, 'rb') as f: + f.seek(height * self.ledger.header_size) + return f.read(self.ledger.header_size) + + def __len__(self): + if self._size is None: + self._size = self.sync_read_length() + return self._size + + def __getitem__(self, height): + assert not isinstance(height, slice),\ + "Slicing of header chain has not been implemented yet." + header = self.sync_read_header(height) + return self._deserialize(height, header) + + @execute_serially + @defer.inlineCallbacks + def connect(self, start, headers): + yield threads.deferToThread(self._sync_connect, start, headers) + + def _sync_connect(self, start, headers): + previous_header = None + for header in self._iterate_headers(start, headers): + height = header['block_height'] + if previous_header is None and height > 0: + previous_header = self[height-1] + self._verify_header(height, header, previous_header) + previous_header = header + + with open(self.path, 'r+b') as f: + f.seek(start * self.ledger.header_size) + f.write(headers) + f.truncate() + + _old_size = self._size + self._size = self.sync_read_length() + change = self._size - _old_size + #log.info('saved {} header blocks'.format(change)) + self._on_change_controller.add(change) + + def _iterate_headers(self, height, headers): + assert len(headers) % self.ledger.header_size == 0 + for idx in range(len(headers) // self.ledger.header_size): + start, end = idx * self.ledger.header_size, (idx + 1) * self.ledger.header_size + header = headers[start:end] + yield self._deserialize(height+idx, header) + + def _verify_header(self, height, header, previous_header): + previous_hash = self._hash_header(previous_header) + assert previous_hash == header['prev_block_hash'], \ + "prev hash mismatch: {} vs {}".format(previous_hash, header['prev_block_hash']) + + bits, target = self._calculate_lbry_next_work_required(height, previous_header, header) + assert bits == header['bits'], \ + "bits mismatch: {} vs {} (hash: {})".format( + bits, header['bits'], self._hash_header(header)) + + _pow_hash = self._pow_hash_header(header) + assert int(b'0x' + _pow_hash, 16) <= target, \ + "insufficient proof of work: {} vs target {}".format( + int(b'0x' + _pow_hash, 16), target) + + @staticmethod + def _serialize(header): + return b''.join([ + int_to_hex(header['version'], 4), + rev_hex(header['prev_block_hash']), + rev_hex(header['merkle_root']), + rev_hex(header['claim_trie_root']), + int_to_hex(int(header['timestamp']), 4), + int_to_hex(int(header['bits']), 4), + int_to_hex(int(header['nonce']), 4) + ]) + + @staticmethod + def _deserialize(height, header): + return { + 'version': hex_to_int(header[0:4]), + 'prev_block_hash': hash_encode(header[4:36]), + 'merkle_root': hash_encode(header[36:68]), + 'claim_trie_root': hash_encode(header[68:100]), + 'timestamp': hex_to_int(header[100:104]), + 'bits': hex_to_int(header[104:108]), + 'nonce': hex_to_int(header[108:112]), + 'block_height': height + } + + def _hash_header(self, header): + if header is None: + return b'0' * 64 + return hash_encode(double_sha256(unhexlify(self._serialize(header)))) + + def _pow_hash_header(self, header): + if header is None: + return b'0' * 64 + return hash_encode(pow_hash(unhexlify(self._serialize(header)))) + + def _calculate_lbry_next_work_required(self, height, first, last): + """ See: lbrycrd/src/lbry.cpp """ + + if height == 0: + return self.ledger.genesis_bits, self.ledger.max_target + + if self.ledger.verify_bits_to_target: + bits = last['bits'] + bitsN = (bits >> 24) & 0xff + assert 0x03 <= bitsN <= 0x1f, \ + "First part of bits should be in [0x03, 0x1d], but it was {}".format(hex(bitsN)) + bitsBase = bits & 0xffffff + assert 0x8000 <= bitsBase <= 0x7fffff, \ + "Second part of bits should be in [0x8000, 0x7fffff] but it was {}".format(bitsBase) + + # new target + retargetTimespan = self.ledger.target_timespan + nActualTimespan = last['timestamp'] - first['timestamp'] + + nModulatedTimespan = retargetTimespan + (nActualTimespan - retargetTimespan) // 8 + + nMinTimespan = retargetTimespan - (retargetTimespan // 8) + nMaxTimespan = retargetTimespan + (retargetTimespan // 2) + + # Limit adjustment step + if nModulatedTimespan < nMinTimespan: + nModulatedTimespan = nMinTimespan + elif nModulatedTimespan > nMaxTimespan: + nModulatedTimespan = nMaxTimespan + + # Retarget + bnPowLimit = _ArithUint256(self.ledger.max_target) + bnNew = _ArithUint256.SetCompact(last['bits']) + bnNew *= nModulatedTimespan + bnNew //= nModulatedTimespan + if bnNew > bnPowLimit: + bnNew = bnPowLimit + + return bnNew.GetCompact(), bnNew._value + + +class _ArithUint256: + """ See: lbrycrd/src/arith_uint256.cpp """ + + def __init__(self, value): + self._value = value + + def __str__(self): + return hex(self._value) + + @staticmethod + def fromCompact(nCompact): + """Convert a compact representation into its value""" + nSize = nCompact >> 24 + # the lower 23 bits + nWord = nCompact & 0x007fffff + if nSize <= 3: + return nWord >> 8 * (3 - nSize) + else: + return nWord << 8 * (nSize - 3) + + @classmethod + def SetCompact(cls, nCompact): + return cls(cls.fromCompact(nCompact)) + + def bits(self): + """Returns the position of the highest bit set plus one.""" + bn = bin(self._value)[2:] + for i, d in enumerate(bn): + if d: + return (len(bn) - i) + 1 + return 0 + + def GetLow64(self): + return self._value & 0xffffffffffffffff + + def GetCompact(self): + """Convert a value into its compact representation""" + nSize = (self.bits() + 7) // 8 + nCompact = 0 + if nSize <= 3: + nCompact = self.GetLow64() << 8 * (3 - nSize) + else: + bn = _ArithUint256(self._value >> 8 * (nSize - 3)) + nCompact = bn.GetLow64() + # The 0x00800000 bit denotes the sign. + # Thus, if it is already set, divide the mantissa by 256 and increase the exponent. + if nCompact & 0x00800000: + nCompact >>= 8 + nSize += 1 + assert (nCompact & ~0x007fffff) == 0 + assert nSize < 256 + nCompact |= nSize << 24 + return nCompact + + def __mul__(self, x): + # Take the mod because we are limited to an unsigned 256 bit number + return _ArithUint256((self._value * x) % 2 ** 256) + + def __ifloordiv__(self, x): + self._value = (self._value // x) + return self + + def __gt__(self, x): + return self._value > x._value diff --git a/torba/basenetwork.py b/torba/basenetwork.py new file mode 100644 index 000000000..2d45a2a2d --- /dev/null +++ b/torba/basenetwork.py @@ -0,0 +1,221 @@ +import six +import json +import socket +import logging +from itertools import cycle +from twisted.internet import defer, reactor, protocol +from twisted.application.internet import ClientService, CancelledError +from twisted.internet.endpoints import clientFromString +from twisted.protocols.basic import LineOnlyReceiver + +from torba import __version__ +from torba.stream import StreamController + +log = logging.getLogger() + + +def unicode2bytes(string): + if isinstance(string, six.text_type): + return string.encode('iso-8859-1') + elif isinstance(string, list): + return [unicode2bytes(s) for s in string] + return string + + +def bytes2unicode(maybe_bytes): + if isinstance(maybe_bytes, bytes): + return maybe_bytes.decode() + elif isinstance(maybe_bytes, list): + return [bytes2unicode(b) for b in maybe_bytes] + return maybe_bytes + + +class StratumClientProtocol(LineOnlyReceiver): + delimiter = b'\n' + MAX_LENGTH = 100000 + + def __init__(self): + self.request_id = 0 + self.lookup_table = {} + self.session = {} + + self.on_disconnected_controller = StreamController() + self.on_disconnected = self.on_disconnected_controller.stream + + def _get_id(self): + self.request_id += 1 + return self.request_id + + @property + def _ip(self): + return self.transport.getPeer().host + + def get_session(self): + return self.session + + def connectionMade(self): + try: + self.transport.setTcpNoDelay(True) + self.transport.setTcpKeepAlive(True) + self.transport.socket.setsockopt( + socket.SOL_TCP, socket.TCP_KEEPIDLE, 120 + # Seconds before sending keepalive probes + ) + self.transport.socket.setsockopt( + socket.SOL_TCP, socket.TCP_KEEPINTVL, 1 + # Interval in seconds between keepalive probes + ) + self.transport.socket.setsockopt( + socket.SOL_TCP, socket.TCP_KEEPCNT, 5 + # Failed keepalive probles before declaring other end dead + ) + except Exception as err: + # Supported only by the socket transport, + # but there's really no better place in code to trigger this. + log.warning("Error setting up socket: %s", err) + + def connectionLost(self, reason=None): + self.on_disconnected_controller.add(True) + + def lineReceived(self, line): + + try: + # `line` comes in as a byte string but `json.loads` automatically converts everything to + # unicode. For keys it's not a big deal but for values there is an expectation + # everywhere else in wallet code that most values are byte strings. + message = json.loads( + line, object_hook=lambda obj: { + k: unicode2bytes(v) for k, v in obj.items() + } + ) + except (ValueError, TypeError): + raise ValueError("Cannot decode message '{}'".format(line.strip())) + + if message.get('id'): + try: + d = self.lookup_table.pop(message['id']) + if message.get('error'): + d.errback(RuntimeError(*message['error'])) + else: + d.callback(message.get('result')) + except KeyError: + raise LookupError( + "Lookup for deferred object for message ID '{}' failed.".format(message['id'])) + elif message.get('method') in self.network.subscription_controllers: + controller = self.network.subscription_controllers[message['method']] + controller.add(message.get('params')) + else: + log.warning("Cannot handle message '%s'" % line) + + def rpc(self, method, *args): + message_id = self._get_id() + message = json.dumps({ + 'id': message_id, + 'method': method, + 'params': [bytes2unicode(arg) for arg in args] + }) + self.sendLine(message.encode('latin-1')) + d = self.lookup_table[message_id] = defer.Deferred() + return d + + +class StratumClientFactory(protocol.ClientFactory): + + protocol = StratumClientProtocol + + def __init__(self, network): + self.network = network + self.client = None + + def buildProtocol(self, addr): + client = self.protocol() + client.factory = self + client.network = self.network + self.client = client + return client + + +class BaseNetwork: + + def __init__(self, config): + self.config = config + self.client = None + self.service = None + self.running = False + + self._on_connected_controller = StreamController() + self.on_connected = self._on_connected_controller.stream + + self._on_header_controller = StreamController() + self.on_header = self._on_header_controller.stream + + self._on_status_controller = StreamController() + self.on_status = self._on_status_controller.stream + + self.subscription_controllers = { + b'blockchain.headers.subscribe': self._on_header_controller, + b'blockchain.address.subscribe': self._on_status_controller, + } + + @defer.inlineCallbacks + def start(self): + for server in cycle(self.config['default_servers']): + endpoint = clientFromString(reactor, 'tcp:{}:{}'.format(*server)) + self.service = ClientService(endpoint, StratumClientFactory(self)) + self.service.startService() + try: + self.client = yield self.service.whenConnected(failAfterFailures=2) + yield self.ensure_server_version() + self._on_connected_controller.add(True) + yield self.client.on_disconnected.first + except CancelledError: + return + except Exception as e: + pass + finally: + self.client = None + if not self.running: + return + + def stop(self): + self.running = False + if self.service is not None: + self.service.stopService() + if self.is_connected: + return self.client.on_disconnected.first + else: + return defer.succeed(True) + + @property + def is_connected(self): + return self.client is not None and self.client.connected + + def rpc(self, list_or_method, *args): + if self.is_connected: + return self.client.rpc(list_or_method, *args) + else: + raise ConnectionError("Attempting to send rpc request when connection is not available.") + + def ensure_server_version(self, required='1.2'): + return self.rpc('server.version', __version__, required) + + def broadcast(self, raw_transaction): + return self.rpc('blockchain.transaction.broadcast', raw_transaction) + + def get_history(self, address): + return self.rpc('blockchain.address.get_history', address) + + def get_transaction(self, tx_hash): + return self.rpc('blockchain.transaction.get', tx_hash) + + def get_merkle(self, tx_hash, height): + return self.rpc('blockchain.transaction.get_merkle', tx_hash, height) + + def get_headers(self, height, count=10000): + return self.rpc('blockchain.block.headers', height, count) + + def subscribe_headers(self): + return self.rpc('blockchain.headers.subscribe', True) + + def subscribe_address(self, address): + return self.rpc('blockchain.address.subscribe', address) diff --git a/torba/basescript.py b/torba/basescript.py new file mode 100644 index 000000000..4cacf6e47 --- /dev/null +++ b/torba/basescript.py @@ -0,0 +1,407 @@ +from itertools import chain +from binascii import hexlify +from collections import namedtuple + +from torba.bcd_data_stream import BCDataStream +from torba.util import subclass_tuple + +# bitcoin opcodes +OP_0 = 0x00 +OP_1 = 0x51 +OP_16 = 0x60 +OP_DUP = 0x76 +OP_HASH160 = 0xa9 +OP_EQUALVERIFY = 0x88 +OP_CHECKSIG = 0xac +OP_CHECKMULTISIG = 0xae +OP_EQUAL = 0x87 +OP_PUSHDATA1 = 0x4c +OP_PUSHDATA2 = 0x4d +OP_PUSHDATA4 = 0x4e +OP_RETURN = 0x6a +OP_2DROP = 0x6d +OP_DROP = 0x75 + + +# template matching opcodes (not real opcodes) +# base class for PUSH_DATA related opcodes +PUSH_DATA_OP = namedtuple('PUSH_DATA_OP', 'name') +# opcode for variable length strings +PUSH_SINGLE = subclass_tuple('PUSH_SINGLE', PUSH_DATA_OP) +# opcode for variable number of variable length strings +PUSH_MANY = subclass_tuple('PUSH_MANY', PUSH_DATA_OP) +# opcode with embedded subscript parsing +PUSH_SUBSCRIPT = namedtuple('PUSH_SUBSCRIPT', 'name template') + + +def is_push_data_opcode(opcode): + return isinstance(opcode, PUSH_DATA_OP) or isinstance(opcode, PUSH_SUBSCRIPT) + + +def is_push_data_token(token): + return 1 <= token <= OP_PUSHDATA4 + + +def push_data(data): + size = len(data) + if size < OP_PUSHDATA1: + yield BCDataStream.uint8.pack(size) + elif size <= 0xFF: + yield BCDataStream.uint8.pack(OP_PUSHDATA1) + yield BCDataStream.uint8.pack(size) + elif size <= 0xFFFF: + yield BCDataStream.uint8.pack(OP_PUSHDATA2) + yield BCDataStream.uint16.pack(size) + else: + yield BCDataStream.uint8.pack(OP_PUSHDATA4) + yield BCDataStream.uint32.pack(size) + yield data + + +def read_data(token, stream): + if token < OP_PUSHDATA1: + return stream.read(token) + elif token == OP_PUSHDATA1: + return stream.read(stream.read_uint8()) + elif token == OP_PUSHDATA2: + return stream.read(stream.read_uint16()) + else: + return stream.read(stream.read_uint32()) + + +# opcode for OP_1 - OP_16 +SMALL_INTEGER = namedtuple('SMALL_INTEGER', 'name') + + +def is_small_integer(token): + return OP_1 <= token <= OP_16 + + +def push_small_integer(num): + assert 1 <= num <= 16 + yield BCDataStream.uint8.pack(OP_1 + (num - 1)) + + +def read_small_integer(token): + return (token - OP_1) + 1 + + +class Token(namedtuple('Token', 'value')): + __slots__ = () + + def __repr__(self): + name = None + for var_name, var_value in globals().items(): + if var_name.startswith('OP_') and var_value == self.value: + name = var_name + break + return name or self.value + + +class DataToken(Token): + __slots__ = () + + def __repr__(self): + return '"{}"'.format(hexlify(self.value)) + + +class SmallIntegerToken(Token): + __slots__ = () + + def __repr__(self): + return 'SmallIntegerToken({})'.format(self.value) + + +def token_producer(source): + token = source.read_uint8() + while token is not None: + if is_push_data_token(token): + yield DataToken(read_data(token, source)) + elif is_small_integer(token): + yield SmallIntegerToken(read_small_integer(token)) + else: + yield Token(token) + token = source.read_uint8() + + +def tokenize(source): + return list(token_producer(source)) + + +class ScriptError(Exception): + """ General script handling error. """ + + +class ParseError(ScriptError): + """ Script parsing error. """ + + +class Parser: + + def __init__(self, opcodes, tokens): + self.opcodes = opcodes + self.tokens = tokens + self.values = {} + self.token_index = 0 + self.opcode_index = 0 + + def parse(self): + while self.token_index < len(self.tokens) and self.opcode_index < len(self.opcodes): + token = self.tokens[self.token_index] + opcode = self.opcodes[self.opcode_index] + if isinstance(token, DataToken): + if isinstance(opcode, (PUSH_SINGLE, PUSH_SUBSCRIPT)): + self.push_single(opcode, token.value) + elif isinstance(opcode, PUSH_MANY): + self.consume_many_non_greedy() + else: + raise ParseError("DataToken found but opcode was '{}'.".format(opcode)) + elif isinstance(token, SmallIntegerToken): + if isinstance(opcode, SMALL_INTEGER): + self.values[opcode.name] = token.value + else: + raise ParseError("SmallIntegerToken found but opcode was '{}'.".format(opcode)) + elif token.value == opcode: + pass + else: + raise ParseError("Token is '{}' and opcode is '{}'.".format(token.value, opcode)) + self.token_index += 1 + self.opcode_index += 1 + + if self.token_index < len(self.tokens): + raise ParseError("Parse completed without all tokens being consumed.") + + if self.opcode_index < len(self.opcodes): + raise ParseError("Parse completed without all opcodes being consumed.") + + return self + + def consume_many_non_greedy(self): + """ Allows PUSH_MANY to consume data without being greedy + in cases when one or more PUSH_SINGLEs follow a PUSH_MANY. This will + prioritize giving all PUSH_SINGLEs some data and only after that + subsume the rest into PUSH_MANY. + """ + + token_values = [] + while self.token_index < len(self.tokens): + token = self.tokens[self.token_index] + if not isinstance(token, DataToken): + self.token_index -= 1 + break + token_values.append(token.value) + self.token_index += 1 + + push_opcodes = [] + push_many_count = 0 + while self.opcode_index < len(self.opcodes): + opcode = self.opcodes[self.opcode_index] + if not is_push_data_opcode(opcode): + self.opcode_index -= 1 + break + if isinstance(opcode, PUSH_MANY): + push_many_count += 1 + push_opcodes.append(opcode) + self.opcode_index += 1 + + if push_many_count > 1: + raise ParseError( + "Cannot have more than one consecutive PUSH_MANY, as there is no way to tell which" + " token value should go into which PUSH_MANY." + ) + + if len(push_opcodes) > len(token_values): + raise ParseError( + "Not enough token values to match all of the PUSH_MANY and PUSH_SINGLE opcodes." + ) + + many_opcode = push_opcodes.pop(0) + + # consume data into PUSH_SINGLE opcodes, working backwards + for opcode in reversed(push_opcodes): + self.push_single(opcode, token_values.pop()) + + # finally PUSH_MANY gets everything that's left + self.values[many_opcode.name] = token_values + + def push_single(self, opcode, value): + if isinstance(opcode, PUSH_SINGLE): + self.values[opcode.name] = value + elif isinstance(opcode, PUSH_SUBSCRIPT): + self.values[opcode.name] = Script.from_source_with_template(value, opcode.template) + else: + raise ParseError("Not a push single or subscript: {}".format(opcode)) + + +class Template(object): + + __slots__ = 'name', 'opcodes' + + def __init__(self, name, opcodes): + self.name = name + self.opcodes = opcodes + + def parse(self, tokens): + return Parser(self.opcodes, tokens).parse().values + + def generate(self, values): + source = BCDataStream() + for opcode in self.opcodes: + if isinstance(opcode, PUSH_SINGLE): + data = values[opcode.name] + source.write_many(push_data(data)) + elif isinstance(opcode, PUSH_SUBSCRIPT): + data = values[opcode.name] + source.write_many(push_data(data.source)) + elif isinstance(opcode, PUSH_MANY): + for data in values[opcode.name]: + source.write_many(push_data(data)) + elif isinstance(opcode, SMALL_INTEGER): + data = values[opcode.name] + source.write_many(push_small_integer(data)) + else: + source.write_uint8(opcode) + return source.get_bytes() + + +class Script(object): + + __slots__ = 'source', 'template', 'values' + + templates = [] + + def __init__(self, source=None, template=None, values=None, template_hint=None): + self.source = source + self.template = template + self.values = values + if source: + self.parse(template_hint) + elif template and values: + self.generate() + + @property + def tokens(self): + return tokenize(BCDataStream(self.source)) + + @classmethod + def from_source_with_template(cls, source, template): + return cls(source, template_hint=template) + + def parse(self, template_hint=None): + tokens = self.tokens + for template in chain((template_hint,), self.templates): + if not template: + continue + try: + self.values = template.parse(tokens) + self.template = template + return + except ParseError: + continue + raise ValueError('No matching templates for source: {}'.format(hexlify(self.source))) + + def generate(self): + self.source = self.template.generate(self.values) + + +class BaseInputScript(Script): + """ Input / redeem script templates (aka scriptSig) """ + + __slots__ = () + + REDEEM_PUBKEY = Template('pubkey', ( + PUSH_SINGLE('signature'), + )) + REDEEM_PUBKEY_HASH = Template('pubkey_hash', ( + PUSH_SINGLE('signature'), PUSH_SINGLE('pubkey') + )) + REDEEM_SCRIPT = Template('script', ( + SMALL_INTEGER('signatures_count'), PUSH_MANY('pubkeys'), SMALL_INTEGER('pubkeys_count'), + OP_CHECKMULTISIG + )) + REDEEM_SCRIPT_HASH = Template('script_hash', ( + OP_0, PUSH_MANY('signatures'), PUSH_SUBSCRIPT('script', REDEEM_SCRIPT) + )) + + templates = [ + REDEEM_PUBKEY, + REDEEM_PUBKEY_HASH, + REDEEM_SCRIPT_HASH, + REDEEM_SCRIPT + ] + + @classmethod + def redeem_pubkey_hash(cls, signature, pubkey): + return cls(template=cls.REDEEM_PUBKEY_HASH, values={ + 'signature': signature, + 'pubkey': pubkey + }) + + @classmethod + def redeem_script_hash(cls, signatures, pubkeys): + return cls(template=cls.REDEEM_SCRIPT_HASH, values={ + 'signatures': signatures, + 'script': cls.redeem_script(signatures, pubkeys) + }) + + @classmethod + def redeem_script(cls, signatures, pubkeys): + return cls(template=cls.REDEEM_SCRIPT, values={ + 'signatures_count': len(signatures), + 'pubkeys': pubkeys, + 'pubkeys_count': len(pubkeys) + }) + + +class BaseOutputScript(Script): + + __slots__ = () + + # output / payment script templates (aka scriptPubKey) + PAY_PUBKEY_FULL = Template('pay_pubkey_full', ( + PUSH_SINGLE('pubkey'), OP_CHECKSIG + )) + PAY_PUBKEY_HASH = Template('pay_pubkey_hash', ( + OP_DUP, OP_HASH160, PUSH_SINGLE('pubkey_hash'), OP_EQUALVERIFY, OP_CHECKSIG + )) + PAY_SCRIPT_HASH = Template('pay_script_hash', ( + OP_HASH160, PUSH_SINGLE('script_hash'), OP_EQUAL + )) + RETURN_DATA = Template('return_data', ( + OP_RETURN, PUSH_SINGLE('data') + )) + + templates = [ + PAY_PUBKEY_FULL, + PAY_PUBKEY_HASH, + PAY_SCRIPT_HASH, + RETURN_DATA + ] + + @classmethod + def pay_pubkey_hash(cls, pubkey_hash): + return cls(template=cls.PAY_PUBKEY_HASH, values={ + 'pubkey_hash': pubkey_hash + }) + + @classmethod + def pay_script_hash(cls, script_hash): + return cls(template=cls.PAY_SCRIPT_HASH, values={ + 'script_hash': script_hash + }) + + @property + def is_pay_pubkey(self): + return self.template.name.endswith('pay_pubkey_full') + + @property + def is_pay_pubkey_hash(self): + return self.template.name.endswith('pay_pubkey_hash') + + @property + def is_pay_script_hash(self): + return self.template.name.endswith('pay_script_hash') + + @property + def is_return_data(self): + return self.template.name.endswith('return_data') diff --git a/torba/basetransaction.py b/torba/basetransaction.py new file mode 100644 index 000000000..af854e970 --- /dev/null +++ b/torba/basetransaction.py @@ -0,0 +1,287 @@ +import six +import logging +from typing import List +from collections import namedtuple + +from torba.basecoin import BaseCoin +from torba.basescript import BaseInputScript, BaseOutputScript +from torba.bcd_data_stream import BCDataStream +from torba.hash import sha256 +from torba.account import Account +from torba.util import ReadOnlyList + + +log = logging.getLogger() + + +NULL_HASH = b'\x00'*32 + + +class InputOutput(object): + + @property + def size(self): + """ Size of this input / output in bytes. """ + stream = BCDataStream() + self.serialize_to(stream) + return len(stream.get_bytes()) + + def serialize_to(self, stream): + raise NotImplemented + + +class BaseInput(InputOutput): + + script_class = None + + NULL_SIGNATURE = b'\x00'*72 + NULL_PUBLIC_KEY = b'\x00'*33 + + def __init__(self, output_or_txid_index, script, sequence=0xFFFFFFFF): + if isinstance(output_or_txid_index, BaseOutput): + self.output = output_or_txid_index # type: BaseOutput + self.output_txid = self.output.transaction.hash + self.output_index = self.output.index + else: + self.output = None # type: BaseOutput + self.output_txid, self.output_index = output_or_txid_index + self.sequence = sequence + self.is_coinbase = self.output_txid == NULL_HASH + self.coinbase = script if self.is_coinbase else None + self.script = script if not self.is_coinbase else None # type: BaseInputScript + + def link_output(self, output): + assert self.output is None + assert self.output_txid == output.transaction.hash + assert self.output_index == output.index + self.output = output + + @classmethod + def spend(cls, output): + """ Create an input to spend the output.""" + assert output.script.is_pay_pubkey_hash, 'Attempting to spend unsupported output.' + script = cls.script_class.redeem_pubkey_hash(cls.NULL_SIGNATURE, cls.NULL_PUBLIC_KEY) + return cls(output, script) + + @property + def amount(self): + """ Amount this input adds to the transaction. """ + if self.output is None: + raise ValueError('Cannot get input value without referenced output.') + return self.output.amount + + @classmethod + def deserialize_from(cls, stream): + txid = stream.read(32) + index = stream.read_uint32() + script = stream.read_string() + sequence = stream.read_uint32() + return cls( + (txid, index), + cls.script_class(script) if not txid == NULL_HASH else script, + sequence + ) + + def serialize_to(self, stream, alternate_script=None): + stream.write(self.output_txid) + stream.write_uint32(self.output_index) + if alternate_script is not None: + stream.write_string(alternate_script) + else: + if self.is_coinbase: + stream.write_string(self.coinbase) + else: + stream.write_string(self.script.source) + stream.write_uint32(self.sequence) + + +class BaseOutputAmountEstimator(object): + + __slots__ = 'coin', 'output', 'fee', 'effective_amount' + + def __init__(self, coin, txo): # type: (BaseCoin, BaseOutput) -> None + self.coin = coin + self.output = txo + txi = coin.transaction_class.input_class.spend(txo) + self.fee = coin.get_input_output_fee(txi) + self.effective_amount = txo.amount - self.fee + + def __lt__(self, other): + return self.effective_amount < other.effective_amount + + +class BaseOutput(InputOutput): + + script_class = None + estimator_class = BaseOutputAmountEstimator + + def __init__(self, amount, script): + self.amount = amount # type: int + self.script = script # type: BaseOutputScript + self.transaction = None # type: BaseTransaction + self.index = None # type: int + + def get_estimator(self, coin): + return self.estimator_class(coin, self) + + @classmethod + def pay_pubkey_hash(cls, amount, pubkey_hash): + return cls(amount, cls.script_class.pay_pubkey_hash(pubkey_hash)) + + @classmethod + def deserialize_from(cls, stream): + return cls( + amount=stream.read_uint64(), + script=cls.script_class(stream.read_string()) + ) + + def serialize_to(self, stream): + stream.write_uint64(self.amount) + stream.write_string(self.script.source) + + +class BaseTransaction: + + input_class = None + output_class = None + + def __init__(self, raw=None, version=1, locktime=0, height=None, is_saved=False): + self._raw = raw + self._hash = None + self._id = None + self.version = version # type: int + self.locktime = locktime # type: int + self.height = height # type: int + self._inputs = [] # type: List[BaseInput] + self._outputs = [] # type: List[BaseOutput] + self.is_saved = is_saved # type: bool + if raw is not None: + self._deserialize() + + @property + def id(self): + if self._id is None: + self._id = self.hash[::-1] + return self._id + + @property + def hash(self): + if self._hash is None: + self._hash = sha256(sha256(self.raw)) + return self._hash + + @property + def raw(self): + if self._raw is None: + self._raw = self._serialize() + return self._raw + + def _reset(self): + self._id = None + self._hash = None + self._raw = None + + @property + def inputs(self): # type: () -> ReadOnlyList[BaseInput] + return ReadOnlyList(self._inputs) + + @property + def outputs(self): # type: () -> ReadOnlyList[BaseOutput] + return ReadOnlyList(self._outputs) + + def add_inputs(self, inputs): + self._inputs.extend(inputs) + self._reset() + return self + + def add_outputs(self, outputs): + for txo in outputs: + txo.transaction = self + txo.index = len(self._outputs) + self._outputs.append(txo) + self._reset() + return self + + @property + def fee(self): + """ Fee that will actually be paid.""" + return self.input_sum - self.output_sum + + @property + def size(self): + """ Size in bytes of the entire transaction. """ + return len(self.raw) + + @property + def base_size(self): + """ Size in bytes of transaction meta data and all outputs; without inputs. """ + return len(self._serialize(with_inputs=False)) + + def _serialize(self, with_inputs=True): + stream = BCDataStream() + stream.write_uint32(self.version) + if with_inputs: + stream.write_compact_size(len(self._inputs)) + for txin in self._inputs: + txin.serialize_to(stream) + stream.write_compact_size(len(self._outputs)) + for txout in self._outputs: + txout.serialize_to(stream) + stream.write_uint32(self.locktime) + return stream.get_bytes() + + def _serialize_for_signature(self, signing_input): + stream = BCDataStream() + stream.write_uint32(self.version) + stream.write_compact_size(len(self._inputs)) + for i, txin in enumerate(self._inputs): + if signing_input == i: + txin.serialize_to(stream, txin.output.script.source) + else: + txin.serialize_to(stream, b'') + stream.write_compact_size(len(self._outputs)) + for txout in self._outputs: + txout.serialize_to(stream) + stream.write_uint32(self.locktime) + stream.write_uint32(1) # signature hash type: SIGHASH_ALL + return stream.get_bytes() + + def _deserialize(self): + if self._raw is not None: + stream = BCDataStream(self._raw) + self.version = stream.read_uint32() + input_count = stream.read_compact_size() + self.add_inputs([ + self.input_class.deserialize_from(stream) for _ in range(input_count) + ]) + output_count = stream.read_compact_size() + self.add_outputs([ + self.output_class.deserialize_from(stream) for _ in range(output_count) + ]) + self.locktime = stream.read_uint32() + + def sign(self, account): # type: (Account) -> BaseTransaction + for i, txi in enumerate(self._inputs): + txo_script = txi.output.script + if txo_script.is_pay_pubkey_hash: + address = account.coin.hash160_to_address(txo_script.values['pubkey_hash']) + private_key = account.get_private_key_for_address(address) + tx = self._serialize_for_signature(i) + txi.script.values['signature'] = private_key.sign(tx)+six.int2byte(1) + txi.script.values['pubkey'] = private_key.public_key.pubkey_bytes + txi.script.generate() + self._reset() + return self + + def sort(self): + # See https://github.com/kristovatlas/rfc/blob/master/bips/bip-li01.mediawiki + self._inputs.sort(key=lambda i: (i['prevout_hash'], i['prevout_n'])) + self._outputs.sort(key=lambda o: (o[2], pay_script(o[0], o[1]))) + + @property + def input_sum(self): + return sum(i.amount for i in self._inputs) + + @property + def output_sum(self): + return sum(o.amount for o in self._outputs) diff --git a/torba/bcd_data_stream.py b/torba/bcd_data_stream.py new file mode 100644 index 000000000..1eb602015 --- /dev/null +++ b/torba/bcd_data_stream.py @@ -0,0 +1,126 @@ +import struct +from io import BytesIO + + +class BCDataStream: + + def __init__(self, data=None): + self.data = BytesIO(data) + + @property + def is_at_beginning(self): + return self.data.tell() == 0 + + def reset(self): + self.data.seek(0) + + def get_bytes(self): + return self.data.getvalue() + + def read(self, size): + return self.data.read(size) + + def write(self, data): + self.data.write(data) + + def write_many(self, many): + self.data.writelines(many) + + def read_string(self): + return self.read(self.read_compact_size()) + + def write_string(self, s): + self.write_compact_size(len(s)) + self.write(s) + + def read_compact_size(self): + size = self.read_uint8() + if size < 253: + return size + if size == 253: + return self.read_uint16() + elif size == 254: + return self.read_uint32() + elif size == 255: + return self.read_uint64() + + def write_compact_size(self, size): + if size < 253: + self.write_uint8(size) + elif size <= 0xFFFF: + self.write_uint8(253) + self.write_uint16(size) + elif size <= 0xFFFFFFFF: + self.write_uint8(254) + self.write_uint32(size) + else: + self.write_uint8(255) + self.write_uint64(size) + + def read_boolean(self): + return self.read_uint8() != 0 + + def write_boolean(self, val): + return self.write_uint8(1 if val else 0) + + int8 = struct.Struct('b') + uint8 = struct.Struct('B') + int16 = struct.Struct(' 0: + return fmt.unpack(value)[0] + + def read_int8(self): + return self._read_struct(self.int8) + + def read_uint8(self): + return self._read_struct(self.uint8) + + def read_int16(self): + return self._read_struct(self.int16) + + def read_uint16(self): + return self._read_struct(self.uint16) + + def read_int32(self): + return self._read_struct(self.int32) + + def read_uint32(self): + return self._read_struct(self.uint32) + + def read_int64(self): + return self._read_struct(self.int64) + + def read_uint64(self): + return self._read_struct(self.uint64) + + def write_int8(self, val): + self.write(self.int8.pack(val)) + + def write_uint8(self, val): + self.write(self.uint8.pack(val)) + + def write_int16(self, val): + self.write(self.int16.pack(val)) + + def write_uint16(self, val): + self.write(self.uint16.pack(val)) + + def write_int32(self, val): + self.write(self.int32.pack(val)) + + def write_uint32(self, val): + self.write(self.uint32.pack(val)) + + def write_int64(self, val): + self.write(self.int64.pack(val)) + + def write_uint64(self, val): + self.write(self.uint64.pack(val)) diff --git a/torba/bip32.py b/torba/bip32.py new file mode 100644 index 000000000..bb65a51af --- /dev/null +++ b/torba/bip32.py @@ -0,0 +1,329 @@ +# Copyright (c) 2017, Neil Booth +# Copyright (c) 2018, LBRY Inc. +# +# All rights reserved. +# +# See the file "LICENCE" for information about the copyright +# and warranty status of this software. + +""" Logic for BIP32 Hierarchical Key Derivation. """ + +import struct +import hashlib +from six import int2byte, byte2int, indexbytes + +import ecdsa +import ecdsa.ellipticcurve as EC +import ecdsa.numbertheory as NT + +from torba.basecoin import BaseCoin +from torba.hash import Base58, hmac_sha512, hash160, double_sha256 +from torba.util import cachedproperty, bytes_to_int, int_to_bytes + + +class DerivationError(Exception): + """ Raised when an invalid derivation occurs. """ + + +class _KeyBase(object): + """ A BIP32 Key, public or private. """ + + CURVE = ecdsa.SECP256k1 + + def __init__(self, coin, chain_code, n, depth, parent): + if not isinstance(coin, BaseCoin): + raise TypeError('invalid coin') + if not isinstance(chain_code, (bytes, bytearray)): + raise TypeError('chain code must be raw bytes') + if len(chain_code) != 32: + raise ValueError('invalid chain code') + if not 0 <= n < 1 << 32: + raise ValueError('invalid child number') + if not 0 <= depth < 256: + raise ValueError('invalid depth') + if parent is not None: + if not isinstance(parent, type(self)): + raise TypeError('parent key has bad type') + self.coin = coin + self.chain_code = chain_code + self.n = n + self.depth = depth + self.parent = parent + + def _hmac_sha512(self, msg): + """ Use SHA-512 to provide an HMAC, returned as a pair of 32-byte objects. """ + hmac = hmac_sha512(self.chain_code, msg) + return hmac[:32], hmac[32:] + + def _extended_key(self, ver_bytes, raw_serkey): + """ Return the 78-byte extended key given prefix version bytes and serialized key bytes. """ + if not isinstance(ver_bytes, (bytes, bytearray)): + raise TypeError('ver_bytes must be raw bytes') + if len(ver_bytes) != 4: + raise ValueError('ver_bytes must have length 4') + if not isinstance(raw_serkey, (bytes, bytearray)): + raise TypeError('raw_serkey must be raw bytes') + if len(raw_serkey) != 33: + raise ValueError('raw_serkey must have length 33') + + return (ver_bytes + int2byte(self.depth) + + self.parent_fingerprint() + struct.pack('>I', self.n) + + self.chain_code + raw_serkey) + + def fingerprint(self): + """ Return the key's fingerprint as 4 bytes. """ + return self.identifier()[:4] + + def parent_fingerprint(self): + """ Return the parent key's fingerprint as 4 bytes. """ + return self.parent.fingerprint() if self.parent else int2byte(0)*4 + + def extended_key_string(self): + """ Return an extended key as a base58 string. """ + return Base58.encode_check(self.extended_key()) + + +class PubKey(_KeyBase): + """ A BIP32 public key. """ + + def __init__(self, coin, pubkey, chain_code, n, depth, parent=None): + super(PubKey, self).__init__(coin, chain_code, n, depth, parent) + if isinstance(pubkey, ecdsa.VerifyingKey): + self.verifying_key = pubkey + else: + self.verifying_key = self._verifying_key_from_pubkey(pubkey) + + @classmethod + def _verifying_key_from_pubkey(cls, pubkey): + """ Converts a 33-byte compressed pubkey into an ecdsa.VerifyingKey object. """ + if not isinstance(pubkey, (bytes, bytearray)): + raise TypeError('pubkey must be raw bytes') + if len(pubkey) != 33: + raise ValueError('pubkey must be 33 bytes') + if byte2int(pubkey[0]) not in (2, 3): + raise ValueError('invalid pubkey prefix byte') + curve = cls.CURVE.curve + + is_odd = byte2int(pubkey[0]) == 3 + x = bytes_to_int(pubkey[1:]) + + # p is the finite field order + a, b, p = curve.a(), curve.b(), curve.p() + y2 = pow(x, 3, p) + b + assert a == 0 # Otherwise y2 += a * pow(x, 2, p) + y = NT.square_root_mod_prime(y2 % p, p) + if bool(y & 1) != is_odd: + y = p - y + point = EC.Point(curve, x, y) + + return ecdsa.VerifyingKey.from_public_point(point, curve=cls.CURVE) + + @cachedproperty + def pubkey_bytes(self): + """ Return the compressed public key as 33 bytes. """ + point = self.verifying_key.pubkey.point + prefix = int2byte(2 + (point.y() & 1)) + padded_bytes = _exponent_to_bytes(point.x()) + return prefix + padded_bytes + + @cachedproperty + def address(self): + """ The public key as a P2PKH address. """ + return self.coin.public_key_to_address(self.pubkey_bytes) + + def ec_point(self): + return self.verifying_key.pubkey.point + + def child(self, n): + """ Return the derived child extended pubkey at index N. """ + if not 0 <= n < (1 << 31): + raise ValueError('invalid BIP32 public key child number') + + msg = self.pubkey_bytes + struct.pack('>I', n) + L, R = self._hmac_sha512(msg) + + curve = self.CURVE + L = bytes_to_int(L) + if L >= curve.order: + raise DerivationError + + point = curve.generator * L + self.ec_point() + if point == EC.INFINITY: + raise DerivationError + + verkey = ecdsa.VerifyingKey.from_public_point(point, curve=curve) + + return PubKey(self.coin, verkey, R, n, self.depth + 1, self) + + def identifier(self): + """ Return the key's identifier as 20 bytes. """ + return hash160(self.pubkey_bytes) + + def extended_key(self): + """ Return a raw extended public key. """ + return self._extended_key( + self.coin.extended_public_key_prefix, + self.pubkey_bytes + ) + + +class LowSValueSigningKey(ecdsa.SigningKey): + """ + Enforce low S values in signatures + BIP-0062: https://github.com/bitcoin/bips/blob/master/bip-0062.mediawiki#low-s-values-in-signatures + """ + + def sign_number(self, number, entropy=None, k=None): + order = self.privkey.order + r, s = ecdsa.SigningKey.sign_number(self, number, entropy, k) + if s > order / 2: + s = order - s + return r, s + + +class PrivateKey(_KeyBase): + """A BIP32 private key.""" + + HARDENED = 1 << 31 + + def __init__(self, coin, privkey, chain_code, n, depth, parent=None): + super(PrivateKey, self).__init__(coin, chain_code, n, depth, parent) + if isinstance(privkey, ecdsa.SigningKey): + self.signing_key = privkey + else: + self.signing_key = self._signing_key_from_privkey(privkey) + + @classmethod + def _signing_key_from_privkey(cls, private_key): + """ Converts a 32-byte private key into an ecdsa.SigningKey object. """ + exponent = cls._private_key_secret_exponent(private_key) + return LowSValueSigningKey.from_secret_exponent(exponent, curve=cls.CURVE) + + @classmethod + def _private_key_secret_exponent(cls, private_key): + """ Return the private key as a secret exponent if it is a valid private key. """ + if not isinstance(private_key, (bytes, bytearray)): + raise TypeError('private key must be raw bytes') + if len(private_key) != 32: + raise ValueError('private key must be 32 bytes') + exponent = bytes_to_int(private_key) + if not 1 <= exponent < cls.CURVE.order: + raise ValueError('private key represents an invalid exponent') + return exponent + + @classmethod + def from_seed(cls, coin, seed): + # This hard-coded message string seems to be coin-independent... + hmac = hmac_sha512(b'Bitcoin seed', seed) + privkey, chain_code = hmac[:32], hmac[32:] + return cls(coin, privkey, chain_code, 0, 0) + + @cachedproperty + def private_key_bytes(self): + """ Return the serialized private key (no leading zero byte). """ + return _exponent_to_bytes(self.secret_exponent()) + + @cachedproperty + def public_key(self): + """ Return the corresponding extended public key. """ + verifying_key = self.signing_key.get_verifying_key() + parent_pubkey = self.parent.public_key if self.parent else None + return PubKey(self.coin, verifying_key, self.chain_code, self.n, self.depth, + parent_pubkey) + + def ec_point(self): + return self.public_key.ec_point() + + def secret_exponent(self): + """ Return the private key as a secret exponent. """ + return self.signing_key.privkey.secret_multiplier + + def wif(self): + """ Return the private key encoded in Wallet Import Format. """ + return self.coin.private_key_to_wif(self.private_key_bytes) + + def address(self): + """ The public key as a P2PKH address. """ + return self.public_key.address + + def child(self, n): + """ Return the derived child extended private key at index N.""" + if not 0 <= n < (1 << 32): + raise ValueError('invalid BIP32 private key child number') + + if n >= self.HARDENED: + serkey = b'\0' + self.private_key_bytes + else: + serkey = self.public_key.pubkey_bytes + + msg = serkey + struct.pack('>I', n) + L, R = self._hmac_sha512(msg) + + curve = self.CURVE + L = bytes_to_int(L) + exponent = (L + bytes_to_int(self.private_key_bytes)) % curve.order + if exponent == 0 or L >= curve.order: + raise DerivationError + + privkey = _exponent_to_bytes(exponent) + + return PrivateKey(self.coin, privkey, R, n, self.depth + 1, self) + + def sign(self, data): + """ Produce a signature for piece of data by double hashing it and signing the hash. """ + key = self.signing_key + digest = double_sha256(data) + return key.sign_digest_deterministic(digest, hashlib.sha256, ecdsa.util.sigencode_der) + + def identifier(self): + """Return the key's identifier as 20 bytes.""" + return self.public_key.identifier() + + def extended_key(self): + """Return a raw extended private key.""" + return self._extended_key( + self.coin.extended_private_key_prefix, + b'\0' + self.private_key_bytes + ) + + +def _exponent_to_bytes(exponent): + """Convert an exponent to 32 big-endian bytes""" + return (int2byte(0)*32 + int_to_bytes(exponent))[-32:] + + +def _from_extended_key(coin, ekey): + """Return a PubKey or PrivateKey from an extended key raw bytes.""" + if not isinstance(ekey, (bytes, bytearray)): + raise TypeError('extended key must be raw bytes') + if len(ekey) != 78: + raise ValueError('extended key must have length 78') + + depth = indexbytes(ekey, 4) + fingerprint = ekey[5:9] # Not used + n, = struct.unpack('>I', ekey[9:13]) + chain_code = ekey[13:45] + + if ekey[:4] == coin.extended_public_key_prefix: + pubkey = ekey[45:] + key = PubKey(coin, pubkey, chain_code, n, depth) + elif ekey[:4] == coin.extended_private_key_prefix: + if indexbytes(ekey, 45) != 0: + raise ValueError('invalid extended private key prefix byte') + privkey = ekey[46:] + key = PrivateKey(coin, privkey, chain_code, n, depth) + else: + raise ValueError('version bytes unrecognised') + + return key + + +def from_extended_key_string(coin, ekey_str): + """Given an extended key string, such as + + xpub6BsnM1W2Y7qLMiuhi7f7dbAwQZ5Cz5gYJCRzTNainXzQXYjFwtuQXHd + 3qfi3t3KJtHxshXezfjft93w4UE7BGMtKwhqEHae3ZA7d823DVrL + + return a PubKey or PrivateKey. + """ + return _from_extended_key(coin, Base58.decode_check(ekey_str)) diff --git a/torba/coin/__init__.py b/torba/coin/__init__.py new file mode 100644 index 000000000..69e3be50d --- /dev/null +++ b/torba/coin/__init__.py @@ -0,0 +1 @@ +__path__ = __import__('pkgutil').extend_path(__path__, __name__) diff --git a/torba/coin/btc.py b/torba/coin/btc.py new file mode 100644 index 000000000..d6f23127e --- /dev/null +++ b/torba/coin/btc.py @@ -0,0 +1,43 @@ +from six import int2byte +from binascii import unhexlify +from torba.baseledger import BaseLedger +from torba.basenetwork import BaseNetwork +from torba.basescript import BaseInputScript, BaseOutputScript +from torba.basetransaction import BaseTransaction, BaseInput, BaseOutput +from torba.basecoin import BaseCoin + + +class Ledger(BaseLedger): + network_class = BaseNetwork + + +class Input(BaseInput): + script_class = BaseInputScript + + +class Output(BaseOutput): + script_class = BaseOutputScript + + +class Transaction(BaseTransaction): + input_class = Input + output_class = Output + + +class BTC(BaseCoin): + name = 'Bitcoin' + symbol = 'BTC' + network = 'mainnet' + + ledger_class = Ledger + transaction_class = Transaction + + pubkey_address_prefix = int2byte(0x00) + script_address_prefix = int2byte(0x05) + extended_public_key_prefix = unhexlify('0488b21e') + extended_private_key_prefix = unhexlify('0488ade4') + + default_fee_per_byte = 50 + + def __init__(self, ledger, fee_per_byte=default_fee_per_byte): + super(BTC, self).__init__(ledger, fee_per_byte) diff --git a/torba/coinselection.py b/torba/coinselection.py new file mode 100644 index 000000000..c0bf38502 --- /dev/null +++ b/torba/coinselection.py @@ -0,0 +1,95 @@ +import six +from random import Random +from typing import List + +from torba.basetransaction import BaseOutputAmountEstimator + +MAXIMUM_TRIES = 100000 + + +class CoinSelector: + + def __init__(self, txos, target, cost_of_change, seed=None): + # type: (List[BaseOutputAmountEstimator], int, int, str) -> None + self.txos = txos + self.target = target + self.cost_of_change = cost_of_change + self.exact_match = False + self.tries = 0 + self.available = sum(c.effective_amount for c in self.txos) + self.random = Random(seed) + if six.PY3 and seed is not None: + self.random.seed(seed, version=1) + + def select(self): + if not self.txos: + return + if self.target > self.available: + return + return self.branch_and_bound() or self.single_random_draw() + + def branch_and_bound(self): + # see bitcoin implementation for more info: + # https://github.com/bitcoin/bitcoin/blob/master/src/wallet/coinselection.cpp + + self.txos.sort(reverse=True) + + current_value = 0 + current_available_value = self.available + current_selection = [] + best_waste = self.cost_of_change + best_selection = [] + + while self.tries < MAXIMUM_TRIES: + self.tries += 1 + + backtrack = False + if current_value + current_available_value < self.target or \ + current_value > self.target + self.cost_of_change: + backtrack = True + elif current_value >= self.target: + new_waste = current_value - self.target + if new_waste <= best_waste: + best_waste = new_waste + best_selection = current_selection[:] + backtrack = True + + if backtrack: + while current_selection and not current_selection[-1]: + current_selection.pop() + current_available_value += self.txos[len(current_selection)].effective_amount + + if not current_selection: + break + + current_selection[-1] = False + utxo = self.txos[len(current_selection) - 1] + current_value -= utxo.effective_amount + + else: + utxo = self.txos[len(current_selection)] + current_available_value -= utxo.effective_amount + previous_utxo = self.txos[len(current_selection) - 1] if current_selection else None + if current_selection and not current_selection[-1] and \ + utxo.effective_amount == previous_utxo.effective_amount and \ + utxo.fee == previous_utxo.fee: + current_selection.append(False) + else: + current_selection.append(True) + current_value += utxo.effective_amount + + if best_selection: + self.exact_match = True + return [ + self.txos[i] for i, include in enumerate(best_selection) if include + ] + + def single_random_draw(self): + self.random.shuffle(self.txos, self.random.random) + selection = [] + amount = 0 + for coin in self.txos: + selection.append(coin) + amount += coin.effective_amount + if amount >= self.target+self.cost_of_change: + return selection diff --git a/torba/constants.py b/torba/constants.py new file mode 100644 index 000000000..9fab12b5f --- /dev/null +++ b/torba/constants.py @@ -0,0 +1,3 @@ + +CENT = 1000000 +COIN = 100*CENT diff --git a/torba/hash.py b/torba/hash.py new file mode 100644 index 000000000..243ecdcde --- /dev/null +++ b/torba/hash.py @@ -0,0 +1,180 @@ +# Copyright (c) 2016-2017, Neil Booth +# Copyright (c) 2018, LBRY Inc. +# +# All rights reserved. +# +# See the file "LICENCE" for information about the copyright +# and warranty status of this software. + +""" Cryptography hash functions and related classes. """ + +import os +import six +import base64 +import hashlib +import hmac +from binascii import hexlify, unhexlify +from cryptography.hazmat.primitives.ciphers import Cipher, modes +from cryptography.hazmat.primitives.ciphers.algorithms import AES +from cryptography.hazmat.primitives.padding import PKCS7 +from cryptography.hazmat.backends import default_backend + +from torba.util import bytes_to_int, int_to_bytes + +_sha256 = hashlib.sha256 +_sha512 = hashlib.sha512 +_new_hash = hashlib.new +_new_hmac = hmac.new + + +def sha256(x): + """ Simple wrapper of hashlib sha256. """ + return _sha256(x).digest() + + +def sha512(x): + """ Simple wrapper of hashlib sha512. """ + return _sha512(x).digest() + + +def ripemd160(x): + """ Simple wrapper of hashlib ripemd160. """ + h = _new_hash('ripemd160') + h.update(x) + return h.digest() + + +def pow_hash(x): + r = sha512(double_sha256(x)) + r1 = ripemd160(r[:len(r) // 2]) + r2 = ripemd160(r[len(r) // 2:]) + r3 = double_sha256(r1 + r2) + return r3 + + +def double_sha256(x): + """ SHA-256 of SHA-256, as used extensively in bitcoin. """ + return sha256(sha256(x)) + + +def hmac_sha512(key, msg): + """ Use SHA-512 to provide an HMAC. """ + return _new_hmac(key, msg, _sha512).digest() + + +def hash160(x): + """ RIPEMD-160 of SHA-256. + Used to make bitcoin addresses from pubkeys. """ + return ripemd160(sha256(x)) + + +def hash_to_hex_str(x): + """ Convert a big-endian binary hash to displayed hex string. + Display form of a binary hash is reversed and converted to hex. """ + return hexlify(reversed(x)) + + +def hex_str_to_hash(x): + """ Convert a displayed hex string to a binary hash. """ + return reversed(unhexlify(x)) + + +def aes_encrypt(secret, value): + key = double_sha256(secret) + init_vector = os.urandom(16) + encryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).encryptor() + padder = PKCS7(AES.block_size).padder() + padded_data = padder.update(value) + padder.finalize() + encrypted_data2 = encryptor.update(padded_data) + encryptor.finalize() + return base64.b64encode(encrypted_data2) + + +def aes_decrypt(secret, value): + data = base64.b64decode(value) + key = double_sha256(secret) + init_vector, data = data[:16], data[16:] + decryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).decryptor() + unpadder = PKCS7(AES.block_size).unpadder() + result = unpadder.update(decryptor.update(data)) + unpadder.finalize() + return result + + +class Base58Error(Exception): + """ Exception used for Base58 errors. """ + + +class Base58(object): + """ Class providing base 58 functionality. """ + + chars = u'123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' + assert len(chars) == 58 + char_map = {c: n for n, c in enumerate(chars)} + + @classmethod + def char_value(cls, c): + val = cls.char_map.get(c) + if val is None: + raise Base58Error('invalid base 58 character "{}"'.format(c)) + return val + + @classmethod + def decode(cls, txt): + """ Decodes txt into a big-endian bytearray. """ + if isinstance(txt, six.binary_type): + txt = txt.decode() + + if not isinstance(txt, six.text_type): + raise TypeError('a string is required') + + if not txt: + raise Base58Error('string cannot be empty') + + value = 0 + for c in txt: + value = value * 58 + cls.char_value(c) + + result = int_to_bytes(value) + + # Prepend leading zero bytes if necessary + count = 0 + for c in txt: + if c != u'1': + break + count += 1 + if count: + result = six.int2byte(0) * count + result + + return result + + @classmethod + def encode(cls, be_bytes): + """Converts a big-endian bytearray into a base58 string.""" + value = bytes_to_int(be_bytes) + + txt = u'' + while value: + value, mod = divmod(value, 58) + txt += cls.chars[mod] + + for byte in be_bytes: + if byte != 0: + break + txt += u'1' + + return txt[::-1].encode() + + @classmethod + def decode_check(cls, txt, hash_fn=double_sha256): + """ Decodes a Base58Check-encoded string to a payload. The version prefixes it. """ + be_bytes = cls.decode(txt) + result, check = be_bytes[:-4], be_bytes[-4:] + if check != hash_fn(result)[:4]: + raise Base58Error('invalid base 58 checksum for {}'.format(txt)) + return result + + @classmethod + def encode_check(cls, payload, hash_fn=double_sha256): + """ Encodes a payload bytearray (which includes the version byte(s)) + into a Base58Check string.""" + be_bytes = payload + hash_fn(payload)[:4] + return cls.encode(be_bytes) diff --git a/torba/manager.py b/torba/manager.py new file mode 100644 index 000000000..3cde77314 --- /dev/null +++ b/torba/manager.py @@ -0,0 +1,83 @@ +import functools +from typing import List, Dict, Type +from twisted.internet import defer + +from torba.account import AccountsView +from torba.basecoin import CoinRegistry +from torba.baseledger import BaseLedger +from torba.wallet import Wallet, WalletStorage + + +class WalletManager: + + def __init__(self, wallets=None, ledgers=None): + self.wallets = wallets or [] # type: List[Wallet] + self.ledgers = ledgers or {} # type: Dict[Type[BaseLedger],BaseLedger] + self.running = False + + @classmethod + def from_config(cls, config): + wallets = [] + manager = cls(wallets) + for coin_id, ledger_config in config.get('ledgers', {}).items(): + manager.get_or_create_ledger(coin_id, ledger_config) + for wallet_path in config.get('wallets', []): + wallet_storage = WalletStorage(wallet_path) + wallet = Wallet.from_storage(wallet_storage, manager) + wallets.append(wallet) + return manager + + def get_or_create_ledger(self, coin_id, ledger_config=None): + coin_class = CoinRegistry.get_coin_class(coin_id) + ledger_class = coin_class.ledger_class + ledger = self.ledgers.get(ledger_class) + if ledger is None: + ledger = ledger_class(self.get_accounts_view(coin_class), ledger_config or {}) + self.ledgers[ledger_class] = ledger + return ledger + + @property + def default_wallet(self): + for wallet in self.wallets: + return wallet + + @property + def default_account(self): + for wallet in self.wallets: + return wallet.default_account + + def get_accounts(self, coin_class): + for wallet in self.wallets: + for account in wallet.accounts: + if account.coin.__class__ is coin_class: + yield account + + def get_accounts_view(self, coin_class): + return AccountsView( + functools.partial(self.get_accounts, coin_class) + ) + + def create_wallet(self, path, coin_class): + storage = WalletStorage(path) + wallet = Wallet.from_storage(storage, self) + self.wallets.append(wallet) + self.create_account(wallet, coin_class) + return wallet + + def create_account(self, wallet, coin_class): + ledger = self.get_or_create_ledger(coin_class.get_id()) + return wallet.generate_account(ledger) + + @defer.inlineCallbacks + def start_ledgers(self): + self.running = True + yield defer.DeferredList([ + l.start() for l in self.ledgers.values() + ]) + + @defer.inlineCallbacks + def stop_ledgers(self): + yield defer.DeferredList([ + l.stop() for l in self.ledgers.values() + ]) + self.running = False diff --git a/torba/mnemonic.py b/torba/mnemonic.py new file mode 100644 index 000000000..df1f5a238 --- /dev/null +++ b/torba/mnemonic.py @@ -0,0 +1,163 @@ +# Copyright (C) 2014 Thomas Voegtlin +# Copyright (C) 2018 LBRY Inc. + +import os +import io +import hmac +import math +import hashlib +import unicodedata +import string +from binascii import hexlify + +import ecdsa +import pbkdf2 + +from torba.hash import hmac_sha512 + +# The hash of the mnemonic seed must begin with this +SEED_PREFIX = b'01' # Standard wallet +SEED_PREFIX_2FA = b'101' # Two-factor authentication +SEED_PREFIX_SW = b'100' # Segwit wallet + +# http://www.asahi-net.or.jp/~ax2s-kmtn/ref/unicode/e_asia.html +CJK_INTERVALS = [ + (0x4E00, 0x9FFF, 'CJK Unified Ideographs'), + (0x3400, 0x4DBF, 'CJK Unified Ideographs Extension A'), + (0x20000, 0x2A6DF, 'CJK Unified Ideographs Extension B'), + (0x2A700, 0x2B73F, 'CJK Unified Ideographs Extension C'), + (0x2B740, 0x2B81F, 'CJK Unified Ideographs Extension D'), + (0xF900, 0xFAFF, 'CJK Compatibility Ideographs'), + (0x2F800, 0x2FA1D, 'CJK Compatibility Ideographs Supplement'), + (0x3190, 0x319F, 'Kanbun'), + (0x2E80, 0x2EFF, 'CJK Radicals Supplement'), + (0x2F00, 0x2FDF, 'CJK Radicals'), + (0x31C0, 0x31EF, 'CJK Strokes'), + (0x2FF0, 0x2FFF, 'Ideographic Description Characters'), + (0xE0100, 0xE01EF, 'Variation Selectors Supplement'), + (0x3100, 0x312F, 'Bopomofo'), + (0x31A0, 0x31BF, 'Bopomofo Extended'), + (0xFF00, 0xFFEF, 'Halfwidth and Fullwidth Forms'), + (0x3040, 0x309F, 'Hiragana'), + (0x30A0, 0x30FF, 'Katakana'), + (0x31F0, 0x31FF, 'Katakana Phonetic Extensions'), + (0x1B000, 0x1B0FF, 'Kana Supplement'), + (0xAC00, 0xD7AF, 'Hangul Syllables'), + (0x1100, 0x11FF, 'Hangul Jamo'), + (0xA960, 0xA97F, 'Hangul Jamo Extended A'), + (0xD7B0, 0xD7FF, 'Hangul Jamo Extended B'), + (0x3130, 0x318F, 'Hangul Compatibility Jamo'), + (0xA4D0, 0xA4FF, 'Lisu'), + (0x16F00, 0x16F9F, 'Miao'), + (0xA000, 0xA48F, 'Yi Syllables'), + (0xA490, 0xA4CF, 'Yi Radicals'), +] + + +def is_cjk(c): + n = ord(c) + for start, end, name in CJK_INTERVALS: + if start <= n <= end: + return True + return False + + +def normalize_text(seed): + seed = unicodedata.normalize('NFKD', seed) + seed = seed.lower() + # remove accents + seed = u''.join([c for c in seed if not unicodedata.combining(c)]) + # normalize whitespaces + seed = u' '.join(seed.split()) + # remove whitespaces between CJK + seed = u''.join([ + seed[i] for i in range(len(seed)) + if not (seed[i] in string.whitespace and is_cjk(seed[i-1]) and is_cjk(seed[i+1])) + ]) + return seed + + +def load_words(filename): + path = os.path.join(os.path.dirname(__file__), 'words', filename) + with io.open(path, 'r', encoding='utf-8') as f: + s = f.read().strip() + s = unicodedata.normalize('NFKD', s) + lines = s.split('\n') + words = [] + for line in lines: + line = line.split('#')[0] + line = line.strip(' \r') + assert ' ' not in line + if line: + words.append(line) + return words + + +file_names = { + 'en': 'english.txt', + 'es': 'spanish.txt', + 'ja': 'japanese.txt', + 'pt': 'portuguese.txt', + 'zh': 'chinese_simplified.txt' +} + + +class Mnemonic(object): + # Seed derivation no longer follows BIP39 + # Mnemonic phrase uses a hash based checksum, instead of a words-dependent checksum + + def __init__(self, lang='en'): + filename = file_names.get(lang, 'english.txt') + self.words = load_words(filename) + + @classmethod + def mnemonic_to_seed(self, mnemonic, passphrase=u''): + PBKDF2_ROUNDS = 2048 + mnemonic = normalize_text(mnemonic) + passphrase = normalize_text(passphrase) + return pbkdf2.PBKDF2(mnemonic, passphrase, iterations=PBKDF2_ROUNDS, macmodule=hmac, digestmodule=hashlib.sha512).read(64) + + def mnemonic_encode(self, i): + n = len(self.words) + words = [] + while i: + x = i%n + i = i//n + words.append(self.words[x]) + return ' '.join(words) + + def mnemonic_decode(self, seed): + n = len(self.words) + words = seed.split() + i = 0 + while words: + w = words.pop() + k = self.words.index(w) + i = i*n + k + return i + + def make_seed(self, prefix=SEED_PREFIX, num_bits=132): + # increase num_bits in order to obtain a uniform distribution for the last word + bpw = math.log(len(self.words), 2) + # rounding + n = int(math.ceil(num_bits/bpw) * bpw) + entropy = 1 + while entropy < pow(2, n - bpw): + # try again if seed would not contain enough words + entropy = ecdsa.util.randrange(pow(2, n)) + nonce = 0 + while True: + nonce += 1 + i = entropy + nonce + seed = self.mnemonic_encode(i) + if i != self.mnemonic_decode(seed): + raise Exception('Cannot extract same entropy from mnemonic!') + if is_new_seed(seed, prefix): + break + return seed + + +def is_new_seed(seed, prefix): + seed = normalize_text(seed) + seed_hash = hexlify(hmac_sha512(b"seed version", seed.encode('utf8'))) + return seed_hash.startswith(prefix) diff --git a/torba/msqr.py b/torba/msqr.py new file mode 100644 index 000000000..beb5bed7f --- /dev/null +++ b/torba/msqr.py @@ -0,0 +1,96 @@ +# from http://eli.thegreenplace.net/2009/03/07/computing-modular-square-roots-in-python/ + + +def modular_sqrt(a, p): + """ Find a quadratic residue (mod p) of 'a'. p + must be an odd prime. + + Solve the congruence of the form: + x^2 = a (mod p) + And returns x. Note that p - x is also a root. + + 0 is returned is no square root exists for + these a and p. + + The Tonelli-Shanks algorithm is used (except + for some simple cases in which the solution + is known from an identity). This algorithm + runs in polynomial time (unless the + generalized Riemann hypothesis is false). + """ + # Simple cases + # + if legendre_symbol(a, p) != 1: + return 0 + elif a == 0: + return 0 + elif p == 2: + return p + elif p % 4 == 3: + return pow(a, (p + 1) / 4, p) + + # Partition p-1 to s * 2^e for an odd s (i.e. + # reduce all the powers of 2 from p-1) + # + s = p - 1 + e = 0 + while s % 2 == 0: + s /= 2 + e += 1 + + # Find some 'n' with a legendre symbol n|p = -1. + # Shouldn't take long. + # + n = 2 + while legendre_symbol(n, p) != -1: + n += 1 + + # Here be dragons! + # Read the paper "Square roots from 1; 24, 51, + # 10 to Dan Shanks" by Ezra Brown for more + # information + # + + # x is a guess of the square root that gets better + # with each iteration. + # b is the "fudge factor" - by how much we're off + # with the guess. The invariant x^2 = ab (mod p) + # is maintained throughout the loop. + # g is used for successive powers of n to update + # both a and b + # r is the exponent - decreases with each update + # + x = pow(a, (s + 1) / 2, p) + b = pow(a, s, p) + g = pow(n, s, p) + r = e + + while True: + t = b + m = 0 + for m in xrange(r): + if t == 1: + break + t = pow(t, 2, p) + + if m == 0: + return x + + gs = pow(g, 2 ** (r - m - 1), p) + g = (gs * gs) % p + x = (x * gs) % p + b = (b * g) % p + r = m + + +def legendre_symbol(a, p): + """ Compute the Legendre symbol a|p using + Euler's criterion. p is a prime, a is + relatively prime to p (if p divides + a, then a|p = 0) + + Returns 1 if a has a square root modulo + p, -1 otherwise. + """ + ls = pow(a, (p - 1) / 2, p) + return -1 if ls == p - 1 else ls diff --git a/torba/stream.py b/torba/stream.py new file mode 100644 index 000000000..0f089dc5f --- /dev/null +++ b/torba/stream.py @@ -0,0 +1,144 @@ +from twisted.internet.defer import Deferred, DeferredLock, maybeDeferred, inlineCallbacks +from twisted.python.failure import Failure + + +def execute_serially(f): + _lock = DeferredLock() + + @inlineCallbacks + def allow_only_one_at_a_time(*args, **kwargs): + yield _lock.acquire() + allow_only_one_at_a_time.is_running = True + try: + yield maybeDeferred(f, *args, **kwargs) + finally: + allow_only_one_at_a_time.is_running = False + _lock.release() + + allow_only_one_at_a_time.is_running = False + return allow_only_one_at_a_time + + +class BroadcastSubscription: + + def __init__(self, controller, on_data, on_error, on_done): + self._controller = controller + self._previous = self._next = None + self._on_data = on_data + self._on_error = on_error + self._on_done = on_done + self.is_paused = False + self.is_canceled = False + self.is_closed = False + + def pause(self): + self.is_paused = True + + def resume(self): + self.is_paused = False + + def cancel(self): + self._controller._cancel(self) + self.is_canceled = True + + @property + def can_fire(self): + return not any((self.is_paused, self.is_canceled, self.is_closed)) + + def _add(self, data): + if self.can_fire and self._on_data is not None: + self._on_data(data) + + def _add_error(self, error, traceback): + if self.can_fire and self._on_error is not None: + self._on_error(error, traceback) + + def _close(self): + if self.can_fire and self._on_done is not None: + self._on_done() + self.is_closed = True + + +class StreamController: + + def __init__(self): + self.stream = Stream(self) + self._first_subscription = None + self._last_subscription = None + + @property + def has_listener(self): + return self._first_subscription is not None + + @property + def _iterate_subscriptions(self): + next = self._first_subscription + while next is not None: + subscription = next + next = next._next + yield subscription + + def add(self, event): + for subscription in self._iterate_subscriptions: + subscription._add(event) + + def add_error(self, error, traceback): + for subscription in self._iterate_subscriptions: + subscription._add_error(error, traceback) + + def close(self): + for subscription in self._iterate_subscriptions: + subscription._close() + + def _cancel(self, subscription): + previous = subscription._previous + next = subscription._next + if previous is None: + self._first_subscription = next + else: + previous._next = next + if next is None: + self._last_subscription = previous + else: + next._previous = previous + subscription._next = subscription._previous = subscription + + def _listen(self, on_data, on_error, on_done): + subscription = BroadcastSubscription(self, on_data, on_error, on_done) + old_last = self._last_subscription + self._last_subscription = subscription + subscription._previous = old_last + subscription._next = None + if old_last is None: + self._first_subscription = subscription + else: + old_last._next = subscription + return subscription + + +class Stream: + + def __init__(self, controller): + self._controller = controller + + def listen(self, on_data, on_error=None, on_done=None): + return self._controller._listen(on_data, on_error, on_done) + + @property + def first(self): + deferred = Deferred() + subscription = self.listen( + lambda value: self._cancel_and_callback(subscription, deferred, value), + lambda error, traceback: self._cancel_and_error(subscription, deferred, error, traceback) + ) + return deferred + + @staticmethod + def _cancel_and_callback(subscription, deferred, value): + subscription.cancel() + deferred.callback(value) + + @staticmethod + def _cancel_and_error(subscription, deferred, error, traceback): + subscription.cancel() + deferred.errback(Failure(error, exc_tb=traceback)) diff --git a/torba/util.py b/torba/util.py new file mode 100644 index 000000000..a6d4b8a52 --- /dev/null +++ b/torba/util.py @@ -0,0 +1,60 @@ +from binascii import unhexlify, hexlify +from collections import Sequence + + +class ReadOnlyList(Sequence): + + def __init__(self, lst): + self.lst = lst + + def __getitem__(self, key): + return self.lst[key] + + def __len__(self): + return len(self.lst) + + +def subclass_tuple(name, base): + return type(name, (base,), {'__slots__': ()}) + + +class cachedproperty(object): + + def __init__(self, f): + self.f = f + + def __get__(self, obj, type): + obj = obj or type + value = self.f(obj) + setattr(obj, self.f.__name__, value) + return value + + +def bytes_to_int(be_bytes): + """ Interprets a big-endian sequence of bytes as an integer. """ + return int(hexlify(be_bytes), 16) + + +def int_to_bytes(value): + """ Converts an integer to a big-endian sequence of bytes. """ + length = (value.bit_length() + 7) // 8 + h = '%x' % value + return unhexlify(('0' * (len(h) % 2) + h).zfill(length * 2)) + + +def rev_hex(s): + return hexlify(unhexlify(s)[::-1]) + + +def int_to_hex(i, length=1): + s = hex(i)[2:].rstrip('L') + s = "0" * (2 * length - len(s)) + s + return rev_hex(s) + + +def hex_to_int(s): + return int(b'0x' + hexlify(s[::-1]), 16) + + +def hash_encode(x): + return hexlify(x[::-1]) diff --git a/torba/wallet.py b/torba/wallet.py new file mode 100644 index 000000000..92a8b7019 --- /dev/null +++ b/torba/wallet.py @@ -0,0 +1,164 @@ +import stat +import json +import os +from typing import List, Dict + +from torba.account import Account +from torba.basecoin import CoinRegistry, BaseCoin +from torba.baseledger import BaseLedger + + +def inflate_coin(manager, coin_id, coin_dict): + # type: ('WalletManager', str, Dict) -> BaseCoin + coin_class = CoinRegistry.get_coin_class(coin_id) + ledger = manager.get_or_create_ledger(coin_id) + return coin_class(ledger, **coin_dict) + + +class Wallet: + """ The primary role of Wallet is to encapsulate a collection + of accounts (seed/private keys) and the spending rules / settings + for the coins attached to those accounts. Wallets are represented + by physical files on the filesystem. + """ + + def __init__(self, name='Wallet', coins=None, accounts=None, storage=None): + self.name = name + self.coins = coins or [] # type: List[BaseCoin] + self.accounts = accounts or [] # type: List[Account] + self.storage = storage or WalletStorage() + + def get_or_create_coin(self, ledger, coin_dict=None): # type: (BaseLedger, Dict) -> BaseCoin + for coin in self.coins: + if coin.__class__ is ledger.coin_class: + return coin + coin = ledger.coin_class(ledger, **(coin_dict or {})) + self.coins.append(coin) + return coin + + def generate_account(self, ledger): # type: (BaseLedger) -> Account + coin = self.get_or_create_coin(ledger) + account = Account.generate(coin, u'torba') + self.accounts.append(account) + return account + + @classmethod + def from_storage(cls, storage, manager): # type: (WalletStorage, 'WalletManager') -> Wallet + json_dict = storage.read() + + coins = {} + for coin_id, coin_dict in json_dict.get('coins', {}).items(): + coins[coin_id] = inflate_coin(manager, coin_id, coin_dict) + + accounts = [] + for account_dict in json_dict.get('accounts', []): + coin_id = account_dict['coin'] + coin = coins.get(coin_id) + if coin is None: + coin = coins[coin_id] = inflate_coin(manager, coin_id, {}) + account = Account.from_dict(coin, account_dict) + accounts.append(account) + + return cls( + name=json_dict.get('name', 'Wallet'), + coins=list(coins.values()), + accounts=accounts, + storage=storage + ) + + def to_dict(self): + return { + 'name': self.name, + 'coins': {c.get_id(): c.to_dict() for c in self.coins}, + 'accounts': [a.to_dict() for a in self.accounts] + } + + def save(self): + self.storage.write(self.to_dict()) + + @property + def default_account(self): + for account in self.accounts: + return account + + def get_account_private_key_for_address(self, address): + for account in self.accounts: + private_key = account.get_private_key_for_address(address) + if private_key is not None: + return account, private_key + + +class WalletStorage: + + LATEST_VERSION = 2 + + DEFAULT = { + 'version': LATEST_VERSION, + 'name': 'Wallet', + 'coins': {}, + 'accounts': [] + } + + def __init__(self, path=None, default=None): + self.path = path + self._default = default or self.DEFAULT.copy() + + @property + def default(self): + return self._default.copy() + + def read(self): + if self.path and os.path.exists(self.path): + with open(self.path, "r") as f: + json_data = f.read() + json_dict = json.loads(json_data) + if json_dict.get('version') == self.LATEST_VERSION and \ + set(json_dict) == set(self._default): + return json_dict + else: + return self.upgrade(json_dict) + else: + return self.default + + @classmethod + def upgrade(cls, json_dict): + json_dict = json_dict.copy() + + def _rename_property(old, new): + if old in json_dict: + json_dict[new] = json_dict[old] + del json_dict[old] + + version = json_dict.pop('version', -1) + + if version == 1: # upgrade from version 1 to version 2 + _rename_property('addr_history', 'history') + _rename_property('use_encryption', 'encrypted') + _rename_property('gap_limit', 'gap_limit_for_receiving') + + upgraded = cls.DEFAULT + upgraded.update(json_dict) + return json_dict + + def write(self, json_dict): + + json_data = json.dumps(json_dict, indent=4, sort_keys=True) + if self.path is None: + return json_data + + temp_path = "%s.tmp.%s" % (self.path, os.getpid()) + with open(temp_path, "w") as f: + f.write(json_data) + f.flush() + os.fsync(f.fileno()) + + if os.path.exists(self.path): + mode = os.stat(self.path).st_mode + else: + mode = stat.S_IREAD | stat.S_IWRITE + try: + os.rename(temp_path, self.path) + except: + os.remove(self.path) + os.rename(temp_path, self.path) + os.chmod(self.path, mode) diff --git a/torba/words/chinese_simplified.txt b/torba/words/chinese_simplified.txt new file mode 100644 index 000000000..b90f1ed85 --- /dev/null +++ b/torba/words/chinese_simplified.txt @@ -0,0 +1,2048 @@ +的 +一 +是 +在 +不 +了 +有 +和 +人 +这 +中 +大 +为 +上 +个 +国 +我 +以 +要 +他 +时 +来 +用 +们 +生 +到 +作 +地 +于 +出 +就 +分 +对 +成 +会 +可 +主 +发 +年 +动 +同 +工 +也 +能 +下 +过 +子 +说 +产 +种 +面 +而 +方 +后 +多 +定 +行 +学 +法 +所 +民 +得 +经 +十 +三 +之 +进 +着 +等 +部 +度 +家 +电 +力 +里 +如 +水 +化 +高 +自 +二 +理 +起 +小 +物 +现 +实 +加 +量 +都 +两 +体 +制 +机 +当 +使 +点 +从 +业 +本 +去 +把 +性 +好 +应 +开 +它 +合 +还 +因 +由 +其 +些 +然 +前 +外 +天 +政 +四 +日 +那 +社 +义 +事 +平 +形 +相 +全 +表 +间 +样 +与 +关 +各 +重 +新 +线 +内 +数 +正 +心 +反 +你 +明 +看 +原 +又 +么 +利 +比 +或 +但 +质 +气 +第 +向 +道 +命 +此 +变 +条 +只 +没 +结 +解 +问 +意 +建 +月 +公 +无 +系 +军 +很 +情 +者 +最 +立 +代 +想 +已 +通 +并 +提 +直 +题 +党 +程 +展 +五 +果 +料 +象 +员 +革 +位 +入 +常 +文 +总 +次 +品 +式 +活 +设 +及 +管 +特 +件 +长 +求 +老 +头 +基 +资 +边 +流 +路 +级 +少 +图 +山 +统 +接 +知 +较 +将 +组 +见 +计 +别 +她 +手 +角 +期 +根 +论 +运 +农 +指 +几 +九 +区 +强 +放 +决 +西 +被 +干 +做 +必 +战 +先 +回 +则 +任 +取 +据 +处 +队 +南 +给 +色 +光 +门 +即 +保 +治 +北 +造 +百 +规 +热 +领 +七 +海 +口 +东 +导 +器 +压 +志 +世 +金 +增 +争 +济 +阶 +油 +思 +术 +极 +交 +受 +联 +什 +认 +六 +共 +权 +收 +证 +改 +清 +美 +再 +采 +转 +更 +单 +风 +切 +打 +白 +教 +速 +花 +带 +安 +场 +身 +车 +例 +真 +务 +具 +万 +每 +目 +至 +达 +走 +积 +示 +议 +声 +报 +斗 +完 +类 +八 +离 +华 +名 +确 +才 +科 +张 +信 +马 +节 +话 +米 +整 +空 +元 +况 +今 +集 +温 +传 +土 +许 +步 +群 +广 +石 +记 +需 +段 +研 +界 +拉 +林 +律 +叫 +且 +究 +观 +越 +织 +装 +影 +算 +低 +持 +音 +众 +书 +布 +复 +容 +儿 +须 +际 +商 +非 +验 +连 +断 +深 +难 +近 +矿 +千 +周 +委 +素 +技 +备 +半 +办 +青 +省 +列 +习 +响 +约 +支 +般 +史 +感 +劳 +便 +团 +往 +酸 +历 +市 +克 +何 +除 +消 +构 +府 +称 +太 +准 +精 +值 +号 +率 +族 +维 +划 +选 +标 +写 +存 +候 +毛 +亲 +快 +效 +斯 +院 +查 +江 +型 +眼 +王 +按 +格 +养 +易 +置 +派 +层 +片 +始 +却 +专 +状 +育 +厂 +京 +识 +适 +属 +圆 +包 +火 +住 +调 +满 +县 +局 +照 +参 +红 +细 +引 +听 +该 +铁 +价 +严 +首 +底 +液 +官 +德 +随 +病 +苏 +失 +尔 +死 +讲 +配 +女 +黄 +推 +显 +谈 +罪 +神 +艺 +呢 +席 +含 +企 +望 +密 +批 +营 +项 +防 +举 +球 +英 +氧 +势 +告 +李 +台 +落 +木 +帮 +轮 +破 +亚 +师 +围 +注 +远 +字 +材 +排 +供 +河 +态 +封 +另 +施 +减 +树 +溶 +怎 +止 +案 +言 +士 +均 +武 +固 +叶 +鱼 +波 +视 +仅 +费 +紧 +爱 +左 +章 +早 +朝 +害 +续 +轻 +服 +试 +食 +充 +兵 +源 +判 +护 +司 +足 +某 +练 +差 +致 +板 +田 +降 +黑 +犯 +负 +击 +范 +继 +兴 +似 +余 +坚 +曲 +输 +修 +故 +城 +夫 +够 +送 +笔 +船 +占 +右 +财 +吃 +富 +春 +职 +觉 +汉 +画 +功 +巴 +跟 +虽 +杂 +飞 +检 +吸 +助 +升 +阳 +互 +初 +创 +抗 +考 +投 +坏 +策 +古 +径 +换 +未 +跑 +留 +钢 +曾 +端 +责 +站 +简 +述 +钱 +副 +尽 +帝 +射 +草 +冲 +承 +独 +令 +限 +阿 +宣 +环 +双 +请 +超 +微 +让 +控 +州 +良 +轴 +找 +否 +纪 +益 +依 +优 +顶 +础 +载 +倒 +房 +突 +坐 +粉 +敌 +略 +客 +袁 +冷 +胜 +绝 +析 +块 +剂 +测 +丝 +协 +诉 +念 +陈 +仍 +罗 +盐 +友 +洋 +错 +苦 +夜 +刑 +移 +频 +逐 +靠 +混 +母 +短 +皮 +终 +聚 +汽 +村 +云 +哪 +既 +距 +卫 +停 +烈 +央 +察 +烧 +迅 +境 +若 +印 +洲 +刻 +括 +激 +孔 +搞 +甚 +室 +待 +核 +校 +散 +侵 +吧 +甲 +游 +久 +菜 +味 +旧 +模 +湖 +货 +损 +预 +阻 +毫 +普 +稳 +乙 +妈 +植 +息 +扩 +银 +语 +挥 +酒 +守 +拿 +序 +纸 +医 +缺 +雨 +吗 +针 +刘 +啊 +急 +唱 +误 +训 +愿 +审 +附 +获 +茶 +鲜 +粮 +斤 +孩 +脱 +硫 +肥 +善 +龙 +演 +父 +渐 +血 +欢 +械 +掌 +歌 +沙 +刚 +攻 +谓 +盾 +讨 +晚 +粒 +乱 +燃 +矛 +乎 +杀 +药 +宁 +鲁 +贵 +钟 +煤 +读 +班 +伯 +香 +介 +迫 +句 +丰 +培 +握 +兰 +担 +弦 +蛋 +沉 +假 +穿 +执 +答 +乐 +谁 +顺 +烟 +缩 +征 +脸 +喜 +松 +脚 +困 +异 +免 +背 +星 +福 +买 +染 +井 +概 +慢 +怕 +磁 +倍 +祖 +皇 +促 +静 +补 +评 +翻 +肉 +践 +尼 +衣 +宽 +扬 +棉 +希 +伤 +操 +垂 +秋 +宜 +氢 +套 +督 +振 +架 +亮 +末 +宪 +庆 +编 +牛 +触 +映 +雷 +销 +诗 +座 +居 +抓 +裂 +胞 +呼 +娘 +景 +威 +绿 +晶 +厚 +盟 +衡 +鸡 +孙 +延 +危 +胶 +屋 +乡 +临 +陆 +顾 +掉 +呀 +灯 +岁 +措 +束 +耐 +剧 +玉 +赵 +跳 +哥 +季 +课 +凯 +胡 +额 +款 +绍 +卷 +齐 +伟 +蒸 +殖 +永 +宗 +苗 +川 +炉 +岩 +弱 +零 +杨 +奏 +沿 +露 +杆 +探 +滑 +镇 +饭 +浓 +航 +怀 +赶 +库 +夺 +伊 +灵 +税 +途 +灭 +赛 +归 +召 +鼓 +播 +盘 +裁 +险 +康 +唯 +录 +菌 +纯 +借 +糖 +盖 +横 +符 +私 +努 +堂 +域 +枪 +润 +幅 +哈 +竟 +熟 +虫 +泽 +脑 +壤 +碳 +欧 +遍 +侧 +寨 +敢 +彻 +虑 +斜 +薄 +庭 +纳 +弹 +饲 +伸 +折 +麦 +湿 +暗 +荷 +瓦 +塞 +床 +筑 +恶 +户 +访 +塔 +奇 +透 +梁 +刀 +旋 +迹 +卡 +氯 +遇 +份 +毒 +泥 +退 +洗 +摆 +灰 +彩 +卖 +耗 +夏 +择 +忙 +铜 +献 +硬 +予 +繁 +圈 +雪 +函 +亦 +抽 +篇 +阵 +阴 +丁 +尺 +追 +堆 +雄 +迎 +泛 +爸 +楼 +避 +谋 +吨 +野 +猪 +旗 +累 +偏 +典 +馆 +索 +秦 +脂 +潮 +爷 +豆 +忽 +托 +惊 +塑 +遗 +愈 +朱 +替 +纤 +粗 +倾 +尚 +痛 +楚 +谢 +奋 +购 +磨 +君 +池 +旁 +碎 +骨 +监 +捕 +弟 +暴 +割 +贯 +殊 +释 +词 +亡 +壁 +顿 +宝 +午 +尘 +闻 +揭 +炮 +残 +冬 +桥 +妇 +警 +综 +招 +吴 +付 +浮 +遭 +徐 +您 +摇 +谷 +赞 +箱 +隔 +订 +男 +吹 +园 +纷 +唐 +败 +宋 +玻 +巨 +耕 +坦 +荣 +闭 +湾 +键 +凡 +驻 +锅 +救 +恩 +剥 +凝 +碱 +齿 +截 +炼 +麻 +纺 +禁 +废 +盛 +版 +缓 +净 +睛 +昌 +婚 +涉 +筒 +嘴 +插 +岸 +朗 +庄 +街 +藏 +姑 +贸 +腐 +奴 +啦 +惯 +乘 +伙 +恢 +匀 +纱 +扎 +辩 +耳 +彪 +臣 +亿 +璃 +抵 +脉 +秀 +萨 +俄 +网 +舞 +店 +喷 +纵 +寸 +汗 +挂 +洪 +贺 +闪 +柬 +爆 +烯 +津 +稻 +墙 +软 +勇 +像 +滚 +厘 +蒙 +芳 +肯 +坡 +柱 +荡 +腿 +仪 +旅 +尾 +轧 +冰 +贡 +登 +黎 +削 +钻 +勒 +逃 +障 +氨 +郭 +峰 +币 +港 +伏 +轨 +亩 +毕 +擦 +莫 +刺 +浪 +秘 +援 +株 +健 +售 +股 +岛 +甘 +泡 +睡 +童 +铸 +汤 +阀 +休 +汇 +舍 +牧 +绕 +炸 +哲 +磷 +绩 +朋 +淡 +尖 +启 +陷 +柴 +呈 +徒 +颜 +泪 +稍 +忘 +泵 +蓝 +拖 +洞 +授 +镜 +辛 +壮 +锋 +贫 +虚 +弯 +摩 +泰 +幼 +廷 +尊 +窗 +纲 +弄 +隶 +疑 +氏 +宫 +姐 +震 +瑞 +怪 +尤 +琴 +循 +描 +膜 +违 +夹 +腰 +缘 +珠 +穷 +森 +枝 +竹 +沟 +催 +绳 +忆 +邦 +剩 +幸 +浆 +栏 +拥 +牙 +贮 +礼 +滤 +钠 +纹 +罢 +拍 +咱 +喊 +袖 +埃 +勤 +罚 +焦 +潜 +伍 +墨 +欲 +缝 +姓 +刊 +饱 +仿 +奖 +铝 +鬼 +丽 +跨 +默 +挖 +链 +扫 +喝 +袋 +炭 +污 +幕 +诸 +弧 +励 +梅 +奶 +洁 +灾 +舟 +鉴 +苯 +讼 +抱 +毁 +懂 +寒 +智 +埔 +寄 +届 +跃 +渡 +挑 +丹 +艰 +贝 +碰 +拔 +爹 +戴 +码 +梦 +芽 +熔 +赤 +渔 +哭 +敬 +颗 +奔 +铅 +仲 +虎 +稀 +妹 +乏 +珍 +申 +桌 +遵 +允 +隆 +螺 +仓 +魏 +锐 +晓 +氮 +兼 +隐 +碍 +赫 +拨 +忠 +肃 +缸 +牵 +抢 +博 +巧 +壳 +兄 +杜 +讯 +诚 +碧 +祥 +柯 +页 +巡 +矩 +悲 +灌 +龄 +伦 +票 +寻 +桂 +铺 +圣 +恐 +恰 +郑 +趣 +抬 +荒 +腾 +贴 +柔 +滴 +猛 +阔 +辆 +妻 +填 +撤 +储 +签 +闹 +扰 +紫 +砂 +递 +戏 +吊 +陶 +伐 +喂 +疗 +瓶 +婆 +抚 +臂 +摸 +忍 +虾 +蜡 +邻 +胸 +巩 +挤 +偶 +弃 +槽 +劲 +乳 +邓 +吉 +仁 +烂 +砖 +租 +乌 +舰 +伴 +瓜 +浅 +丙 +暂 +燥 +橡 +柳 +迷 +暖 +牌 +秧 +胆 +详 +簧 +踏 +瓷 +谱 +呆 +宾 +糊 +洛 +辉 +愤 +竞 +隙 +怒 +粘 +乃 +绪 +肩 +籍 +敏 +涂 +熙 +皆 +侦 +悬 +掘 +享 +纠 +醒 +狂 +锁 +淀 +恨 +牲 +霸 +爬 +赏 +逆 +玩 +陵 +祝 +秒 +浙 +貌 +役 +彼 +悉 +鸭 +趋 +凤 +晨 +畜 +辈 +秩 +卵 +署 +梯 +炎 +滩 +棋 +驱 +筛 +峡 +冒 +啥 +寿 +译 +浸 +泉 +帽 +迟 +硅 +疆 +贷 +漏 +稿 +冠 +嫩 +胁 +芯 +牢 +叛 +蚀 +奥 +鸣 +岭 +羊 +凭 +串 +塘 +绘 +酵 +融 +盆 +锡 +庙 +筹 +冻 +辅 +摄 +袭 +筋 +拒 +僚 +旱 +钾 +鸟 +漆 +沈 +眉 +疏 +添 +棒 +穗 +硝 +韩 +逼 +扭 +侨 +凉 +挺 +碗 +栽 +炒 +杯 +患 +馏 +劝 +豪 +辽 +勃 +鸿 +旦 +吏 +拜 +狗 +埋 +辊 +掩 +饮 +搬 +骂 +辞 +勾 +扣 +估 +蒋 +绒 +雾 +丈 +朵 +姆 +拟 +宇 +辑 +陕 +雕 +偿 +蓄 +崇 +剪 +倡 +厅 +咬 +驶 +薯 +刷 +斥 +番 +赋 +奉 +佛 +浇 +漫 +曼 +扇 +钙 +桃 +扶 +仔 +返 +俗 +亏 +腔 +鞋 +棱 +覆 +框 +悄 +叔 +撞 +骗 +勘 +旺 +沸 +孤 +吐 +孟 +渠 +屈 +疾 +妙 +惜 +仰 +狠 +胀 +谐 +抛 +霉 +桑 +岗 +嘛 +衰 +盗 +渗 +脏 +赖 +涌 +甜 +曹 +阅 +肌 +哩 +厉 +烃 +纬 +毅 +昨 +伪 +症 +煮 +叹 +钉 +搭 +茎 +笼 +酷 +偷 +弓 +锥 +恒 +杰 +坑 +鼻 +翼 +纶 +叙 +狱 +逮 +罐 +络 +棚 +抑 +膨 +蔬 +寺 +骤 +穆 +冶 +枯 +册 +尸 +凸 +绅 +坯 +牺 +焰 +轰 +欣 +晋 +瘦 +御 +锭 +锦 +丧 +旬 +锻 +垄 +搜 +扑 +邀 +亭 +酯 +迈 +舒 +脆 +酶 +闲 +忧 +酚 +顽 +羽 +涨 +卸 +仗 +陪 +辟 +惩 +杭 +姚 +肚 +捉 +飘 +漂 +昆 +欺 +吾 +郎 +烷 +汁 +呵 +饰 +萧 +雅 +邮 +迁 +燕 +撒 +姻 +赴 +宴 +烦 +债 +帐 +斑 +铃 +旨 +醇 +董 +饼 +雏 +姿 +拌 +傅 +腹 +妥 +揉 +贤 +拆 +歪 +葡 +胺 +丢 +浩 +徽 +昂 +垫 +挡 +览 +贪 +慰 +缴 +汪 +慌 +冯 +诺 +姜 +谊 +凶 +劣 +诬 +耀 +昏 +躺 +盈 +骑 +乔 +溪 +丛 +卢 +抹 +闷 +咨 +刮 +驾 +缆 +悟 +摘 +铒 +掷 +颇 +幻 +柄 +惠 +惨 +佳 +仇 +腊 +窝 +涤 +剑 +瞧 +堡 +泼 +葱 +罩 +霍 +捞 +胎 +苍 +滨 +俩 +捅 +湘 +砍 +霞 +邵 +萄 +疯 +淮 +遂 +熊 +粪 +烘 +宿 +档 +戈 +驳 +嫂 +裕 +徙 +箭 +捐 +肠 +撑 +晒 +辨 +殿 +莲 +摊 +搅 +酱 +屏 +疫 +哀 +蔡 +堵 +沫 +皱 +畅 +叠 +阁 +莱 +敲 +辖 +钩 +痕 +坝 +巷 +饿 +祸 +丘 +玄 +溜 +曰 +逻 +彭 +尝 +卿 +妨 +艇 +吞 +韦 +怨 +矮 +歇 diff --git a/torba/words/english.txt b/torba/words/english.txt new file mode 100644 index 000000000..942040ed5 --- /dev/null +++ b/torba/words/english.txt @@ -0,0 +1,2048 @@ +abandon +ability +able +about +above +absent +absorb +abstract +absurd +abuse +access +accident +account +accuse +achieve +acid +acoustic +acquire +across +act +action +actor +actress +actual +adapt +add +addict +address +adjust +admit +adult +advance +advice +aerobic +affair +afford +afraid +again +age +agent +agree +ahead +aim +air +airport +aisle +alarm +album +alcohol +alert +alien +all +alley +allow +almost +alone +alpha +already +also +alter +always +amateur +amazing +among +amount +amused +analyst +anchor +ancient +anger +angle +angry +animal +ankle +announce +annual +another +answer +antenna +antique +anxiety +any +apart +apology +appear +apple +approve +april +arch +arctic +area +arena +argue +arm +armed +armor +army +around +arrange +arrest +arrive +arrow +art +artefact +artist +artwork +ask +aspect +assault +asset +assist +assume +asthma +athlete +atom +attack +attend +attitude +attract +auction +audit +august +aunt +author +auto +autumn +average +avocado +avoid +awake +aware +away +awesome +awful +awkward +axis +baby +bachelor +bacon +badge +bag +balance +balcony +ball +bamboo +banana +banner +bar +barely +bargain +barrel +base +basic +basket +battle +beach +bean +beauty +because +become +beef +before +begin +behave +behind +believe +below +belt +bench +benefit +best +betray +better +between +beyond +bicycle +bid +bike +bind +biology +bird +birth +bitter +black +blade +blame +blanket +blast +bleak +bless +blind +blood +blossom +blouse +blue +blur +blush +board +boat +body +boil +bomb +bone +bonus +book +boost +border +boring +borrow +boss +bottom +bounce +box +boy +bracket +brain +brand +brass +brave +bread +breeze +brick +bridge +brief +bright +bring +brisk +broccoli +broken +bronze +broom +brother +brown +brush +bubble +buddy +budget +buffalo +build +bulb +bulk +bullet +bundle +bunker +burden +burger +burst +bus +business +busy +butter +buyer +buzz +cabbage +cabin +cable +cactus +cage +cake +call +calm +camera +camp +can +canal +cancel +candy +cannon +canoe +canvas +canyon +capable +capital +captain +car +carbon +card +cargo +carpet +carry +cart +case +cash +casino +castle +casual +cat +catalog +catch +category +cattle +caught +cause +caution +cave +ceiling +celery +cement +census +century +cereal +certain +chair +chalk +champion +change +chaos +chapter +charge +chase +chat +cheap +check +cheese +chef +cherry +chest +chicken +chief +child +chimney +choice +choose +chronic +chuckle +chunk +churn +cigar +cinnamon +circle +citizen +city +civil +claim +clap +clarify +claw +clay +clean +clerk +clever +click +client +cliff +climb +clinic +clip +clock +clog +close +cloth +cloud +clown +club +clump +cluster +clutch +coach +coast +coconut +code +coffee +coil +coin +collect +color +column +combine +come +comfort +comic +common +company +concert +conduct +confirm +congress +connect +consider +control +convince +cook +cool +copper +copy +coral +core +corn +correct +cost +cotton +couch +country +couple +course +cousin +cover +coyote +crack +cradle +craft +cram +crane +crash +crater +crawl +crazy +cream +credit +creek +crew +cricket +crime +crisp +critic +crop +cross +crouch +crowd +crucial +cruel +cruise +crumble +crunch +crush +cry +crystal +cube +culture +cup +cupboard +curious +current +curtain +curve +cushion +custom +cute +cycle +dad +damage +damp +dance +danger +daring +dash +daughter +dawn +day +deal +debate +debris +decade +december +decide +decline +decorate +decrease +deer +defense +define +defy +degree +delay +deliver +demand +demise +denial +dentist +deny +depart +depend +deposit +depth +deputy +derive +describe +desert +design +desk +despair +destroy +detail +detect +develop +device +devote +diagram +dial +diamond +diary +dice +diesel +diet +differ +digital +dignity +dilemma +dinner +dinosaur +direct +dirt +disagree +discover +disease +dish +dismiss +disorder +display +distance +divert +divide +divorce +dizzy +doctor +document +dog +doll +dolphin +domain +donate +donkey +donor +door +dose +double +dove +draft +dragon +drama +drastic +draw +dream +dress +drift +drill +drink +drip +drive +drop +drum +dry +duck +dumb +dune +during +dust +dutch +duty +dwarf +dynamic +eager +eagle +early +earn +earth +easily +east +easy +echo +ecology +economy +edge +edit +educate +effort +egg +eight +either +elbow +elder +electric +elegant +element +elephant +elevator +elite +else +embark +embody +embrace +emerge +emotion +employ +empower +empty +enable +enact +end +endless +endorse +enemy +energy +enforce +engage +engine +enhance +enjoy +enlist +enough +enrich +enroll +ensure +enter +entire +entry +envelope +episode +equal +equip +era +erase +erode +erosion +error +erupt +escape +essay +essence +estate +eternal +ethics +evidence +evil +evoke +evolve +exact +example +excess +exchange +excite +exclude +excuse +execute +exercise +exhaust +exhibit +exile +exist +exit +exotic +expand +expect +expire +explain +expose +express +extend +extra +eye +eyebrow +fabric +face +faculty +fade +faint +faith +fall +false +fame +family +famous +fan +fancy +fantasy +farm +fashion +fat +fatal +father +fatigue +fault +favorite +feature +february +federal +fee +feed +feel +female +fence +festival +fetch +fever +few +fiber +fiction +field +figure +file +film +filter +final +find +fine +finger +finish +fire +firm +first +fiscal +fish +fit +fitness +fix +flag +flame +flash +flat +flavor +flee +flight +flip +float +flock +floor +flower +fluid +flush +fly +foam +focus +fog +foil +fold +follow +food +foot +force +forest +forget +fork +fortune +forum +forward +fossil +foster +found +fox +fragile +frame +frequent +fresh +friend +fringe +frog +front +frost +frown +frozen +fruit +fuel +fun +funny +furnace +fury +future +gadget +gain +galaxy +gallery +game +gap +garage +garbage +garden +garlic +garment +gas +gasp +gate +gather +gauge +gaze +general +genius +genre +gentle +genuine +gesture +ghost +giant +gift +giggle +ginger +giraffe +girl +give +glad +glance +glare +glass +glide +glimpse +globe +gloom +glory +glove +glow +glue +goat +goddess +gold +good +goose +gorilla +gospel +gossip +govern +gown +grab +grace +grain +grant +grape +grass +gravity +great +green +grid +grief +grit +grocery +group +grow +grunt +guard +guess +guide +guilt +guitar +gun +gym +habit +hair +half +hammer +hamster +hand +happy +harbor +hard +harsh +harvest +hat +have +hawk +hazard +head +health +heart +heavy +hedgehog +height +hello +helmet +help +hen +hero +hidden +high +hill +hint +hip +hire +history +hobby +hockey +hold +hole +holiday +hollow +home +honey +hood +hope +horn +horror +horse +hospital +host +hotel +hour +hover +hub +huge +human +humble +humor +hundred +hungry +hunt +hurdle +hurry +hurt +husband +hybrid +ice +icon +idea +identify +idle +ignore +ill +illegal +illness +image +imitate +immense +immune +impact +impose +improve +impulse +inch +include +income +increase +index +indicate +indoor +industry +infant +inflict +inform +inhale +inherit +initial +inject +injury +inmate +inner +innocent +input +inquiry +insane +insect +inside +inspire +install +intact +interest +into +invest +invite +involve +iron +island +isolate +issue +item +ivory +jacket +jaguar +jar +jazz +jealous +jeans +jelly +jewel +job +join +joke +journey +joy +judge +juice +jump +jungle +junior +junk +just +kangaroo +keen +keep +ketchup +key +kick +kid +kidney +kind +kingdom +kiss +kit +kitchen +kite +kitten +kiwi +knee +knife +knock +know +lab +label +labor +ladder +lady +lake +lamp +language +laptop +large +later +latin +laugh +laundry +lava +law +lawn +lawsuit +layer +lazy +leader +leaf +learn +leave +lecture +left +leg +legal +legend +leisure +lemon +lend +length +lens +leopard +lesson +letter +level +liar +liberty +library +license +life +lift +light +like +limb +limit +link +lion +liquid +list +little +live +lizard +load +loan +lobster +local +lock +logic +lonely +long +loop +lottery +loud +lounge +love +loyal +lucky +luggage +lumber +lunar +lunch +luxury +lyrics +machine +mad +magic +magnet +maid +mail +main +major +make +mammal +man +manage +mandate +mango +mansion +manual +maple +marble +march +margin +marine +market +marriage +mask +mass +master +match +material +math +matrix +matter +maximum +maze +meadow +mean +measure +meat +mechanic +medal +media +melody +melt +member +memory +mention +menu +mercy +merge +merit +merry +mesh +message +metal +method +middle +midnight +milk +million +mimic +mind +minimum +minor +minute +miracle +mirror +misery +miss +mistake +mix +mixed +mixture +mobile +model +modify +mom +moment +monitor +monkey +monster +month +moon +moral +more +morning +mosquito +mother +motion +motor +mountain +mouse +move +movie +much +muffin +mule +multiply +muscle +museum +mushroom +music +must +mutual +myself +mystery +myth +naive +name +napkin +narrow +nasty +nation +nature +near +neck +need +negative +neglect +neither +nephew +nerve +nest +net +network +neutral +never +news +next +nice +night +noble +noise +nominee +noodle +normal +north +nose +notable +note +nothing +notice +novel +now +nuclear +number +nurse +nut +oak +obey +object +oblige +obscure +observe +obtain +obvious +occur +ocean +october +odor +off +offer +office +often +oil +okay +old +olive +olympic +omit +once +one +onion +online +only +open +opera +opinion +oppose +option +orange +orbit +orchard +order +ordinary +organ +orient +original +orphan +ostrich +other +outdoor +outer +output +outside +oval +oven +over +own +owner +oxygen +oyster +ozone +pact +paddle +page +pair +palace +palm +panda +panel +panic +panther +paper +parade +parent +park +parrot +party +pass +patch +path +patient +patrol +pattern +pause +pave +payment +peace +peanut +pear +peasant +pelican +pen +penalty +pencil +people +pepper +perfect +permit +person +pet +phone +photo +phrase +physical +piano +picnic +picture +piece +pig +pigeon +pill +pilot +pink +pioneer +pipe +pistol +pitch +pizza +place +planet +plastic +plate +play +please +pledge +pluck +plug +plunge +poem +poet +point +polar +pole +police +pond +pony +pool +popular +portion +position +possible +post +potato +pottery +poverty +powder +power +practice +praise +predict +prefer +prepare +present +pretty +prevent +price +pride +primary +print +priority +prison +private +prize +problem +process +produce +profit +program +project +promote +proof +property +prosper +protect +proud +provide +public +pudding +pull +pulp +pulse +pumpkin +punch +pupil +puppy +purchase +purity +purpose +purse +push +put +puzzle +pyramid +quality +quantum +quarter +question +quick +quit +quiz +quote +rabbit +raccoon +race +rack +radar +radio +rail +rain +raise +rally +ramp +ranch +random +range +rapid +rare +rate +rather +raven +raw +razor +ready +real +reason +rebel +rebuild +recall +receive +recipe +record +recycle +reduce +reflect +reform +refuse +region +regret +regular +reject +relax +release +relief +rely +remain +remember +remind +remove +render +renew +rent +reopen +repair +repeat +replace +report +require +rescue +resemble +resist +resource +response +result +retire +retreat +return +reunion +reveal +review +reward +rhythm +rib +ribbon +rice +rich +ride +ridge +rifle +right +rigid +ring +riot +ripple +risk +ritual +rival +river +road +roast +robot +robust +rocket +romance +roof +rookie +room +rose +rotate +rough +round +route +royal +rubber +rude +rug +rule +run +runway +rural +sad +saddle +sadness +safe +sail +salad +salmon +salon +salt +salute +same +sample +sand +satisfy +satoshi +sauce +sausage +save +say +scale +scan +scare +scatter +scene +scheme +school +science +scissors +scorpion +scout +scrap +screen +script +scrub +sea +search +season +seat +second +secret +section +security +seed +seek +segment +select +sell +seminar +senior +sense +sentence +series +service +session +settle +setup +seven +shadow +shaft +shallow +share +shed +shell +sheriff +shield +shift +shine +ship +shiver +shock +shoe +shoot +shop +short +shoulder +shove +shrimp +shrug +shuffle +shy +sibling +sick +side +siege +sight +sign +silent +silk +silly +silver +similar +simple +since +sing +siren +sister +situate +six +size +skate +sketch +ski +skill +skin +skirt +skull +slab +slam +sleep +slender +slice +slide +slight +slim +slogan +slot +slow +slush +small +smart +smile +smoke +smooth +snack +snake +snap +sniff +snow +soap +soccer +social +sock +soda +soft +solar +soldier +solid +solution +solve +someone +song +soon +sorry +sort +soul +sound +soup +source +south +space +spare +spatial +spawn +speak +special +speed +spell +spend +sphere +spice +spider +spike +spin +spirit +split +spoil +sponsor +spoon +sport +spot +spray +spread +spring +spy +square +squeeze +squirrel +stable +stadium +staff +stage +stairs +stamp +stand +start +state +stay +steak +steel +stem +step +stereo +stick +still +sting +stock +stomach +stone +stool +story +stove +strategy +street +strike +strong +struggle +student +stuff +stumble +style +subject +submit +subway +success +such +sudden +suffer +sugar +suggest +suit +summer +sun +sunny +sunset +super +supply +supreme +sure +surface +surge +surprise +surround +survey +suspect +sustain +swallow +swamp +swap +swarm +swear +sweet +swift +swim +swing +switch +sword +symbol +symptom +syrup +system +table +tackle +tag +tail +talent +talk +tank +tape +target +task +taste +tattoo +taxi +teach +team +tell +ten +tenant +tennis +tent +term +test +text +thank +that +theme +then +theory +there +they +thing +this +thought +three +thrive +throw +thumb +thunder +ticket +tide +tiger +tilt +timber +time +tiny +tip +tired +tissue +title +toast +tobacco +today +toddler +toe +together +toilet +token +tomato +tomorrow +tone +tongue +tonight +tool +tooth +top +topic +topple +torch +tornado +tortoise +toss +total +tourist +toward +tower +town +toy +track +trade +traffic +tragic +train +transfer +trap +trash +travel +tray +treat +tree +trend +trial +tribe +trick +trigger +trim +trip +trophy +trouble +truck +true +truly +trumpet +trust +truth +try +tube +tuition +tumble +tuna +tunnel +turkey +turn +turtle +twelve +twenty +twice +twin +twist +two +type +typical +ugly +umbrella +unable +unaware +uncle +uncover +under +undo +unfair +unfold +unhappy +uniform +unique +unit +universe +unknown +unlock +until +unusual +unveil +update +upgrade +uphold +upon +upper +upset +urban +urge +usage +use +used +useful +useless +usual +utility +vacant +vacuum +vague +valid +valley +valve +van +vanish +vapor +various +vast +vault +vehicle +velvet +vendor +venture +venue +verb +verify +version +very +vessel +veteran +viable +vibrant +vicious +victory +video +view +village +vintage +violin +virtual +virus +visa +visit +visual +vital +vivid +vocal +voice +void +volcano +volume +vote +voyage +wage +wagon +wait +walk +wall +walnut +want +warfare +warm +warrior +wash +wasp +waste +water +wave +way +wealth +weapon +wear +weasel +weather +web +wedding +weekend +weird +welcome +west +wet +whale +what +wheat +wheel +when +where +whip +whisper +wide +width +wife +wild +will +win +window +wine +wing +wink +winner +winter +wire +wisdom +wise +wish +witness +wolf +woman +wonder +wood +wool +word +work +world +worry +worth +wrap +wreck +wrestle +wrist +write +wrong +yard +year +yellow +you +young +youth +zebra +zero +zone +zoo diff --git a/torba/words/japanese.txt b/torba/words/japanese.txt new file mode 100644 index 000000000..c4c9dca4e --- /dev/null +++ b/torba/words/japanese.txt @@ -0,0 +1,2048 @@ +あいこくしん +あいさつ +あいだ +あおぞら +あかちゃん +あきる +あけがた +あける +あこがれる +あさい +あさひ +あしあと +あじわう +あずかる +あずき +あそぶ +あたえる +あたためる +あたりまえ +あたる +あつい +あつかう +あっしゅく +あつまり +あつめる +あてな +あてはまる +あひる +あぶら +あぶる +あふれる +あまい +あまど +あまやかす +あまり +あみもの +あめりか +あやまる +あゆむ +あらいぐま +あらし +あらすじ +あらためる +あらゆる +あらわす +ありがとう +あわせる +あわてる +あんい +あんがい +あんこ +あんぜん +あんてい +あんない +あんまり +いいだす +いおん +いがい +いがく +いきおい +いきなり +いきもの +いきる +いくじ +いくぶん +いけばな +いけん +いこう +いこく +いこつ +いさましい +いさん +いしき +いじゅう +いじょう +いじわる +いずみ +いずれ +いせい +いせえび +いせかい +いせき +いぜん +いそうろう +いそがしい +いだい +いだく +いたずら +いたみ +いたりあ +いちおう +いちじ +いちど +いちば +いちぶ +いちりゅう +いつか +いっしゅん +いっせい +いっそう +いったん +いっち +いってい +いっぽう +いてざ +いてん +いどう +いとこ +いない +いなか +いねむり +いのち +いのる +いはつ +いばる +いはん +いびき +いひん +いふく +いへん +いほう +いみん +いもうと +いもたれ +いもり +いやがる +いやす +いよかん +いよく +いらい +いらすと +いりぐち +いりょう +いれい +いれもの +いれる +いろえんぴつ +いわい +いわう +いわかん +いわば +いわゆる +いんげんまめ +いんさつ +いんしょう +いんよう +うえき +うえる +うおざ +うがい +うかぶ +うかべる +うきわ +うくらいな +うくれれ +うけたまわる +うけつけ +うけとる +うけもつ +うける +うごかす +うごく +うこん +うさぎ +うしなう +うしろがみ +うすい +うすぎ +うすぐらい +うすめる +うせつ +うちあわせ +うちがわ +うちき +うちゅう +うっかり +うつくしい +うったえる +うつる +うどん +うなぎ +うなじ +うなずく +うなる +うねる +うのう +うぶげ +うぶごえ +うまれる +うめる +うもう +うやまう +うよく +うらがえす +うらぐち +うらない +うりあげ +うりきれ +うるさい +うれしい +うれゆき +うれる +うろこ +うわき +うわさ +うんこう +うんちん +うんてん +うんどう +えいえん +えいが +えいきょう +えいご +えいせい +えいぶん +えいよう +えいわ +えおり +えがお +えがく +えきたい +えくせる +えしゃく +えすて +えつらん +えのぐ +えほうまき +えほん +えまき +えもじ +えもの +えらい +えらぶ +えりあ +えんえん +えんかい +えんぎ +えんげき +えんしゅう +えんぜつ +えんそく +えんちょう +えんとつ +おいかける +おいこす +おいしい +おいつく +おうえん +おうさま +おうじ +おうせつ +おうたい +おうふく +おうべい +おうよう +おえる +おおい +おおう +おおどおり +おおや +おおよそ +おかえり +おかず +おがむ +おかわり +おぎなう +おきる +おくさま +おくじょう +おくりがな +おくる +おくれる +おこす +おこなう +おこる +おさえる +おさない +おさめる +おしいれ +おしえる +おじぎ +おじさん +おしゃれ +おそらく +おそわる +おたがい +おたく +おだやか +おちつく +おっと +おつり +おでかけ +おとしもの +おとなしい +おどり +おどろかす +おばさん +おまいり +おめでとう +おもいで +おもう +おもたい +おもちゃ +おやつ +おやゆび +およぼす +おらんだ +おろす +おんがく +おんけい +おんしゃ +おんせん +おんだん +おんちゅう +おんどけい +かあつ +かいが +がいき +がいけん +がいこう +かいさつ +かいしゃ +かいすいよく +かいぜん +かいぞうど +かいつう +かいてん +かいとう +かいふく +がいへき +かいほう +かいよう +がいらい +かいわ +かえる +かおり +かかえる +かがく +かがし +かがみ +かくご +かくとく +かざる +がぞう +かたい +かたち +がちょう +がっきゅう +がっこう +がっさん +がっしょう +かなざわし +かのう +がはく +かぶか +かほう +かほご +かまう +かまぼこ +かめれおん +かゆい +かようび +からい +かるい +かろう +かわく +かわら +がんか +かんけい +かんこう +かんしゃ +かんそう +かんたん +かんち +がんばる +きあい +きあつ +きいろ +ぎいん +きうい +きうん +きえる +きおう +きおく +きおち +きおん +きかい +きかく +きかんしゃ +ききて +きくばり +きくらげ +きけんせい +きこう +きこえる +きこく +きさい +きさく +きさま +きさらぎ +ぎじかがく +ぎしき +ぎじたいけん +ぎじにってい +ぎじゅつしゃ +きすう +きせい +きせき +きせつ +きそう +きぞく +きぞん +きたえる +きちょう +きつえん +ぎっちり +きつつき +きつね +きてい +きどう +きどく +きない +きなが +きなこ +きぬごし +きねん +きのう +きのした +きはく +きびしい +きひん +きふく +きぶん +きぼう +きほん +きまる +きみつ +きむずかしい +きめる +きもだめし +きもち +きもの +きゃく +きやく +ぎゅうにく +きよう +きょうりゅう +きらい +きらく +きりん +きれい +きれつ +きろく +ぎろん +きわめる +ぎんいろ +きんかくじ +きんじょ +きんようび +ぐあい +くいず +くうかん +くうき +くうぐん +くうこう +ぐうせい +くうそう +ぐうたら +くうふく +くうぼ +くかん +くきょう +くげん +ぐこう +くさい +くさき +くさばな +くさる +くしゃみ +くしょう +くすのき +くすりゆび +くせげ +くせん +ぐたいてき +くださる +くたびれる +くちこみ +くちさき +くつした +ぐっすり +くつろぐ +くとうてん +くどく +くなん +くねくね +くのう +くふう +くみあわせ +くみたてる +くめる +くやくしょ +くらす +くらべる +くるま +くれる +くろう +くわしい +ぐんかん +ぐんしょく +ぐんたい +ぐんて +けあな +けいかく +けいけん +けいこ +けいさつ +げいじゅつ +けいたい +げいのうじん +けいれき +けいろ +けおとす +けおりもの +げきか +げきげん +げきだん +げきちん +げきとつ +げきは +げきやく +げこう +げこくじょう +げざい +けさき +げざん +けしき +けしごむ +けしょう +げすと +けたば +けちゃっぷ +けちらす +けつあつ +けつい +けつえき +けっこん +けつじょ +けっせき +けってい +けつまつ +げつようび +げつれい +けつろん +げどく +けとばす +けとる +けなげ +けなす +けなみ +けぬき +げねつ +けねん +けはい +げひん +けぶかい +げぼく +けまり +けみかる +けむし +けむり +けもの +けらい +けろけろ +けわしい +けんい +けんえつ +けんお +けんか +げんき +けんげん +けんこう +けんさく +けんしゅう +けんすう +げんそう +けんちく +けんてい +けんとう +けんない +けんにん +げんぶつ +けんま +けんみん +けんめい +けんらん +けんり +こあくま +こいぬ +こいびと +ごうい +こうえん +こうおん +こうかん +ごうきゅう +ごうけい +こうこう +こうさい +こうじ +こうすい +ごうせい +こうそく +こうたい +こうちゃ +こうつう +こうてい +こうどう +こうない +こうはい +ごうほう +ごうまん +こうもく +こうりつ +こえる +こおり +ごかい +ごがつ +ごかん +こくご +こくさい +こくとう +こくない +こくはく +こぐま +こけい +こける +ここのか +こころ +こさめ +こしつ +こすう +こせい +こせき +こぜん +こそだて +こたい +こたえる +こたつ +こちょう +こっか +こつこつ +こつばん +こつぶ +こてい +こてん +ことがら +ことし +ことば +ことり +こなごな +こねこね +このまま +このみ +このよ +ごはん +こひつじ +こふう +こふん +こぼれる +ごまあぶら +こまかい +ごますり +こまつな +こまる +こむぎこ +こもじ +こもち +こもの +こもん +こやく +こやま +こゆう +こゆび +こよい +こよう +こりる +これくしょん +ころっけ +こわもて +こわれる +こんいん +こんかい +こんき +こんしゅう +こんすい +こんだて +こんとん +こんなん +こんびに +こんぽん +こんまけ +こんや +こんれい +こんわく +ざいえき +さいかい +さいきん +ざいげん +ざいこ +さいしょ +さいせい +ざいたく +ざいちゅう +さいてき +ざいりょう +さうな +さかいし +さがす +さかな +さかみち +さがる +さぎょう +さくし +さくひん +さくら +さこく +さこつ +さずかる +ざせき +さたん +さつえい +ざつおん +ざっか +ざつがく +さっきょく +ざっし +さつじん +ざっそう +さつたば +さつまいも +さてい +さといも +さとう +さとおや +さとし +さとる +さのう +さばく +さびしい +さべつ +さほう +さほど +さます +さみしい +さみだれ +さむけ +さめる +さやえんどう +さゆう +さよう +さよく +さらだ +ざるそば +さわやか +さわる +さんいん +さんか +さんきゃく +さんこう +さんさい +ざんしょ +さんすう +さんせい +さんそ +さんち +さんま +さんみ +さんらん +しあい +しあげ +しあさって +しあわせ +しいく +しいん +しうち +しえい +しおけ +しかい +しかく +じかん +しごと +しすう +じだい +したうけ +したぎ +したて +したみ +しちょう +しちりん +しっかり +しつじ +しつもん +してい +してき +してつ +じてん +じどう +しなぎれ +しなもの +しなん +しねま +しねん +しのぐ +しのぶ +しはい +しばかり +しはつ +しはらい +しはん +しひょう +しふく +じぶん +しへい +しほう +しほん +しまう +しまる +しみん +しむける +じむしょ +しめい +しめる +しもん +しゃいん +しゃうん +しゃおん +じゃがいも +しやくしょ +しゃくほう +しゃけん +しゃこ +しゃざい +しゃしん +しゃせん +しゃそう +しゃたい +しゃちょう +しゃっきん +じゃま +しゃりん +しゃれい +じゆう +じゅうしょ +しゅくはく +じゅしん +しゅっせき +しゅみ +しゅらば +じゅんばん +しょうかい +しょくたく +しょっけん +しょどう +しょもつ +しらせる +しらべる +しんか +しんこう +じんじゃ +しんせいじ +しんちく +しんりん +すあげ +すあし +すあな +ずあん +すいえい +すいか +すいとう +ずいぶん +すいようび +すうがく +すうじつ +すうせん +すおどり +すきま +すくう +すくない +すける +すごい +すこし +ずさん +すずしい +すすむ +すすめる +すっかり +ずっしり +ずっと +すてき +すてる +すねる +すのこ +すはだ +すばらしい +ずひょう +ずぶぬれ +すぶり +すふれ +すべて +すべる +ずほう +すぼん +すまい +すめし +すもう +すやき +すらすら +するめ +すれちがう +すろっと +すわる +すんぜん +すんぽう +せあぶら +せいかつ +せいげん +せいじ +せいよう +せおう +せかいかん +せきにん +せきむ +せきゆ +せきらんうん +せけん +せこう +せすじ +せたい +せたけ +せっかく +せっきゃく +ぜっく +せっけん +せっこつ +せっさたくま +せつぞく +せつだん +せつでん +せっぱん +せつび +せつぶん +せつめい +せつりつ +せなか +せのび +せはば +せびろ +せぼね +せまい +せまる +せめる +せもたれ +せりふ +ぜんあく +せんい +せんえい +せんか +せんきょ +せんく +せんげん +ぜんご +せんさい +せんしゅ +せんすい +せんせい +せんぞ +せんたく +せんちょう +せんてい +せんとう +せんぬき +せんねん +せんぱい +ぜんぶ +ぜんぽう +せんむ +せんめんじょ +せんもん +せんやく +せんゆう +せんよう +ぜんら +ぜんりゃく +せんれい +せんろ +そあく +そいとげる +そいね +そうがんきょう +そうき +そうご +そうしん +そうだん +そうなん +そうび +そうめん +そうり +そえもの +そえん +そがい +そげき +そこう +そこそこ +そざい +そしな +そせい +そせん +そそぐ +そだてる +そつう +そつえん +そっかん +そつぎょう +そっけつ +そっこう +そっせん +そっと +そとがわ +そとづら +そなえる +そなた +そふぼ +そぼく +そぼろ +そまつ +そまる +そむく +そむりえ +そめる +そもそも +そよかぜ +そらまめ +そろう +そんかい +そんけい +そんざい +そんしつ +そんぞく +そんちょう +ぞんび +ぞんぶん +そんみん +たあい +たいいん +たいうん +たいえき +たいおう +だいがく +たいき +たいぐう +たいけん +たいこ +たいざい +だいじょうぶ +だいすき +たいせつ +たいそう +だいたい +たいちょう +たいてい +だいどころ +たいない +たいねつ +たいのう +たいはん +だいひょう +たいふう +たいへん +たいほ +たいまつばな +たいみんぐ +たいむ +たいめん +たいやき +たいよう +たいら +たいりょく +たいる +たいわん +たうえ +たえる +たおす +たおる +たおれる +たかい +たかね +たきび +たくさん +たこく +たこやき +たさい +たしざん +だじゃれ +たすける +たずさわる +たそがれ +たたかう +たたく +ただしい +たたみ +たちばな +だっかい +だっきゃく +だっこ +だっしゅつ +だったい +たてる +たとえる +たなばた +たにん +たぬき +たのしみ +たはつ +たぶん +たべる +たぼう +たまご +たまる +だむる +ためいき +ためす +ためる +たもつ +たやすい +たよる +たらす +たりきほんがん +たりょう +たりる +たると +たれる +たれんと +たろっと +たわむれる +だんあつ +たんい +たんおん +たんか +たんき +たんけん +たんご +たんさん +たんじょうび +だんせい +たんそく +たんたい +だんち +たんてい +たんとう +だんな +たんにん +だんねつ +たんのう +たんぴん +だんぼう +たんまつ +たんめい +だんれつ +だんろ +だんわ +ちあい +ちあん +ちいき +ちいさい +ちえん +ちかい +ちから +ちきゅう +ちきん +ちけいず +ちけん +ちこく +ちさい +ちしき +ちしりょう +ちせい +ちそう +ちたい +ちたん +ちちおや +ちつじょ +ちてき +ちてん +ちぬき +ちぬり +ちのう +ちひょう +ちへいせん +ちほう +ちまた +ちみつ +ちみどろ +ちめいど +ちゃんこなべ +ちゅうい +ちゆりょく +ちょうし +ちょさくけん +ちらし +ちらみ +ちりがみ +ちりょう +ちるど +ちわわ +ちんたい +ちんもく +ついか +ついたち +つうか +つうじょう +つうはん +つうわ +つかう +つかれる +つくね +つくる +つけね +つける +つごう +つたえる +つづく +つつじ +つつむ +つとめる +つながる +つなみ +つねづね +つのる +つぶす +つまらない +つまる +つみき +つめたい +つもり +つもる +つよい +つるぼ +つるみく +つわもの +つわり +てあし +てあて +てあみ +ていおん +ていか +ていき +ていけい +ていこく +ていさつ +ていし +ていせい +ていたい +ていど +ていねい +ていひょう +ていへん +ていぼう +てうち +ておくれ +てきとう +てくび +でこぼこ +てさぎょう +てさげ +てすり +てそう +てちがい +てちょう +てつがく +てつづき +でっぱ +てつぼう +てつや +でぬかえ +てぬき +てぬぐい +てのひら +てはい +てぶくろ +てふだ +てほどき +てほん +てまえ +てまきずし +てみじか +てみやげ +てらす +てれび +てわけ +てわたし +でんあつ +てんいん +てんかい +てんき +てんぐ +てんけん +てんごく +てんさい +てんし +てんすう +でんち +てんてき +てんとう +てんない +てんぷら +てんぼうだい +てんめつ +てんらんかい +でんりょく +でんわ +どあい +といれ +どうかん +とうきゅう +どうぐ +とうし +とうむぎ +とおい +とおか +とおく +とおす +とおる +とかい +とかす +ときおり +ときどき +とくい +とくしゅう +とくてん +とくに +とくべつ +とけい +とける +とこや +とさか +としょかん +とそう +とたん +とちゅう +とっきゅう +とっくん +とつぜん +とつにゅう +とどける +ととのえる +とない +となえる +となり +とのさま +とばす +どぶがわ +とほう +とまる +とめる +ともだち +ともる +どようび +とらえる +とんかつ +どんぶり +ないかく +ないこう +ないしょ +ないす +ないせん +ないそう +なおす +ながい +なくす +なげる +なこうど +なさけ +なたでここ +なっとう +なつやすみ +ななおし +なにごと +なにもの +なにわ +なのか +なふだ +なまいき +なまえ +なまみ +なみだ +なめらか +なめる +なやむ +ならう +ならび +ならぶ +なれる +なわとび +なわばり +にあう +にいがた +にうけ +におい +にかい +にがて +にきび +にくしみ +にくまん +にげる +にさんかたんそ +にしき +にせもの +にちじょう +にちようび +にっか +にっき +にっけい +にっこう +にっさん +にっしょく +にっすう +にっせき +にってい +になう +にほん +にまめ +にもつ +にやり +にゅういん +にりんしゃ +にわとり +にんい +にんか +にんき +にんげん +にんしき +にんずう +にんそう +にんたい +にんち +にんてい +にんにく +にんぷ +にんまり +にんむ +にんめい +にんよう +ぬいくぎ +ぬかす +ぬぐいとる +ぬぐう +ぬくもり +ぬすむ +ぬまえび +ぬめり +ぬらす +ぬんちゃく +ねあげ +ねいき +ねいる +ねいろ +ねぐせ +ねくたい +ねくら +ねこぜ +ねこむ +ねさげ +ねすごす +ねそべる +ねだん +ねつい +ねっしん +ねつぞう +ねったいぎょ +ねぶそく +ねふだ +ねぼう +ねほりはほり +ねまき +ねまわし +ねみみ +ねむい +ねむたい +ねもと +ねらう +ねわざ +ねんいり +ねんおし +ねんかん +ねんきん +ねんぐ +ねんざ +ねんし +ねんちゃく +ねんど +ねんぴ +ねんぶつ +ねんまつ +ねんりょう +ねんれい +のいず +のおづま +のがす +のきなみ +のこぎり +のこす +のこる +のせる +のぞく +のぞむ +のたまう +のちほど +のっく +のばす +のはら +のべる +のぼる +のみもの +のやま +のらいぬ +のらねこ +のりもの +のりゆき +のれん +のんき +ばあい +はあく +ばあさん +ばいか +ばいく +はいけん +はいご +はいしん +はいすい +はいせん +はいそう +はいち +ばいばい +はいれつ +はえる +はおる +はかい +ばかり +はかる +はくしゅ +はけん +はこぶ +はさみ +はさん +はしご +ばしょ +はしる +はせる +ぱそこん +はそん +はたん +はちみつ +はつおん +はっかく +はづき +はっきり +はっくつ +はっけん +はっこう +はっさん +はっしん +はったつ +はっちゅう +はってん +はっぴょう +はっぽう +はなす +はなび +はにかむ +はぶらし +はみがき +はむかう +はめつ +はやい +はやし +はらう +はろうぃん +はわい +はんい +はんえい +はんおん +はんかく +はんきょう +ばんぐみ +はんこ +はんしゃ +はんすう +はんだん +ぱんち +ぱんつ +はんてい +はんとし +はんのう +はんぱ +はんぶん +はんぺん +はんぼうき +はんめい +はんらん +はんろん +ひいき +ひうん +ひえる +ひかく +ひかり +ひかる +ひかん +ひくい +ひけつ +ひこうき +ひこく +ひさい +ひさしぶり +ひさん +びじゅつかん +ひしょ +ひそか +ひそむ +ひたむき +ひだり +ひたる +ひつぎ +ひっこし +ひっし +ひつじゅひん +ひっす +ひつぜん +ぴったり +ぴっちり +ひつよう +ひてい +ひとごみ +ひなまつり +ひなん +ひねる +ひはん +ひびく +ひひょう +ひほう +ひまわり +ひまん +ひみつ +ひめい +ひめじし +ひやけ +ひやす +ひよう +びょうき +ひらがな +ひらく +ひりつ +ひりょう +ひるま +ひるやすみ +ひれい +ひろい +ひろう +ひろき +ひろゆき +ひんかく +ひんけつ +ひんこん +ひんしゅ +ひんそう +ぴんち +ひんぱん +びんぼう +ふあん +ふいうち +ふうけい +ふうせん +ぷうたろう +ふうとう +ふうふ +ふえる +ふおん +ふかい +ふきん +ふくざつ +ふくぶくろ +ふこう +ふさい +ふしぎ +ふじみ +ふすま +ふせい +ふせぐ +ふそく +ぶたにく +ふたん +ふちょう +ふつう +ふつか +ふっかつ +ふっき +ふっこく +ぶどう +ふとる +ふとん +ふのう +ふはい +ふひょう +ふへん +ふまん +ふみん +ふめつ +ふめん +ふよう +ふりこ +ふりる +ふるい +ふんいき +ぶんがく +ぶんぐ +ふんしつ +ぶんせき +ふんそう +ぶんぽう +へいあん +へいおん +へいがい +へいき +へいげん +へいこう +へいさ +へいしゃ +へいせつ +へいそ +へいたく +へいてん +へいねつ +へいわ +へきが +へこむ +べにいろ +べにしょうが +へらす +へんかん +べんきょう +べんごし +へんさい +へんたい +べんり +ほあん +ほいく +ぼうぎょ +ほうこく +ほうそう +ほうほう +ほうもん +ほうりつ +ほえる +ほおん +ほかん +ほきょう +ぼきん +ほくろ +ほけつ +ほけん +ほこう +ほこる +ほしい +ほしつ +ほしゅ +ほしょう +ほせい +ほそい +ほそく +ほたて +ほたる +ぽちぶくろ +ほっきょく +ほっさ +ほったん +ほとんど +ほめる +ほんい +ほんき +ほんけ +ほんしつ +ほんやく +まいにち +まかい +まかせる +まがる +まける +まこと +まさつ +まじめ +ますく +まぜる +まつり +まとめ +まなぶ +まぬけ +まねく +まほう +まもる +まゆげ +まよう +まろやか +まわす +まわり +まわる +まんが +まんきつ +まんぞく +まんなか +みいら +みうち +みえる +みがく +みかた +みかん +みけん +みこん +みじかい +みすい +みすえる +みせる +みっか +みつかる +みつける +みてい +みとめる +みなと +みなみかさい +みねらる +みのう +みのがす +みほん +みもと +みやげ +みらい +みりょく +みわく +みんか +みんぞく +むいか +むえき +むえん +むかい +むかう +むかえ +むかし +むぎちゃ +むける +むげん +むさぼる +むしあつい +むしば +むじゅん +むしろ +むすう +むすこ +むすぶ +むすめ +むせる +むせん +むちゅう +むなしい +むのう +むやみ +むよう +むらさき +むりょう +むろん +めいあん +めいうん +めいえん +めいかく +めいきょく +めいさい +めいし +めいそう +めいぶつ +めいれい +めいわく +めぐまれる +めざす +めした +めずらしい +めだつ +めまい +めやす +めんきょ +めんせき +めんどう +もうしあげる +もうどうけん +もえる +もくし +もくてき +もくようび +もちろん +もどる +もらう +もんく +もんだい +やおや +やける +やさい +やさしい +やすい +やすたろう +やすみ +やせる +やそう +やたい +やちん +やっと +やっぱり +やぶる +やめる +ややこしい +やよい +やわらかい +ゆうき +ゆうびんきょく +ゆうべ +ゆうめい +ゆけつ +ゆしゅつ +ゆせん +ゆそう +ゆたか +ゆちゃく +ゆでる +ゆにゅう +ゆびわ +ゆらい +ゆれる +ようい +ようか +ようきゅう +ようじ +ようす +ようちえん +よかぜ +よかん +よきん +よくせい +よくぼう +よけい +よごれる +よさん +よしゅう +よそう +よそく +よっか +よてい +よどがわく +よねつ +よやく +よゆう +よろこぶ +よろしい +らいう +らくがき +らくご +らくさつ +らくだ +らしんばん +らせん +らぞく +らたい +らっか +られつ +りえき +りかい +りきさく +りきせつ +りくぐん +りくつ +りけん +りこう +りせい +りそう +りそく +りてん +りねん +りゆう +りゅうがく +りよう +りょうり +りょかん +りょくちゃ +りょこう +りりく +りれき +りろん +りんご +るいけい +るいさい +るいじ +るいせき +るすばん +るりがわら +れいかん +れいぎ +れいせい +れいぞうこ +れいとう +れいぼう +れきし +れきだい +れんあい +れんけい +れんこん +れんさい +れんしゅう +れんぞく +れんらく +ろうか +ろうご +ろうじん +ろうそく +ろくが +ろこつ +ろじうら +ろしゅつ +ろせん +ろてん +ろめん +ろれつ +ろんぎ +ろんぱ +ろんぶん +ろんり +わかす +わかめ +わかやま +わかれる +わしつ +わじまし +わすれもの +わらう +われる diff --git a/torba/words/portuguese.txt b/torba/words/portuguese.txt new file mode 100644 index 000000000..394c88da2 --- /dev/null +++ b/torba/words/portuguese.txt @@ -0,0 +1,1654 @@ +# Copyright (c) 2014, The Monero Project +# +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, are +# permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this list of +# conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, this list +# of conditions and the following disclaimer in the documentation and/or other +# materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its contributors may be +# used to endorse or promote products derived from this software without specific +# prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL +# THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF +# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +abaular +abdominal +abeto +abissinio +abjeto +ablucao +abnegar +abotoar +abrutalhar +absurdo +abutre +acautelar +accessorios +acetona +achocolatado +acirrar +acne +acovardar +acrostico +actinomicete +acustico +adaptavel +adeus +adivinho +adjunto +admoestar +adnominal +adotivo +adquirir +adriatico +adsorcao +adutora +advogar +aerossol +afazeres +afetuoso +afixo +afluir +afortunar +afrouxar +aftosa +afunilar +agentes +agito +aglutinar +aiatola +aimore +aino +aipo +airoso +ajeitar +ajoelhar +ajudante +ajuste +alazao +albumina +alcunha +alegria +alexandre +alforriar +alguns +alhures +alivio +almoxarife +alotropico +alpiste +alquimista +alsaciano +altura +aluviao +alvura +amazonico +ambulatorio +ametodico +amizades +amniotico +amovivel +amurada +anatomico +ancorar +anexo +anfora +aniversario +anjo +anotar +ansioso +anturio +anuviar +anverso +anzol +aonde +apaziguar +apito +aplicavel +apoteotico +aprimorar +aprumo +apto +apuros +aquoso +arauto +arbusto +arduo +aresta +arfar +arguto +aritmetico +arlequim +armisticio +aromatizar +arpoar +arquivo +arrumar +arsenio +arturiano +aruaque +arvores +asbesto +ascorbico +aspirina +asqueroso +assustar +astuto +atazanar +ativo +atletismo +atmosferico +atormentar +atroz +aturdir +audivel +auferir +augusto +aula +aumento +aurora +autuar +avatar +avexar +avizinhar +avolumar +avulso +axiomatico +azerbaijano +azimute +azoto +azulejo +bacteriologista +badulaque +baforada +baixote +bajular +balzaquiana +bambuzal +banzo +baoba +baqueta +barulho +bastonete +batuta +bauxita +bavaro +bazuca +bcrepuscular +beato +beduino +begonia +behaviorista +beisebol +belzebu +bemol +benzido +beocio +bequer +berro +besuntar +betume +bexiga +bezerro +biatlon +biboca +bicuspide +bidirecional +bienio +bifurcar +bigorna +bijuteria +bimotor +binormal +bioxido +bipolarizacao +biquini +birutice +bisturi +bituca +biunivoco +bivalve +bizarro +blasfemo +blenorreia +blindar +bloqueio +blusao +boazuda +bofete +bojudo +bolso +bombordo +bonzo +botina +boquiaberto +bostoniano +botulismo +bourbon +bovino +boximane +bravura +brevidade +britar +broxar +bruno +bruxuleio +bubonico +bucolico +buda +budista +bueiro +buffer +bugre +bujao +bumerangue +burundines +busto +butique +buzios +caatinga +cabuqui +cacunda +cafuzo +cajueiro +camurca +canudo +caquizeiro +carvoeiro +casulo +catuaba +cauterizar +cebolinha +cedula +ceifeiro +celulose +cerzir +cesto +cetro +ceus +cevar +chavena +cheroqui +chita +chovido +chuvoso +ciatico +cibernetico +cicuta +cidreira +cientistas +cifrar +cigarro +cilio +cimo +cinzento +cioso +cipriota +cirurgico +cisto +citrico +ciumento +civismo +clavicula +clero +clitoris +cluster +coaxial +cobrir +cocota +codorniz +coexistir +cogumelo +coito +colusao +compaixao +comutativo +contentamento +convulsivo +coordenativa +coquetel +correto +corvo +costureiro +cotovia +covil +cozinheiro +cretino +cristo +crivo +crotalo +cruzes +cubo +cucuia +cueiro +cuidar +cujo +cultural +cunilingua +cupula +curvo +custoso +cutucar +czarismo +dablio +dacota +dados +daguerreotipo +daiquiri +daltonismo +damista +dantesco +daquilo +darwinista +dasein +dativo +deao +debutantes +decurso +deduzir +defunto +degustar +dejeto +deltoide +demover +denunciar +deputado +deque +dervixe +desvirtuar +deturpar +deuteronomio +devoto +dextrose +dezoito +diatribe +dicotomico +didatico +dietista +difuso +digressao +diluvio +diminuto +dinheiro +dinossauro +dioxido +diplomatico +dique +dirimivel +disturbio +diurno +divulgar +dizivel +doar +dobro +docura +dodoi +doer +dogue +doloso +domo +donzela +doping +dorsal +dossie +dote +doutro +doze +dravidico +dreno +driver +dropes +druso +dubnio +ducto +dueto +dulija +dundum +duodeno +duquesa +durou +duvidoso +duzia +ebano +ebrio +eburneo +echarpe +eclusa +ecossistema +ectoplasma +ecumenismo +eczema +eden +editorial +edredom +edulcorar +efetuar +efigie +efluvio +egiptologo +egresso +egua +einsteiniano +eira +eivar +eixos +ejetar +elastomero +eldorado +elixir +elmo +eloquente +elucidativo +emaranhar +embutir +emerito +emfa +emitir +emotivo +empuxo +emulsao +enamorar +encurvar +enduro +enevoar +enfurnar +enguico +enho +enigmista +enlutar +enormidade +enpreendimento +enquanto +enriquecer +enrugar +entusiastico +enunciar +envolvimento +enxuto +enzimatico +eolico +epiteto +epoxi +epura +equivoco +erario +erbio +ereto +erguido +erisipela +ermo +erotizar +erros +erupcao +ervilha +esburacar +escutar +esfuziante +esguio +esloveno +esmurrar +esoterismo +esperanca +espirito +espurio +essencialmente +esturricar +esvoacar +etario +eterno +etiquetar +etnologo +etos +etrusco +euclidiano +euforico +eugenico +eunuco +europio +eustaquio +eutanasia +evasivo +eventualidade +evitavel +evoluir +exaustor +excursionista +exercito +exfoliado +exito +exotico +expurgo +exsudar +extrusora +exumar +fabuloso +facultativo +fado +fagulha +faixas +fajuto +faltoso +famoso +fanzine +fapesp +faquir +fartura +fastio +faturista +fausto +favorito +faxineira +fazer +fealdade +febril +fecundo +fedorento +feerico +feixe +felicidade +felipe +feltro +femur +fenotipo +fervura +festivo +feto +feudo +fevereiro +fezinha +fiasco +fibra +ficticio +fiduciario +fiesp +fifa +figurino +fijiano +filtro +finura +fiorde +fiquei +firula +fissurar +fitoteca +fivela +fixo +flavio +flexor +flibusteiro +flotilha +fluxograma +fobos +foco +fofura +foguista +foie +foliculo +fominha +fonte +forum +fosso +fotossintese +foxtrote +fraudulento +frevo +frivolo +frouxo +frutose +fuba +fucsia +fugitivo +fuinha +fujao +fulustreco +fumo +funileiro +furunculo +fustigar +futurologo +fuxico +fuzue +gabriel +gado +gaelico +gafieira +gaguejo +gaivota +gajo +galvanoplastico +gamo +ganso +garrucha +gastronomo +gatuno +gaussiano +gaviao +gaxeta +gazeteiro +gear +geiser +geminiano +generoso +genuino +geossinclinal +gerundio +gestual +getulista +gibi +gigolo +gilete +ginseng +giroscopio +glaucio +glacial +gleba +glifo +glote +glutonia +gnostico +goela +gogo +goitaca +golpista +gomo +gonzo +gorro +gostou +goticula +gourmet +governo +gozo +graxo +grevista +grito +grotesco +gruta +guaxinim +gude +gueto +guizo +guloso +gume +guru +gustativo +gustavo +gutural +habitue +haitiano +halterofilista +hamburguer +hanseniase +happening +harpista +hastear +haveres +hebreu +hectometro +hedonista +hegira +helena +helminto +hemorroidas +henrique +heptassilabo +hertziano +hesitar +heterossexual +heuristico +hexagono +hiato +hibrido +hidrostatico +hieroglifo +hifenizar +higienizar +hilario +himen +hino +hippie +hirsuto +historiografia +hitlerista +hodometro +hoje +holograma +homus +honroso +hoquei +horto +hostilizar +hotentote +huguenote +humilde +huno +hurra +hutu +iaia +ialorixa +iambico +iansa +iaque +iara +iatista +iberico +ibis +icar +iceberg +icosagono +idade +ideologo +idiotice +idoso +iemenita +iene +igarape +iglu +ignorar +igreja +iguaria +iidiche +ilativo +iletrado +ilharga +ilimitado +ilogismo +ilustrissimo +imaturo +imbuzeiro +imerso +imitavel +imovel +imputar +imutavel +inaveriguavel +incutir +induzir +inextricavel +infusao +ingua +inhame +iniquo +injusto +inning +inoxidavel +inquisitorial +insustentavel +intumescimento +inutilizavel +invulneravel +inzoneiro +iodo +iogurte +ioio +ionosfera +ioruba +iota +ipsilon +irascivel +iris +irlandes +irmaos +iroques +irrupcao +isca +isento +islandes +isotopo +isqueiro +israelita +isso +isto +iterbio +itinerario +itrio +iuane +iugoslavo +jabuticabeira +jacutinga +jade +jagunco +jainista +jaleco +jambo +jantarada +japones +jaqueta +jarro +jasmim +jato +jaula +javel +jazz +jegue +jeitoso +jejum +jenipapo +jeova +jequitiba +jersei +jesus +jetom +jiboia +jihad +jilo +jingle +jipe +jocoso +joelho +joguete +joio +jojoba +jorro +jota +joule +joviano +jubiloso +judoca +jugular +juizo +jujuba +juliano +jumento +junto +jururu +justo +juta +juventude +labutar +laguna +laico +lajota +lanterninha +lapso +laquear +lastro +lauto +lavrar +laxativo +lazer +leasing +lebre +lecionar +ledo +leguminoso +leitura +lele +lemure +lento +leonardo +leopardo +lepton +leque +leste +letreiro +leucocito +levitico +lexicologo +lhama +lhufas +liame +licoroso +lidocaina +liliputiano +limusine +linotipo +lipoproteina +liquidos +lirismo +lisura +liturgico +livros +lixo +lobulo +locutor +lodo +logro +lojista +lombriga +lontra +loop +loquaz +lorota +losango +lotus +louvor +luar +lubrificavel +lucros +lugubre +luis +luminoso +luneta +lustroso +luto +luvas +luxuriante +luzeiro +maduro +maestro +mafioso +magro +maiuscula +majoritario +malvisto +mamute +manutencao +mapoteca +maquinista +marzipa +masturbar +matuto +mausoleu +mavioso +maxixe +mazurca +meandro +mecha +medusa +mefistofelico +megera +meirinho +melro +memorizar +menu +mequetrefe +mertiolate +mestria +metroviario +mexilhao +mezanino +miau +microssegundo +midia +migratorio +mimosa +minuto +miosotis +mirtilo +misturar +mitzvah +miudos +mixuruca +mnemonico +moagem +mobilizar +modulo +moer +mofo +mogno +moita +molusco +monumento +moqueca +morubixaba +mostruario +motriz +mouse +movivel +mozarela +muarra +muculmano +mudo +mugir +muitos +mumunha +munir +muon +muquira +murros +musselina +nacoes +nado +naftalina +nago +naipe +naja +nalgum +namoro +nanquim +napolitano +naquilo +nascimento +nautilo +navios +nazista +nebuloso +nectarina +nefrologo +negus +nelore +nenufar +nepotismo +nervura +neste +netuno +neutron +nevoeiro +newtoniano +nexo +nhenhenhem +nhoque +nigeriano +niilista +ninho +niobio +niponico +niquelar +nirvana +nisto +nitroglicerina +nivoso +nobreza +nocivo +noel +nogueira +noivo +nojo +nominativo +nonuplo +noruegues +nostalgico +noturno +nouveau +nuanca +nublar +nucleotideo +nudista +nulo +numismatico +nunquinha +nupcias +nutritivo +nuvens +oasis +obcecar +obeso +obituario +objetos +oblongo +obnoxio +obrigatorio +obstruir +obtuso +obus +obvio +ocaso +occipital +oceanografo +ocioso +oclusivo +ocorrer +ocre +octogono +odalisca +odisseia +odorifico +oersted +oeste +ofertar +ofidio +oftalmologo +ogiva +ogum +oigale +oitavo +oitocentos +ojeriza +olaria +oleoso +olfato +olhos +oliveira +olmo +olor +olvidavel +ombudsman +omeleteira +omitir +omoplata +onanismo +ondular +oneroso +onomatopeico +ontologico +onus +onze +opalescente +opcional +operistico +opio +oposto +oprobrio +optometrista +opusculo +oratorio +orbital +orcar +orfao +orixa +orla +ornitologo +orquidea +ortorrombico +orvalho +osculo +osmotico +ossudo +ostrogodo +otario +otite +ouro +ousar +outubro +ouvir +ovario +overnight +oviparo +ovni +ovoviviparo +ovulo +oxala +oxente +oxiuro +oxossi +ozonizar +paciente +pactuar +padronizar +paete +pagodeiro +paixao +pajem +paludismo +pampas +panturrilha +papudo +paquistanes +pastoso +patua +paulo +pauzinhos +pavoroso +paxa +pazes +peao +pecuniario +pedunculo +pegaso +peixinho +pejorativo +pelvis +penuria +pequno +petunia +pezada +piauiense +pictorico +pierro +pigmeu +pijama +pilulas +pimpolho +pintura +piorar +pipocar +piqueteiro +pirulito +pistoleiro +pituitaria +pivotar +pixote +pizzaria +plistoceno +plotar +pluviometrico +pneumonico +poco +podridao +poetisa +pogrom +pois +polvorosa +pomposo +ponderado +pontudo +populoso +poquer +porvir +posudo +potro +pouso +povoar +prazo +prezar +privilegios +proximo +prussiano +pseudopode +psoriase +pterossauros +ptialina +ptolemaico +pudor +pueril +pufe +pugilista +puir +pujante +pulverizar +pumba +punk +purulento +pustula +putsch +puxe +quatrocentos +quetzal +quixotesco +quotizavel +rabujice +racista +radonio +rafia +ragu +rajado +ralo +rampeiro +ranzinza +raptor +raquitismo +raro +rasurar +ratoeira +ravioli +razoavel +reavivar +rebuscar +recusavel +reduzivel +reexposicao +refutavel +regurgitar +reivindicavel +rejuvenescimento +relva +remuneravel +renunciar +reorientar +repuxo +requisito +resumo +returno +reutilizar +revolvido +rezonear +riacho +ribossomo +ricota +ridiculo +rifle +rigoroso +rijo +rimel +rins +rios +riqueza +riquixa +rissole +ritualistico +rivalizar +rixa +robusto +rococo +rodoviario +roer +rogo +rojao +rolo +rompimento +ronronar +roqueiro +rorqual +rosto +rotundo +rouxinol +roxo +royal +ruas +rucula +rudimentos +ruela +rufo +rugoso +ruivo +rule +rumoroso +runico +ruptura +rural +rustico +rutilar +saariano +sabujo +sacudir +sadomasoquista +safra +sagui +sais +samurai +santuario +sapo +saquear +sartriano +saturno +saude +sauva +saveiro +saxofonista +sazonal +scherzo +script +seara +seborreia +secura +seduzir +sefardim +seguro +seja +selvas +sempre +senzala +sepultura +sequoia +sestercio +setuplo +seus +seviciar +sezonismo +shalom +siames +sibilante +sicrano +sidra +sifilitico +signos +silvo +simultaneo +sinusite +sionista +sirio +sisudo +situar +sivan +slide +slogan +soar +sobrio +socratico +sodomizar +soerguer +software +sogro +soja +solver +somente +sonso +sopro +soquete +sorveteiro +sossego +soturno +sousafone +sovinice +sozinho +suavizar +subverter +sucursal +sudoriparo +sufragio +sugestoes +suite +sujo +sultao +sumula +suntuoso +suor +supurar +suruba +susto +suturar +suvenir +tabuleta +taco +tadjique +tafeta +tagarelice +taitiano +talvez +tampouco +tanzaniano +taoista +tapume +taquion +tarugo +tascar +tatuar +tautologico +tavola +taxionomista +tchecoslovaco +teatrologo +tectonismo +tedioso +teflon +tegumento +teixo +telurio +temporas +tenue +teosofico +tepido +tequila +terrorista +testosterona +tetrico +teutonico +teve +texugo +tiara +tibia +tiete +tifoide +tigresa +tijolo +tilintar +timpano +tintureiro +tiquete +tiroteio +tisico +titulos +tive +toar +toboga +tofu +togoles +toicinho +tolueno +tomografo +tontura +toponimo +toquio +torvelinho +tostar +toto +touro +toxina +trazer +trezentos +trivialidade +trovoar +truta +tuaregue +tubular +tucano +tudo +tufo +tuiste +tulipa +tumultuoso +tunisino +tupiniquim +turvo +tutu +ucraniano +udenista +ufanista +ufologo +ugaritico +uiste +uivo +ulceroso +ulema +ultravioleta +umbilical +umero +umido +umlaut +unanimidade +unesco +ungulado +unheiro +univoco +untuoso +urano +urbano +urdir +uretra +urgente +urinol +urna +urologo +urro +ursulina +urtiga +urupe +usavel +usbeque +usei +usineiro +usurpar +utero +utilizar +utopico +uvular +uxoricidio +vacuo +vadio +vaguear +vaivem +valvula +vampiro +vantajoso +vaporoso +vaquinha +varziano +vasto +vaticinio +vaudeville +vazio +veado +vedico +veemente +vegetativo +veio +veja +veludo +venusiano +verdade +verve +vestuario +vetusto +vexatorio +vezes +viavel +vibratorio +victor +vicunha +vidros +vietnamita +vigoroso +vilipendiar +vime +vintem +violoncelo +viquingue +virus +visualizar +vituperio +viuvo +vivo +vizir +voar +vociferar +vodu +vogar +voile +volver +vomito +vontade +vortice +vosso +voto +vovozinha +voyeuse +vozes +vulva +vupt +western +xadrez +xale +xampu +xango +xarope +xaual +xavante +xaxim +xenonio +xepa +xerox +xicara +xifopago +xiita +xilogravura +xinxim +xistoso +xixi +xodo +xogum +xucro +zabumba +zagueiro +zambiano +zanzar +zarpar +zebu +zefiro +zeloso +zenite +zumbi diff --git a/torba/words/spanish.txt b/torba/words/spanish.txt new file mode 100644 index 000000000..d0900c2c7 --- /dev/null +++ b/torba/words/spanish.txt @@ -0,0 +1,2048 @@ +ábaco +abdomen +abeja +abierto +abogado +abono +aborto +abrazo +abrir +abuelo +abuso +acabar +academia +acceso +acción +aceite +acelga +acento +aceptar +ácido +aclarar +acné +acoger +acoso +activo +acto +actriz +actuar +acudir +acuerdo +acusar +adicto +admitir +adoptar +adorno +aduana +adulto +aéreo +afectar +afición +afinar +afirmar +ágil +agitar +agonía +agosto +agotar +agregar +agrio +agua +agudo +águila +aguja +ahogo +ahorro +aire +aislar +ajedrez +ajeno +ajuste +alacrán +alambre +alarma +alba +álbum +alcalde +aldea +alegre +alejar +alerta +aleta +alfiler +alga +algodón +aliado +aliento +alivio +alma +almeja +almíbar +altar +alteza +altivo +alto +altura +alumno +alzar +amable +amante +amapola +amargo +amasar +ámbar +ámbito +ameno +amigo +amistad +amor +amparo +amplio +ancho +anciano +ancla +andar +andén +anemia +ángulo +anillo +ánimo +anís +anotar +antena +antiguo +antojo +anual +anular +anuncio +añadir +añejo +año +apagar +aparato +apetito +apio +aplicar +apodo +aporte +apoyo +aprender +aprobar +apuesta +apuro +arado +araña +arar +árbitro +árbol +arbusto +archivo +arco +arder +ardilla +arduo +área +árido +aries +armonía +arnés +aroma +arpa +arpón +arreglo +arroz +arruga +arte +artista +asa +asado +asalto +ascenso +asegurar +aseo +asesor +asiento +asilo +asistir +asno +asombro +áspero +astilla +astro +astuto +asumir +asunto +atajo +ataque +atar +atento +ateo +ático +atleta +átomo +atraer +atroz +atún +audaz +audio +auge +aula +aumento +ausente +autor +aval +avance +avaro +ave +avellana +avena +avestruz +avión +aviso +ayer +ayuda +ayuno +azafrán +azar +azote +azúcar +azufre +azul +baba +babor +bache +bahía +baile +bajar +balanza +balcón +balde +bambú +banco +banda +baño +barba +barco +barniz +barro +báscula +bastón +basura +batalla +batería +batir +batuta +baúl +bazar +bebé +bebida +bello +besar +beso +bestia +bicho +bien +bingo +blanco +bloque +blusa +boa +bobina +bobo +boca +bocina +boda +bodega +boina +bola +bolero +bolsa +bomba +bondad +bonito +bono +bonsái +borde +borrar +bosque +bote +botín +bóveda +bozal +bravo +brazo +brecha +breve +brillo +brinco +brisa +broca +broma +bronce +brote +bruja +brusco +bruto +buceo +bucle +bueno +buey +bufanda +bufón +búho +buitre +bulto +burbuja +burla +burro +buscar +butaca +buzón +caballo +cabeza +cabina +cabra +cacao +cadáver +cadena +caer +café +caída +caimán +caja +cajón +cal +calamar +calcio +caldo +calidad +calle +calma +calor +calvo +cama +cambio +camello +camino +campo +cáncer +candil +canela +canguro +canica +canto +caña +cañón +caoba +caos +capaz +capitán +capote +captar +capucha +cara +carbón +cárcel +careta +carga +cariño +carne +carpeta +carro +carta +casa +casco +casero +caspa +castor +catorce +catre +caudal +causa +cazo +cebolla +ceder +cedro +celda +célebre +celoso +célula +cemento +ceniza +centro +cerca +cerdo +cereza +cero +cerrar +certeza +césped +cetro +chacal +chaleco +champú +chancla +chapa +charla +chico +chiste +chivo +choque +choza +chuleta +chupar +ciclón +ciego +cielo +cien +cierto +cifra +cigarro +cima +cinco +cine +cinta +ciprés +circo +ciruela +cisne +cita +ciudad +clamor +clan +claro +clase +clave +cliente +clima +clínica +cobre +cocción +cochino +cocina +coco +código +codo +cofre +coger +cohete +cojín +cojo +cola +colcha +colegio +colgar +colina +collar +colmo +columna +combate +comer +comida +cómodo +compra +conde +conejo +conga +conocer +consejo +contar +copa +copia +corazón +corbata +corcho +cordón +corona +correr +coser +cosmos +costa +cráneo +cráter +crear +crecer +creído +crema +cría +crimen +cripta +crisis +cromo +crónica +croqueta +crudo +cruz +cuadro +cuarto +cuatro +cubo +cubrir +cuchara +cuello +cuento +cuerda +cuesta +cueva +cuidar +culebra +culpa +culto +cumbre +cumplir +cuna +cuneta +cuota +cupón +cúpula +curar +curioso +curso +curva +cutis +dama +danza +dar +dardo +dátil +deber +débil +década +decir +dedo +defensa +definir +dejar +delfín +delgado +delito +demora +denso +dental +deporte +derecho +derrota +desayuno +deseo +desfile +desnudo +destino +desvío +detalle +detener +deuda +día +diablo +diadema +diamante +diana +diario +dibujo +dictar +diente +dieta +diez +difícil +digno +dilema +diluir +dinero +directo +dirigir +disco +diseño +disfraz +diva +divino +doble +doce +dolor +domingo +don +donar +dorado +dormir +dorso +dos +dosis +dragón +droga +ducha +duda +duelo +dueño +dulce +dúo +duque +durar +dureza +duro +ébano +ebrio +echar +eco +ecuador +edad +edición +edificio +editor +educar +efecto +eficaz +eje +ejemplo +elefante +elegir +elemento +elevar +elipse +élite +elixir +elogio +eludir +embudo +emitir +emoción +empate +empeño +empleo +empresa +enano +encargo +enchufe +encía +enemigo +enero +enfado +enfermo +engaño +enigma +enlace +enorme +enredo +ensayo +enseñar +entero +entrar +envase +envío +época +equipo +erizo +escala +escena +escolar +escribir +escudo +esencia +esfera +esfuerzo +espada +espejo +espía +esposa +espuma +esquí +estar +este +estilo +estufa +etapa +eterno +ética +etnia +evadir +evaluar +evento +evitar +exacto +examen +exceso +excusa +exento +exigir +exilio +existir +éxito +experto +explicar +exponer +extremo +fábrica +fábula +fachada +fácil +factor +faena +faja +falda +fallo +falso +faltar +fama +familia +famoso +faraón +farmacia +farol +farsa +fase +fatiga +fauna +favor +fax +febrero +fecha +feliz +feo +feria +feroz +fértil +fervor +festín +fiable +fianza +fiar +fibra +ficción +ficha +fideo +fiebre +fiel +fiera +fiesta +figura +fijar +fijo +fila +filete +filial +filtro +fin +finca +fingir +finito +firma +flaco +flauta +flecha +flor +flota +fluir +flujo +flúor +fobia +foca +fogata +fogón +folio +folleto +fondo +forma +forro +fortuna +forzar +fosa +foto +fracaso +frágil +franja +frase +fraude +freír +freno +fresa +frío +frito +fruta +fuego +fuente +fuerza +fuga +fumar +función +funda +furgón +furia +fusil +fútbol +futuro +gacela +gafas +gaita +gajo +gala +galería +gallo +gamba +ganar +gancho +ganga +ganso +garaje +garza +gasolina +gastar +gato +gavilán +gemelo +gemir +gen +género +genio +gente +geranio +gerente +germen +gesto +gigante +gimnasio +girar +giro +glaciar +globo +gloria +gol +golfo +goloso +golpe +goma +gordo +gorila +gorra +gota +goteo +gozar +grada +gráfico +grano +grasa +gratis +grave +grieta +grillo +gripe +gris +grito +grosor +grúa +grueso +grumo +grupo +guante +guapo +guardia +guerra +guía +guiño +guion +guiso +guitarra +gusano +gustar +haber +hábil +hablar +hacer +hacha +hada +hallar +hamaca +harina +haz +hazaña +hebilla +hebra +hecho +helado +helio +hembra +herir +hermano +héroe +hervir +hielo +hierro +hígado +higiene +hijo +himno +historia +hocico +hogar +hoguera +hoja +hombre +hongo +honor +honra +hora +hormiga +horno +hostil +hoyo +hueco +huelga +huerta +hueso +huevo +huida +huir +humano +húmedo +humilde +humo +hundir +huracán +hurto +icono +ideal +idioma +ídolo +iglesia +iglú +igual +ilegal +ilusión +imagen +imán +imitar +impar +imperio +imponer +impulso +incapaz +índice +inerte +infiel +informe +ingenio +inicio +inmenso +inmune +innato +insecto +instante +interés +íntimo +intuir +inútil +invierno +ira +iris +ironía +isla +islote +jabalí +jabón +jamón +jarabe +jardín +jarra +jaula +jazmín +jefe +jeringa +jinete +jornada +joroba +joven +joya +juerga +jueves +juez +jugador +jugo +juguete +juicio +junco +jungla +junio +juntar +júpiter +jurar +justo +juvenil +juzgar +kilo +koala +labio +lacio +lacra +lado +ladrón +lagarto +lágrima +laguna +laico +lamer +lámina +lámpara +lana +lancha +langosta +lanza +lápiz +largo +larva +lástima +lata +látex +latir +laurel +lavar +lazo +leal +lección +leche +lector +leer +legión +legumbre +lejano +lengua +lento +leña +león +leopardo +lesión +letal +letra +leve +leyenda +libertad +libro +licor +líder +lidiar +lienzo +liga +ligero +lima +límite +limón +limpio +lince +lindo +línea +lingote +lino +linterna +líquido +liso +lista +litera +litio +litro +llaga +llama +llanto +llave +llegar +llenar +llevar +llorar +llover +lluvia +lobo +loción +loco +locura +lógica +logro +lombriz +lomo +lonja +lote +lucha +lucir +lugar +lujo +luna +lunes +lupa +lustro +luto +luz +maceta +macho +madera +madre +maduro +maestro +mafia +magia +mago +maíz +maldad +maleta +malla +malo +mamá +mambo +mamut +manco +mando +manejar +manga +maniquí +manjar +mano +manso +manta +mañana +mapa +máquina +mar +marco +marea +marfil +margen +marido +mármol +marrón +martes +marzo +masa +máscara +masivo +matar +materia +matiz +matriz +máximo +mayor +mazorca +mecha +medalla +medio +médula +mejilla +mejor +melena +melón +memoria +menor +mensaje +mente +menú +mercado +merengue +mérito +mes +mesón +meta +meter +método +metro +mezcla +miedo +miel +miembro +miga +mil +milagro +militar +millón +mimo +mina +minero +mínimo +minuto +miope +mirar +misa +miseria +misil +mismo +mitad +mito +mochila +moción +moda +modelo +moho +mojar +molde +moler +molino +momento +momia +monarca +moneda +monja +monto +moño +morada +morder +moreno +morir +morro +morsa +mortal +mosca +mostrar +motivo +mover +móvil +mozo +mucho +mudar +mueble +muela +muerte +muestra +mugre +mujer +mula +muleta +multa +mundo +muñeca +mural +muro +músculo +museo +musgo +música +muslo +nácar +nación +nadar +naipe +naranja +nariz +narrar +nasal +natal +nativo +natural +náusea +naval +nave +navidad +necio +néctar +negar +negocio +negro +neón +nervio +neto +neutro +nevar +nevera +nicho +nido +niebla +nieto +niñez +niño +nítido +nivel +nobleza +noche +nómina +noria +norma +norte +nota +noticia +novato +novela +novio +nube +nuca +núcleo +nudillo +nudo +nuera +nueve +nuez +nulo +número +nutria +oasis +obeso +obispo +objeto +obra +obrero +observar +obtener +obvio +oca +ocaso +océano +ochenta +ocho +ocio +ocre +octavo +octubre +oculto +ocupar +ocurrir +odiar +odio +odisea +oeste +ofensa +oferta +oficio +ofrecer +ogro +oído +oír +ojo +ola +oleada +olfato +olivo +olla +olmo +olor +olvido +ombligo +onda +onza +opaco +opción +ópera +opinar +oponer +optar +óptica +opuesto +oración +orador +oral +órbita +orca +orden +oreja +órgano +orgía +orgullo +oriente +origen +orilla +oro +orquesta +oruga +osadía +oscuro +osezno +oso +ostra +otoño +otro +oveja +óvulo +óxido +oxígeno +oyente +ozono +pacto +padre +paella +página +pago +país +pájaro +palabra +palco +paleta +pálido +palma +paloma +palpar +pan +panal +pánico +pantera +pañuelo +papá +papel +papilla +paquete +parar +parcela +pared +parir +paro +párpado +parque +párrafo +parte +pasar +paseo +pasión +paso +pasta +pata +patio +patria +pausa +pauta +pavo +payaso +peatón +pecado +pecera +pecho +pedal +pedir +pegar +peine +pelar +peldaño +pelea +peligro +pellejo +pelo +peluca +pena +pensar +peñón +peón +peor +pepino +pequeño +pera +percha +perder +pereza +perfil +perico +perla +permiso +perro +persona +pesa +pesca +pésimo +pestaña +pétalo +petróleo +pez +pezuña +picar +pichón +pie +piedra +pierna +pieza +pijama +pilar +piloto +pimienta +pino +pintor +pinza +piña +piojo +pipa +pirata +pisar +piscina +piso +pista +pitón +pizca +placa +plan +plata +playa +plaza +pleito +pleno +plomo +pluma +plural +pobre +poco +poder +podio +poema +poesía +poeta +polen +policía +pollo +polvo +pomada +pomelo +pomo +pompa +poner +porción +portal +posada +poseer +posible +poste +potencia +potro +pozo +prado +precoz +pregunta +premio +prensa +preso +previo +primo +príncipe +prisión +privar +proa +probar +proceso +producto +proeza +profesor +programa +prole +promesa +pronto +propio +próximo +prueba +público +puchero +pudor +pueblo +puerta +puesto +pulga +pulir +pulmón +pulpo +pulso +puma +punto +puñal +puño +pupa +pupila +puré +quedar +queja +quemar +querer +queso +quieto +química +quince +quitar +rábano +rabia +rabo +ración +radical +raíz +rama +rampa +rancho +rango +rapaz +rápido +rapto +rasgo +raspa +rato +rayo +raza +razón +reacción +realidad +rebaño +rebote +recaer +receta +rechazo +recoger +recreo +recto +recurso +red +redondo +reducir +reflejo +reforma +refrán +refugio +regalo +regir +regla +regreso +rehén +reino +reír +reja +relato +relevo +relieve +relleno +reloj +remar +remedio +remo +rencor +rendir +renta +reparto +repetir +reposo +reptil +res +rescate +resina +respeto +resto +resumen +retiro +retorno +retrato +reunir +revés +revista +rey +rezar +rico +riego +rienda +riesgo +rifa +rígido +rigor +rincón +riñón +río +riqueza +risa +ritmo +rito +rizo +roble +roce +rociar +rodar +rodeo +rodilla +roer +rojizo +rojo +romero +romper +ron +ronco +ronda +ropa +ropero +rosa +rosca +rostro +rotar +rubí +rubor +rudo +rueda +rugir +ruido +ruina +ruleta +rulo +rumbo +rumor +ruptura +ruta +rutina +sábado +saber +sabio +sable +sacar +sagaz +sagrado +sala +saldo +salero +salir +salmón +salón +salsa +salto +salud +salvar +samba +sanción +sandía +sanear +sangre +sanidad +sano +santo +sapo +saque +sardina +sartén +sastre +satán +sauna +saxofón +sección +seco +secreto +secta +sed +seguir +seis +sello +selva +semana +semilla +senda +sensor +señal +señor +separar +sepia +sequía +ser +serie +sermón +servir +sesenta +sesión +seta +setenta +severo +sexo +sexto +sidra +siesta +siete +siglo +signo +sílaba +silbar +silencio +silla +símbolo +simio +sirena +sistema +sitio +situar +sobre +socio +sodio +sol +solapa +soldado +soledad +sólido +soltar +solución +sombra +sondeo +sonido +sonoro +sonrisa +sopa +soplar +soporte +sordo +sorpresa +sorteo +sostén +sótano +suave +subir +suceso +sudor +suegra +suelo +sueño +suerte +sufrir +sujeto +sultán +sumar +superar +suplir +suponer +supremo +sur +surco +sureño +surgir +susto +sutil +tabaco +tabique +tabla +tabú +taco +tacto +tajo +talar +talco +talento +talla +talón +tamaño +tambor +tango +tanque +tapa +tapete +tapia +tapón +taquilla +tarde +tarea +tarifa +tarjeta +tarot +tarro +tarta +tatuaje +tauro +taza +tazón +teatro +techo +tecla +técnica +tejado +tejer +tejido +tela +teléfono +tema +temor +templo +tenaz +tender +tener +tenis +tenso +teoría +terapia +terco +término +ternura +terror +tesis +tesoro +testigo +tetera +texto +tez +tibio +tiburón +tiempo +tienda +tierra +tieso +tigre +tijera +tilde +timbre +tímido +timo +tinta +tío +típico +tipo +tira +tirón +titán +títere +título +tiza +toalla +tobillo +tocar +tocino +todo +toga +toldo +tomar +tono +tonto +topar +tope +toque +tórax +torero +tormenta +torneo +toro +torpedo +torre +torso +tortuga +tos +tosco +toser +tóxico +trabajo +tractor +traer +tráfico +trago +traje +tramo +trance +trato +trauma +trazar +trébol +tregua +treinta +tren +trepar +tres +tribu +trigo +tripa +triste +triunfo +trofeo +trompa +tronco +tropa +trote +trozo +truco +trueno +trufa +tubería +tubo +tuerto +tumba +tumor +túnel +túnica +turbina +turismo +turno +tutor +ubicar +úlcera +umbral +unidad +unir +universo +uno +untar +uña +urbano +urbe +urgente +urna +usar +usuario +útil +utopía +uva +vaca +vacío +vacuna +vagar +vago +vaina +vajilla +vale +válido +valle +valor +válvula +vampiro +vara +variar +varón +vaso +vecino +vector +vehículo +veinte +vejez +vela +velero +veloz +vena +vencer +venda +veneno +vengar +venir +venta +venus +ver +verano +verbo +verde +vereda +verja +verso +verter +vía +viaje +vibrar +vicio +víctima +vida +vídeo +vidrio +viejo +viernes +vigor +vil +villa +vinagre +vino +viñedo +violín +viral +virgo +virtud +visor +víspera +vista +vitamina +viudo +vivaz +vivero +vivir +vivo +volcán +volumen +volver +voraz +votar +voto +voz +vuelo +vulgar +yacer +yate +yegua +yema +yerno +yeso +yodo +yoga +yogur +zafiro +zanja +zapato +zarza +zona +zorro +zumo +zurdo diff --git a/tox.ini b/tox.ini new file mode 100644 index 000000000..7099b9dd7 --- /dev/null +++ b/tox.ini @@ -0,0 +1,12 @@ +[tox] +envlist = py{27,36} + +[testenv] +deps = + coverage + mock + +changedir = {toxinidir}/tests + +commands = + coverage run -p --source={envsitepackagesdir}/torba -m unittest discover -v From ca6d5937ba4a534e359e8fc6ec0db25a65ecea7f Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 25 May 2018 09:54:01 -0400 Subject: [PATCH 002/383] stream.where and stream.async_where --- torba/baseledger.py | 2 +- torba/basetransaction.py | 4 ++-- torba/stream.py | 21 +++++++++++++++++++++ 3 files changed, 24 insertions(+), 3 deletions(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index 7a25af41e..99fb5f1d1 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -105,7 +105,7 @@ class BaseLedger: if address not in self.addresses: self.addresses[address] = Address(self.coin_class.address_to_hash160(address)) self.addresses[address].add_transaction(transaction) - self.transactions.setdefault(hexlify(transaction.id), transaction) + self.transactions.setdefault(transaction.id, transaction) self._on_transaction_controller.add(transaction) def has_address(self, address): diff --git a/torba/basetransaction.py b/torba/basetransaction.py index af854e970..ee23b0929 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -1,7 +1,7 @@ import six import logging from typing import List -from collections import namedtuple +from binascii import hexlify from torba.basecoin import BaseCoin from torba.basescript import BaseInputScript, BaseOutputScript @@ -161,7 +161,7 @@ class BaseTransaction: @property def id(self): if self._id is None: - self._id = self.hash[::-1] + self._id = hexlify(self.hash[::-1]) return self._id @property diff --git a/torba/stream.py b/torba/stream.py index 0f089dc5f..a5f3f63c9 100644 --- a/torba/stream.py +++ b/torba/stream.py @@ -1,6 +1,10 @@ +import six from twisted.internet.defer import Deferred, DeferredLock, maybeDeferred, inlineCallbacks from twisted.python.failure import Failure +if six.PY3: + import asyncio + def execute_serially(f): _lock = DeferredLock() @@ -124,6 +128,23 @@ class Stream: def listen(self, on_data, on_error=None, on_done=None): return self._controller._listen(on_data, on_error, on_done) + def where(self, condition): + deferred = Deferred() + + def where_test(value): + if condition(value): + self._cancel_and_callback(subscription, deferred, value) + + subscription = self.listen( + where_test, + lambda error, traceback: self._cancel_and_error(subscription, deferred, error, traceback) + ) + + return deferred + + def async_where(self, condition): + return self.where(condition).asFuture(asyncio.get_event_loop()) + @property def first(self): deferred = Deferred() From 4e4c4b5f96666775255e51104b80c60458f51470 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 25 May 2018 11:11:28 -0400 Subject: [PATCH 003/383] fixing travis --- .travis.yml | 9 +-------- torba/stream.py | 6 +++--- 2 files changed, 4 insertions(+), 11 deletions(-) diff --git a/.travis.yml b/.travis.yml index 4056bc8b3..e37918195 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,4 +1,3 @@ -sudo: false language: python python: @@ -6,14 +5,8 @@ python: - "3.6" install: pip install tox-travis coverage - -script: - - tox +script: tox after_success: - coverage combine tests/ - bash <(curl -s https://codecov.io/bash) - -branches: - only: - - master diff --git a/torba/stream.py b/torba/stream.py index a5f3f63c9..6438b7184 100644 --- a/torba/stream.py +++ b/torba/stream.py @@ -128,7 +128,7 @@ class Stream: def listen(self, on_data, on_error=None, on_done=None): return self._controller._listen(on_data, on_error, on_done) - def where(self, condition): + def deferred_where(self, condition): deferred = Deferred() def where_test(value): @@ -142,8 +142,8 @@ class Stream: return deferred - def async_where(self, condition): - return self.where(condition).asFuture(asyncio.get_event_loop()) + def where(self, condition): + return self.deferred_where(condition).asFuture(asyncio.get_event_loop()) @property def first(self): From 246cc234c48295d0c25f0c3c896f382b88900d22 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 25 May 2018 13:19:54 -0400 Subject: [PATCH 004/383] test fixes to get it running on travis --- setup.py | 7 +++---- tests/unit/test_account.py | 22 +++++++++++----------- tests/unit/test_hash.py | 6 +++++- tests/unit/test_wallet.py | 4 ++-- torba/account.py | 8 ++++---- 5 files changed, 25 insertions(+), 22 deletions(-) diff --git a/setup.py b/setup.py index f8cfa7c17..57a7fe88e 100644 --- a/setup.py +++ b/setup.py @@ -2,12 +2,11 @@ import os import re from setuptools import setup, find_packages -init_file = open(os.path.join(os.path.dirname(__path__), 'torba', '__init__.py')).read() -version = re.search('\d+\.\d+\.\d+', init_file).group() +import torba setup( name='torba', - version=version, + version=torba.__version__, url='https://github.com/lbryio/torba', license='MIT', author='LBRY Inc.', @@ -29,7 +28,7 @@ setup( ), packages=find_packages(exclude=('tests',)), include_package_data=True, - python_requires='>=2.7,>=3.6', + python_requires='>=2.7', install_requires=( 'twisted', 'ecdsa', diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index a01aacbdd..3648c5fe4 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -39,25 +39,25 @@ class TestAccount(unittest.TestCase): ) self.assertEqual( account.private_key.extended_key_string(), - 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - '6yz3jMbycrLrRMpeAJxR8qDg8' + b'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + b'6yz3jMbycrLrRMpeAJxR8qDg8' ) self.assertEqual( account.public_key.extended_key_string(), - 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' - 'iW44g14WF52fYC5J483wqQ5ZP' + b'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' + b'iW44g14WF52fYC5J483wqQ5ZP' ) self.assertEqual( account.receiving_keys.generate_next_address(), - '1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP' + b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP' ) - private_key = account.get_private_key_for_address('1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') + private_key = account.get_private_key_for_address(b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') self.assertEqual( private_key.extended_key_string(), - 'xprv9xNEfQ296VTRaEUDZ8oKq74xw2U6kpj486vFUB4K1wT9U25GX4UwuzFgJN1YuRrqkQ5TTwCpkYnjNpSoHS' - 'BaEigNHPkoeYbuPMRo6mRUjxg' + b'xprv9xNEfQ296VTRaEUDZ8oKq74xw2U6kpj486vFUB4K1wT9U25GX4UwuzFgJN1YuRrqkQ5TTwCpkYnjNpSoHS' + b'BaEigNHPkoeYbuPMRo6mRUjxg' ) - self.assertIsNone(account.get_private_key_for_address('BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX')) + self.assertIsNone(account.get_private_key_for_address(b'BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX')) self.assertEqual( hexlify(private_key.wif()), @@ -92,12 +92,12 @@ class TestAccount(unittest.TestCase): self.assertEqual(len(account.receiving_keys.addresses), 2) self.assertEqual( account.receiving_keys.addresses[0], - '1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP' + b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP' ) self.assertEqual(len(account.change_keys.addresses), 1) self.assertEqual( account.change_keys.addresses[0], - '1PUbu1D1f3c244JPRSJKBCxRqui5NT6geR' + b'1PUbu1D1f3c244JPRSJKBCxRqui5NT6geR' ) self.maxDiff = None diff --git a/tests/unit/test_hash.py b/tests/unit/test_hash.py index 896337eba..8c7f09c53 100644 --- a/tests/unit/test_hash.py +++ b/tests/unit/test_hash.py @@ -1,7 +1,11 @@ -import mock from unittest import TestCase from torba.hash import aes_decrypt, aes_encrypt +try: + from unittest import mock +except ImportError: + import mock + class TestAESEncryptDecrypt(TestCase): diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index 992a6dee6..09d0bf884 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -86,12 +86,12 @@ class TestWalletCreation(unittest.TestCase): self.assertEqual(len(account.receiving_keys.addresses), 2) self.assertEqual( account.receiving_keys.addresses[0], - '1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP' + b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP' ) self.assertEqual(len(account.change_keys.addresses), 1) self.assertEqual( account.change_keys.addresses[0], - '1PUbu1D1f3c244JPRSJKBCxRqui5NT6geR' + b'1PUbu1D1f3c244JPRSJKBCxRqui5NT6geR' ) wallet_dict['coins'] = {'btc_mainnet': {'fee_per_byte': 50}} self.assertDictEqual(wallet_dict, wallet.to_dict()) diff --git a/torba/account.py b/torba/account.py index ea480c505..b166fcd3b 100644 --- a/torba/account.py +++ b/torba/account.py @@ -102,11 +102,11 @@ class Account: 'seed': self.seed, 'encrypted': self.encrypted, 'private_key': self.private_key if self.encrypted else - self.private_key.extended_key_string(), - 'public_key': self.public_key.extended_key_string(), - 'receiving_keys': [hexlify(k).decode('iso-8859-1') for k in self.receiving_keys.child_keys], + self.private_key.extended_key_string().decode(), + 'public_key': self.public_key.extended_key_string().decode(), + 'receiving_keys': [hexlify(k).decode() for k in self.receiving_keys.child_keys], 'receiving_gap': self.receiving_keys.minimum_gap, - 'change_keys': [hexlify(k).decode('iso-8859-1') for k in self.change_keys.child_keys], + 'change_keys': [hexlify(k).decode() for k in self.change_keys.child_keys], 'change_gap': self.change_keys.minimum_gap } From c86113b288eb393acbb7289794b0e7e68c487368 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 1 Jun 2018 01:32:12 -0400 Subject: [PATCH 005/383] torba icon --- torba.png | Bin 0 -> 11412 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 torba.png diff --git a/torba.png b/torba.png new file mode 100644 index 0000000000000000000000000000000000000000..675aa31bedebc5979806770308e154d983993087 GIT binary patch literal 11412 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 literal 0 HcmV?d00001 From 02768a8181a261cad2ec91de02b4af27c450d86e Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 1 Jun 2018 01:34:30 -0400 Subject: [PATCH 006/383] shorter icon --- torba.png | Bin 11412 -> 10917 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/torba.png b/torba.png index 675aa31bedebc5979806770308e154d983993087..4a525d661fef2c793b0589adf733331d0bf8b687 100644 GIT binary patch literal 10917 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 R3J#P)Fy>Y#D^C#O{ttcSuyX(a literal 11412 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 From 08f3ecbf25e4d56afeee79a4bc33067ab2a1ecc0 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 1 Jun 2018 01:52:51 -0400 Subject: [PATCH 007/383] initial readme --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index e69de29bb..37bd6d1cb 100644 --- a/README.md +++ b/README.md @@ -0,0 +1,3 @@ +# Torba Torba [![Build Status](https://travis-ci.org/lbryio/torba.svg?branch=master)](https://travis-ci.org/lbryio/torba) [![Test Coverage](https://codecov.io/gh/lbryio/torba/branch/master/graph/badge.svg)](https://codecov.io/gh/lbryio/torba) + +A new wallet library to help bitcoin based projects build fast, correct and scalable crypto currency wallets in Python. From 740af0465eb5cc54ca7605e561daf9ee18ba20b1 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 3 Jun 2018 20:06:55 -0400 Subject: [PATCH 008/383] send_amount_to_address --- torba/manager.py | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/torba/manager.py b/torba/manager.py index 3cde77314..84de427c1 100644 --- a/torba/manager.py +++ b/torba/manager.py @@ -5,6 +5,9 @@ from twisted.internet import defer from torba.account import AccountsView from torba.basecoin import CoinRegistry from torba.baseledger import BaseLedger +from torba.basetransaction import NULL_HASH +from torba.coinselection import CoinSelector +from torba.constants import COIN from torba.wallet import Wallet, WalletStorage @@ -81,3 +84,42 @@ class WalletManager: l.stop() for l in self.ledgers.values() ]) self.running = False + + def send_amount_to_address(self, amount, address): + amount = int(amount * COIN) + + account = self.default_account + coin = account.coin + ledger = coin.ledger + tx_class = ledger.transaction_class + in_class, out_class = tx_class.input_class, tx_class.output_class + + estimators = [ + txo.get_estimator(coin) for txo in account.get_unspent_utxos() + ] + + cost_of_output = coin.get_input_output_fee( + out_class.pay_pubkey_hash(COIN, NULL_HASH) + ) + + selector = CoinSelector(estimators, amount, cost_of_output) + spendables = selector.select() + if not spendables: + raise ValueError('Not enough funds to cover this transaction.') + + outputs = [ + out_class.pay_pubkey_hash(amount, coin.address_to_hash160(address)) + ] + + spent_sum = sum(s.effective_amount for s in spendables) + if spent_sum > amount: + change_address = account.get_least_used_change_address() + change_hash160 = coin.address_to_hash160(change_address) + outputs.append(out_class.pay_pubkey_hash(spent_sum - amount, change_hash160)) + + tx = tx_class() \ + .add_inputs([s.txi for s in spendables]) \ + .add_outputs(outputs) \ + .sign(account) + + return tx From 09a32174c81e7da6ea0b566c2d36790614a1c84c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 3 Jun 2018 20:07:40 -0400 Subject: [PATCH 009/383] handle tuples in network RPC request data --- torba/basenetwork.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/basenetwork.py b/torba/basenetwork.py index 2d45a2a2d..59c2855e7 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -25,7 +25,7 @@ def unicode2bytes(string): def bytes2unicode(maybe_bytes): if isinstance(maybe_bytes, bytes): return maybe_bytes.decode() - elif isinstance(maybe_bytes, list): + elif isinstance(maybe_bytes, (list, tuple)): return [bytes2unicode(b) for b in maybe_bytes] return maybe_bytes From 54350bcbc4c806b55ed4bdaf2a13489984f9630d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 3 Jun 2018 20:13:30 -0400 Subject: [PATCH 010/383] BaseOutputAmountEstimator --- torba/basetransaction.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/torba/basetransaction.py b/torba/basetransaction.py index ee23b0929..924186959 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -97,13 +97,13 @@ class BaseInput(InputOutput): class BaseOutputAmountEstimator(object): - __slots__ = 'coin', 'output', 'fee', 'effective_amount' + __slots__ = 'coin', 'txi', 'txo', 'fee', 'effective_amount' def __init__(self, coin, txo): # type: (BaseCoin, BaseOutput) -> None self.coin = coin - self.output = txo - txi = coin.transaction_class.input_class.spend(txo) - self.fee = coin.get_input_output_fee(txi) + self.txo = txo + self.txi = coin.transaction_class.input_class.spend(txo) + self.fee = coin.get_input_output_fee(self.txi) self.effective_amount = txo.amount - self.fee def __lt__(self, other): From 78e413515935e54568e79501db8dfe8b7c70e058 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 7 Jun 2018 23:47:46 -0400 Subject: [PATCH 011/383] wip --- tests/integration/__init__.py | 0 tests/integration/test_transactions.py | 32 ++++ tests/unit/test_account.py | 4 +- tests/unit/test_coinselection.py | 4 +- tests/unit/test_transaction.py | 4 +- tests/unit/test_wallet.py | 4 +- torba/account.py | 59 +++--- torba/basecoin.py | 11 +- torba/basedatabase.py | 219 ++++++++++++++++++++++ torba/baseledger.py | 249 ++++++++++++------------- torba/{manager.py => basemanager.py} | 25 ++- torba/basenetwork.py | 4 +- torba/basetransaction.py | 135 +++++++++++--- torba/coin/bitcoincash.py | 85 +++++++++ torba/coin/bitcoinsegwit.py | 83 +++++++++ torba/coin/btc.py | 43 ----- torba/coinselection.py | 4 +- 17 files changed, 708 insertions(+), 257 deletions(-) create mode 100644 tests/integration/__init__.py create mode 100644 tests/integration/test_transactions.py create mode 100644 torba/basedatabase.py rename torba/{manager.py => basemanager.py} (83%) create mode 100644 torba/coin/bitcoincash.py create mode 100644 torba/coin/bitcoinsegwit.py delete mode 100644 torba/coin/btc.py diff --git a/tests/integration/__init__.py b/tests/integration/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py new file mode 100644 index 000000000..fd16cc534 --- /dev/null +++ b/tests/integration/test_transactions.py @@ -0,0 +1,32 @@ +import asyncio +from orchstr8.testcase import IntegrationTestCase +from torba.constants import COIN + + +class BasicTransactionTests(IntegrationTestCase): + + VERBOSE = True + + async def test_sending_and_recieving(self): + account1, account2 = self.account, self.wallet.generate_account(self.ledger) + + self.assertEqual(await self.get_balance(account1), 0) + self.assertEqual(await self.get_balance(account2), 0) + + address = await account1.get_least_used_receiving_address().asFuture(asyncio.get_event_loop()) + sendtxid = await self.blockchain.send_to_address(address.decode(), 5.5) + await self.blockchain.generate(1) + await self.on_transaction(sendtxid) + + self.assertEqual(await self.get_balance(account1), int(5.5*COIN)) + self.assertEqual(await self.get_balance(account2), 0) + + address = await account2.get_least_used_receiving_address().asFuture(asyncio.get_event_loop()) + sendtxid = await self.blockchain.send_to_address(address.decode(), 5.5) + await self.broadcast(tx) + await self.on_transaction(tx.id.decode()) + await self.lbrycrd.generate(1) + + self.assertEqual(await self.get_balance(account1), int(3.0*COIN)) + self.assertEqual(await self.get_balance(account2), int(2.5*COIN)) + diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index 3648c5fe4..b75eb9b31 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -1,8 +1,8 @@ from binascii import hexlify from twisted.trial import unittest -from torba.coin.btc import BTC -from torba.manager import WalletManager +from torba.coin.bitcoinsegwit import BTC +from torba.basemanager import WalletManager from torba.wallet import Account diff --git a/tests/unit/test_coinselection.py b/tests/unit/test_coinselection.py index d57ff172d..4e2c2b565 100644 --- a/tests/unit/test_coinselection.py +++ b/tests/unit/test_coinselection.py @@ -1,9 +1,9 @@ import unittest -from torba.coin.btc import BTC +from torba.coin.bitcoinsegwit import BTC from torba.coinselection import CoinSelector, MAXIMUM_TRIES from torba.constants import CENT -from torba.manager import WalletManager +from torba.basemanager import WalletManager from .test_transaction import Output, get_output as utxo diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index fcdd2d736..bf34afc20 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -2,9 +2,9 @@ from binascii import hexlify, unhexlify from twisted.trial import unittest from torba.account import Account -from torba.coin.btc import BTC, Transaction, Output, Input +from torba.coin.bitcoinsegwit import BTC, Transaction, Output, Input from torba.constants import CENT, COIN -from torba.manager import WalletManager +from torba.basemanager import WalletManager from torba.wallet import Wallet diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index 09d0bf884..52e1240dd 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -1,7 +1,7 @@ from twisted.trial import unittest -from torba.coin.btc import BTC -from torba.manager import WalletManager +from torba.coin.bitcoinsegwit import BTC +from torba.basemanager import WalletManager from torba.wallet import Account, Wallet, WalletStorage from .ftc import FTC diff --git a/torba/account.py b/torba/account.py index b166fcd3b..acc518b5c 100644 --- a/torba/account.py +++ b/torba/account.py @@ -1,6 +1,7 @@ import itertools from typing import Dict, Generator from binascii import hexlify, unhexlify +from twisted.internet import defer from torba.basecoin import BaseCoin from torba.mnemonic import Mnemonic @@ -20,14 +21,14 @@ class KeyChain: for key in child_keys ] - @property + @defer.inlineCallbacks def has_gap(self): if len(self.addresses) < self.minimum_gap: - return False + defer.returnValue(False) for address in self.addresses[-self.minimum_gap:]: - if self.coin.ledger.is_address_old(address): - return False - return True + if (yield self.coin.ledger.is_address_old(address)): + defer.returnValue(False) + defer.returnValue(True) def generate_next_address(self): child_key = self.parent_key.child(len(self.child_keys)) @@ -35,11 +36,12 @@ class KeyChain: self.addresses.append(child_key.address) return child_key.address + @defer.inlineCallbacks def ensure_enough_addresses(self): starting_length = len(self.addresses) - while not self.has_gap: + while not (yield self.has_gap()): self.generate_next_address() - return self.addresses[starting_length:] + defer.returnValue(self.addresses[starting_length:]) class Account: @@ -135,50 +137,39 @@ class Account: if address == match: return self.private_key.child(a).child(b) + @defer.inlineCallbacks def ensure_enough_addresses(self): - return [ - address - for keychain in self.keychains - for address in keychain.ensure_enough_addresses() - ] - - def addresses_without_history(self): - for address in self.addresses: - if not self.coin.ledger.has_address(address): - yield address + addresses = [] + for keychain in self.keychains: + for address in (yield keychain.ensure_enough_addresses()): + addresses.append(address) + defer.returnValue(addresses) def get_least_used_receiving_address(self, max_transactions=1000): return self._get_least_used_address( - self.receiving_keys.addresses, self.receiving_keys, max_transactions ) def get_least_used_change_address(self, max_transactions=100): return self._get_least_used_address( - self.change_keys.addresses, self.change_keys, max_transactions ) - def _get_least_used_address(self, addresses, keychain, max_transactions): + def _get_least_used_address(self, keychain, max_transactions): ledger = self.coin.ledger - address = ledger.get_least_used_address(addresses, max_transactions) + address = ledger.get_least_used_address(self, keychain, max_transactions) if address: return address address = keychain.generate_next_address() ledger.subscribe_history(address) return address - def get_unspent_utxos(self): - return [ - utxo - for address in self.addresses - for utxo in self.coin.ledger.get_unspent_outputs(address) - ] - + @defer.inlineCallbacks def get_balance(self): - return sum(utxo.amount for utxo in self.get_unspent_utxos()) + utxos = yield self.coin.ledger.get_unspent_outputs(self) + defer.returnValue(sum(utxo.amount for utxo in utxos)) class AccountsView: @@ -188,3 +179,13 @@ class AccountsView: def __iter__(self): # type: () -> Generator[Account] return self._accounts_generator() + + def addresses(self): + for account in self: + for address in account.addresses: + yield address + + def get_account_for_address(self, address): + for account in self: + if address in account.addresses: + return account \ No newline at end of file diff --git a/torba/basecoin.py b/torba/basecoin.py index 2b8c04502..7b00115cd 100644 --- a/torba/basecoin.py +++ b/torba/basecoin.py @@ -44,22 +44,13 @@ class BaseCoin(six.with_metaclass(CoinRegistry)): def __init__(self, ledger, fee_per_byte): self.ledger = ledger - self.fee_per_byte = fee_per_byte @classmethod def get_id(cls): return '{}_{}'.format(cls.symbol.lower(), cls.network.lower()) def to_dict(self): - return {'fee_per_byte': self.fee_per_byte} - - def get_input_output_fee(self, io): - """ Fee based on size of the input / output. """ - return self.fee_per_byte * io.size - - def get_transaction_base_fee(self, tx): - """ Fee for the transaction header and all outputs; without inputs. """ - return self.fee_per_byte * tx.base_size + return {} def hash160_to_address(self, h160): raw_address = self.pubkey_address_prefix + h160 diff --git a/torba/basedatabase.py b/torba/basedatabase.py new file mode 100644 index 000000000..1b8082690 --- /dev/null +++ b/torba/basedatabase.py @@ -0,0 +1,219 @@ +import logging +import os +import sqlite3 +from twisted.internet import defer +from twisted.enterprise import adbapi + +log = logging.getLogger(__name__) + + +class BaseSQLiteWalletStorage(object): + + CREATE_TX_TABLE = """ + create table if not exists tx ( + txid blob primary key, + raw blob not null, + height integer not null, + is_confirmed boolean not null, + is_verified boolean not null + ); + create table if not exists address_status ( + address blob not null, + status text not null + ); + """ + + CREATE_TXO_TABLE = """ + create table if not exists txo ( + txoid integer primary key, + account blob not null, + address blob not null, + txid blob references tx, + pos integer not null, + amount integer not null, + script blob not null + ); + """ + + CREATE_TXI_TABLE = """ + create table if not exists txi ( + account blob not null, + txid blob references tx, + txoid integer references txo + ); + """ + + CREATE_TABLES_QUERY = ( + CREATE_TX_TABLE + + CREATE_TXO_TABLE + + CREATE_TXI_TABLE + ) + + def __init__(self, ledger): + self._db_path = os.path.join(ledger.path, "blockchain.db") + self.db = None + + def start(self): + log.info("connecting to database: %s", self._db_path) + self.db = adbapi.ConnectionPool( + 'sqlite3', self._db_path, cp_min=1, cp_max=1, check_same_thread=False + ) + return self.db.runInteraction( + lambda t: t.executescript(self.CREATE_TABLES_QUERY) + ) + + def stop(self): + self.db.close() + return defer.succeed(True) + + @defer.inlineCallbacks + def run_and_return_one_or_none(self, query, *args): + result = yield self.db.runQuery(query, args) + if result: + defer.returnValue(result[0][0]) + else: + defer.returnValue(None) + + @defer.inlineCallbacks + def run_and_return_list(self, query, *args): + result = yield self.db.runQuery(query, args) + if result: + defer.returnValue([i[0] for i in result]) + else: + defer.returnValue([]) + + def run_and_return_id(self, query, *args): + def do_save(t): + t.execute(query, args) + return t.lastrowid + return self.db.runInteraction(do_save) + + def add_transaction(self, tx, height, is_confirmed, is_verified): + return self.run_and_return_id( + "insert into tx values (?, ?, ?, ?, ?)", + sqlite3.Binary(tx.id), + sqlite3.Binary(tx.raw), + height, + is_confirmed, + is_verified + ) + + @defer.inlineCallbacks + def has_transaction(self, txid): + result = yield self.db.runQuery( + "select rowid from tx where txid=?", (txid,) + ) + defer.returnValue(bool(result)) + + def add_tx_output(self, account, txo): + return self.db.runOperation( + "insert into txo values (?, ?, ?, ?, ?, ?, ?, ?, ?)", ( + sqlite3.Binary(account.public_key.address), + sqlite3.Binary(txo.script.values['pubkey_hash']), + sqlite3.Binary(txo.txid), + txo.index, + txo.amount, + sqlite3.Binary(txo.script.source), + txo.script.is_claim_name, + txo.script.is_support_claim, + txo.script.is_update_claim + ) + ) + + def add_tx_input(self, account, txi): + def _ops(t): + txoid = t.execute( + "select rowid from txo where txid=? and pos=?", ( + sqlite3.Binary(txi.output_txid), txi.output_index + ) + ).fetchone()[0] + t.execute( + "insert into txi values (?, ?, ?)", ( + sqlite3.Binary(account.public_key.address), + sqlite3.Binary(txi.txid), + txoid + ) + ) + return self.db.runInteraction(_ops) + + @defer.inlineCallbacks + def get_balance_for_account(self, account): + result = yield self.db.runQuery( + "select sum(amount) from txo where account=:account and rowid not in (select txo from txi where account=:account)", + {'account': sqlite3.Binary(account.public_key.address)} + ) + if result: + defer.returnValue(result[0][0] or 0) + else: + defer.returnValue(0) + + def get_used_addresses(self, account): + return self.db.runQuery( + """ + SELECT + txios.address, + sum(txios.used_count) as total + FROM + (SELECT address, count(*) as used_count FROM txo + WHERE account=:account GROUP BY address + UNION + SELECT address, count(*) as used_count FROM txi NATURAL JOIN txo + WHERE account=:account GROUP BY address) AS txios + GROUP BY txios.address + ORDER BY total + """, {'account': sqlite3.Binary(account.public_key.address)} + ) + + @defer.inlineCallbacks + def get_earliest_block_height_for_address(self, address): + result = yield self.db.runQuery( + """ + SELECT + height + FROM + (SELECT DISTINCT height FROM txi NATURAL JOIN txo NATURAL JOIN tx WHERE address=:address + UNION + SELECT DISTINCT height FROM txo NATURAL JOIN tx WHERE address=:address) AS txios + ORDER BY height LIMIT 1 + """, {'address': sqlite3.Binary(address)} + ) + if result: + defer.returnValue(result[0][0]) + else: + defer.returnValue(None) + + @defer.inlineCallbacks + def get_utxos(self, account, output_class): + utxos = yield self.db.runQuery( + """ + SELECT + amount, script, txid + FROM txo + WHERE + account=:account AND + txoid NOT IN (SELECT txoid FROM txi WHERE account=:account) + """, + {'account': sqlite3.Binary(account.public_key.address)} + ) + defer.returnValue([ + output_class( + values[0], + output_class.script_class(values[1]), + values[2] + ) for values in utxos + ]) + + @defer.inlineCallbacks + def get_address_status(self, address): + result = yield self.db.runQuery( + "select status from address_status where address=?", (address,) + ) + if result: + defer.returnValue(result[0][0]) + else: + defer.returnValue(None) + + def set_address_status(self, address, status): + return self.db.runOperation( + "replace into address_status (address, status) values (?, ?)", (address,status) + ) diff --git a/torba/baseledger.py b/torba/baseledger.py index 99fb5f1d1..9f913df38 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -1,17 +1,18 @@ import os import hashlib +import struct from binascii import hexlify, unhexlify from typing import List, Dict, Type from operator import itemgetter from twisted.internet import threads, defer, task, reactor +from torba import basetransaction, basedatabase from torba.account import Account, AccountsView from torba.basecoin import BaseCoin -from torba.basetransaction import BaseTransaction from torba.basenetwork import BaseNetwork from torba.stream import StreamController, execute_serially -from torba.util import hex_to_int, int_to_hex, rev_hex, hash_encode +from torba.util import int_to_hex, rev_hex, hash_encode from torba.hash import double_sha256, pow_hash @@ -28,22 +29,11 @@ class Address: return len(self.transactions) def add_transaction(self, transaction): - self.transactions.append(transaction) - - def get_unspent_utxos(self): - inputs, outputs, utxos = [], [], [] - for tx in self: - for txi in tx.inputs: - inputs.append((txi.output_txid, txi.output_index)) - for txo in tx.outputs: - if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == self.pubkey_hash: - outputs.append((txo, txo.transaction.hash, txo.index)) - for output in set(outputs): - if output[1:] not in inputs: - yield output[0] + if transaction not in self.transactions: + self.transactions.append(transaction) -class BaseLedger: +class BaseLedger(object): # coin_class is automatically set by BaseCoin metaclass # when it creates the Coin classes, there is a 1..1 relationship @@ -52,21 +42,38 @@ class BaseLedger: # but many coin instances can exist linking back to the single Ledger instance. coin_class = None # type: Type[BaseCoin] network_class = None # type: Type[BaseNetwork] + headers_class = None # type: Type[BaseHeaders] + database_class = None # type: Type[basedatabase.BaseSQLiteWalletStorage] - verify_bits_to_target = True + default_fee_per_byte = 10 - def __init__(self, accounts, config=None, network=None, db=None): + def __init__(self, accounts, config=None, db=None, network=None, + fee_per_byte=default_fee_per_byte): self.accounts = accounts # type: AccountsView self.config = config or {} - self.db = db - self.addresses = {} # type: Dict[str, Address] - self.transactions = {} # type: Dict[str, BaseTransaction] - self.headers = Headers(self) - self._on_transaction_controller = StreamController() - self.on_transaction = self._on_transaction_controller.stream - self.network = network or self.network_class(self.config) + self.db = db or self.database_class(self) # type: basedatabase.BaseSQLiteWalletStorage + self.network = network or self.network_class(self) self.network.on_header.listen(self.process_header) self.network.on_status.listen(self.process_status) + self.headers = self.headers_class(self) + self.fee_per_byte = fee_per_byte + + self._on_transaction_controller = StreamController() + self.on_transaction = self._on_transaction_controller.stream + + @property + def path(self): + return os.path.join( + self.config['wallet_path'], self.coin_class.get_id() + ) + + def get_input_output_fee(self, io): + """ Fee based on size of the input / output. """ + return self.fee_per_byte * io.size + + def get_transaction_base_fee(self, tx): + """ Fee for the transaction header and all outputs; without inputs. """ + return self.fee_per_byte * tx.base_size @property def transaction_class(self): @@ -77,79 +84,51 @@ class BaseLedger: return cls(json_dict) @defer.inlineCallbacks - def load(self): - txs = yield self.db.get_transactions() - for tx_hash, raw, height in txs: - self.transactions[tx_hash] = self.transaction_class(raw, height) - txios = yield self.db.get_transaction_inputs_and_outputs() - for tx_hash, address_hash, input_output, amount, height in txios: - tx = self.transactions[tx_hash] - address = self.addresses.get(address_hash) - if address is None: - address = self.addresses[address_hash] = Address(self.coin_class.address_to_hash160(address_hash)) - tx.add_txio(address, input_output, amount) - address.add_transaction(tx) - def is_address_old(self, address, age_limit=2): - age = -1 - for tx in self.get_transactions(address, []): - if tx.height == 0: - tx_age = 0 - else: - tx_age = self.headers.height - tx.height + 1 - if tx_age > age: - age = tx_age + height = yield self.db.get_earliest_block_height_for_address(address) + if height is None: + return False + age = self.headers.height - height + 1 return age > age_limit - def add_transaction(self, address, transaction): # type: (str, BaseTransaction) -> None - if address not in self.addresses: - self.addresses[address] = Address(self.coin_class.address_to_hash160(address)) - self.addresses[address].add_transaction(transaction) - self.transactions.setdefault(transaction.id, transaction) + @defer.inlineCallbacks + def add_transaction(self, transaction, height): # type: (basetransaction.BaseTransaction, int) -> None + yield self.db.add_transaction(transaction, height, False, False) self._on_transaction_controller.add(transaction) def has_address(self, address): - return address in self.addresses + return address in self.accounts.addresses - def get_transaction(self, tx_hash, *args): - return self.transactions.get(tx_hash, *args) + @defer.inlineCallbacks + def get_least_used_address(self, account, keychain, max_transactions=100): + used_addresses = yield self.db.get_used_addresses(account) + unused_set = set(keychain.addresses) - set(map(itemgetter(0), used_addresses)) + if unused_set: + defer.returnValue(unused_set.pop()) + if used_addresses and used_addresses[0][1] < max_transactions: + defer.returnValue(used_addresses[0][0]) - def get_transactions(self, address, *args): - return self.addresses.get(address, *args) + def get_unspent_outputs(self, account): + return self.db.get_utxos(account, self.transaction_class.output_class) - def get_status(self, address): - hashes = [ - '{}:{}:'.format(hexlify(tx.hash), tx.height).encode() - for tx in self.get_transactions(address, []) if tx.height is not None - ] - if hashes: - return hexlify(hashlib.sha256(b''.join(hashes)).digest()) - - def has_transaction(self, tx_hash): - return tx_hash in self.transactions - - def get_least_used_address(self, addresses, max_transactions=100): - transaction_counts = [] - for address in addresses: - transactions = self.get_transactions(address, []) - tx_count = len(transactions) - if tx_count == 0: - return address - elif tx_count >= max_transactions: - continue - else: - transaction_counts.append((address, tx_count)) - if transaction_counts: - transaction_counts.sort(key=itemgetter(1)) - return transaction_counts[0] - - def get_unspent_outputs(self, address): - if address in self.addresses: - return list(self.addresses[address].get_unspent_utxos()) - return [] +# def get_unspent_outputs(self, account): +# inputs, outputs, utxos = set(), set(), set() +# for address in self.addresses.values(): +# for tx in address: +# for txi in tx.inputs: +# inputs.add((hexlify(txi.output_txid), txi.output_index)) +# for txo in tx.outputs: +# if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == address.pubkey_hash: +# outputs.add((txo, txo.transaction.id, txo.index)) +# for output in outputs: +# if output[1:] not in inputs: +# yield output[0] @defer.inlineCallbacks def start(self): + if not os.path.exists(self.path): + os.mkdir(self.path) + yield self.db.start() first_connection = self.network.on_connected.first self.network.start() yield first_connection @@ -197,13 +176,14 @@ class BaseLedger: # this avoids situation where we're getting status updates to addresses we know # need to update anyways. Continue to get history and create more addresses until # all missing addresses are created and history for them is fully restored. - account.ensure_enough_addresses() - addresses = list(account.addresses_without_history()) + yield account.ensure_enough_addresses() + used_addresses = yield self.db.get_used_addresses(account) + addresses = set(account.addresses) - set(map(itemgetter(0), used_addresses)) while addresses: yield defer.DeferredList([ self.update_history(a) for a in addresses ]) - addresses = account.ensure_enough_addresses() + addresses = yield account.ensure_enough_addresses() # By this point all of the addresses should be restored and we # can now subscribe all of them to receive updates. @@ -212,32 +192,49 @@ class BaseLedger: for address in account.addresses ]) + def _get_status_from_history(self, history): + hashes = [ + '{}:{}:'.format(hash.decode(), height).encode() + for hash, height in map(itemgetter('tx_hash', 'height'), history) + ] + if hashes: + return hexlify(hashlib.sha256(b''.join(hashes)).digest()) + @defer.inlineCallbacks - def update_history(self, address): + def update_history(self, address, remote_status=None): history = yield self.network.get_history(address) - for hash in map(itemgetter('tx_hash'), history): - transaction = self.get_transaction(hash) - if not transaction: + for hash, height in map(itemgetter('tx_hash', 'height'), history): + if not (yield self.db.has_transaction(hash)): raw = yield self.network.get_transaction(hash) transaction = self.transaction_class(unhexlify(raw)) - self.add_transaction(address, transaction) + yield self.add_transaction(transaction, height) + if remote_status is None: + remote_status = self._get_status_from_history(history) + if remote_status: + yield self.db.set_address_status(address, remote_status) @defer.inlineCallbacks def subscribe_history(self, address): - status = yield self.network.subscribe_address(address) - if status != self.get_status(address): - yield self.update_history(address) + remote_status = yield self.network.subscribe_address(address) + local_status = yield self.db.get_address_status(address) + if local_status != remote_status: + yield self.update_history(address, remote_status) + @defer.inlineCallbacks def process_status(self, response): - address, status = response - if status != self.get_status(address): - task.deferLater(reactor, 0, self.update_history, address) + address, remote_status = response + local_status = yield self.db.get_address_status(address) + if local_status != remote_status: + yield self.update_history(address, remote_status) def broadcast(self, tx): return self.network.broadcast(hexlify(tx.raw)) -class Headers: +class BaseHeaders: + + header_size = 80 + verify_bits_to_target = True def __init__(self, ledger): self.ledger = ledger @@ -247,9 +244,7 @@ class Headers: @property def path(self): - wallet_path = self.ledger.config.get('wallet_path', '') - filename = '{}_headers'.format(self.ledger.coin_class.get_id()) - return os.path.join(wallet_path, filename) + return os.path.join(self.ledger.path, 'headers') def touch(self): if not os.path.exists(self.path): @@ -261,13 +256,13 @@ class Headers: return len(self) - 1 def sync_read_length(self): - return os.path.getsize(self.path) // self.ledger.header_size + return os.path.getsize(self.path) // self.header_size def sync_read_header(self, height): if 0 <= height < len(self): with open(self.path, 'rb') as f: - f.seek(height * self.ledger.header_size) - return f.read(self.ledger.header_size) + f.seek(height * self.header_size) + return f.read(self.header_size) def __len__(self): if self._size is None: @@ -295,7 +290,7 @@ class Headers: previous_header = header with open(self.path, 'r+b') as f: - f.seek(start * self.ledger.header_size) + f.seek(start * self.header_size) f.write(headers) f.truncate() @@ -306,9 +301,9 @@ class Headers: self._on_change_controller.add(change) def _iterate_headers(self, height, headers): - assert len(headers) % self.ledger.header_size == 0 - for idx in range(len(headers) // self.ledger.header_size): - start, end = idx * self.ledger.header_size, (idx + 1) * self.ledger.header_size + assert len(headers) % self.header_size == 0 + for idx in range(len(headers) // self.header_size): + start, end = idx * self.header_size, (idx + 1) * self.header_size header = headers[start:end] yield self._deserialize(height+idx, header) @@ -317,15 +312,16 @@ class Headers: assert previous_hash == header['prev_block_hash'], \ "prev hash mismatch: {} vs {}".format(previous_hash, header['prev_block_hash']) - bits, target = self._calculate_lbry_next_work_required(height, previous_header, header) + bits, target = self._calculate_next_work_required(height, previous_header, header) assert bits == header['bits'], \ "bits mismatch: {} vs {} (hash: {})".format( bits, header['bits'], self._hash_header(header)) - _pow_hash = self._pow_hash_header(header) - assert int(b'0x' + _pow_hash, 16) <= target, \ - "insufficient proof of work: {} vs target {}".format( - int(b'0x' + _pow_hash, 16), target) + # TODO: FIX ME!!! + #_pow_hash = self._pow_hash_header(header) + #assert int(b'0x' + _pow_hash, 16) <= target, \ + # "insufficient proof of work: {} vs target {}".format( + # int(b'0x' + _pow_hash, 16), target) @staticmethod def _serialize(header): @@ -333,7 +329,6 @@ class Headers: int_to_hex(header['version'], 4), rev_hex(header['prev_block_hash']), rev_hex(header['merkle_root']), - rev_hex(header['claim_trie_root']), int_to_hex(int(header['timestamp']), 4), int_to_hex(int(header['bits']), 4), int_to_hex(int(header['nonce']), 4) @@ -341,15 +336,16 @@ class Headers: @staticmethod def _deserialize(height, header): + version, = struct.unpack('> 24) & 0xff - assert 0x03 <= bitsN <= 0x1f, \ + assert 0x03 <= bitsN <= 0x1d, \ "First part of bits should be in [0x03, 0x1d], but it was {}".format(hex(bitsN)) bitsBase = bits & 0xffffff assert 0x8000 <= bitsBase <= 0x7fffff, \ diff --git a/torba/manager.py b/torba/basemanager.py similarity index 83% rename from torba/manager.py rename to torba/basemanager.py index 84de427c1..ea5b6e9f7 100644 --- a/torba/manager.py +++ b/torba/basemanager.py @@ -5,13 +5,13 @@ from twisted.internet import defer from torba.account import AccountsView from torba.basecoin import CoinRegistry from torba.baseledger import BaseLedger -from torba.basetransaction import NULL_HASH +from torba.basetransaction import BaseTransaction, NULL_HASH from torba.coinselection import CoinSelector from torba.constants import COIN from torba.wallet import Wallet, WalletStorage -class WalletManager: +class BaseWalletManager(object): def __init__(self, wallets=None, ledgers=None): self.wallets = wallets or [] # type: List[Wallet] @@ -35,10 +35,22 @@ class WalletManager: ledger_class = coin_class.ledger_class ledger = self.ledgers.get(ledger_class) if ledger is None: - ledger = ledger_class(self.get_accounts_view(coin_class), ledger_config or {}) + ledger = self.create_ledger(ledger_class, self.get_accounts_view(coin_class), ledger_config or {}) self.ledgers[ledger_class] = ledger return ledger + def create_ledger(self, ledger_class, accounts, config): + return ledger_class(accounts, config) + + @defer.inlineCallbacks + def get_balance(self): + balances = {} + for ledger in self.ledgers: + for account in self.get_accounts(ledger.coin_class): + balances.setdefault(ledger.coin_class.name, 0) + balances[ledger.coin_class.name] += yield account.get_balance() + defer.returnValue(balances) + @property def default_wallet(self): for wallet in self.wallets: @@ -72,14 +84,14 @@ class WalletManager: return wallet.generate_account(ledger) @defer.inlineCallbacks - def start_ledgers(self): + def start(self): self.running = True yield defer.DeferredList([ l.start() for l in self.ledgers.values() ]) @defer.inlineCallbacks - def stop_ledgers(self): + def stop(self): yield defer.DeferredList([ l.stop() for l in self.ledgers.values() ]) @@ -91,12 +103,13 @@ class WalletManager: account = self.default_account coin = account.coin ledger = coin.ledger - tx_class = ledger.transaction_class + tx_class = ledger.transaction_class # type: BaseTransaction in_class, out_class = tx_class.input_class, tx_class.output_class estimators = [ txo.get_estimator(coin) for txo in account.get_unspent_utxos() ] + tx_class.create() cost_of_output = coin.get_input_output_fee( out_class.pay_pubkey_hash(COIN, NULL_HASH) diff --git a/torba/basenetwork.py b/torba/basenetwork.py index 59c2855e7..2b16ee767 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -137,8 +137,8 @@ class StratumClientFactory(protocol.ClientFactory): class BaseNetwork: - def __init__(self, config): - self.config = config + def __init__(self, ledger): + self.config = ledger.config self.client = None self.service = None self.running = False diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 924186959..6963db4c0 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -1,10 +1,12 @@ import six import logging -from typing import List +from typing import List, Iterable, Generator from binascii import hexlify -from torba.basecoin import BaseCoin +from torba import baseledger from torba.basescript import BaseInputScript, BaseOutputScript +from torba.coinselection import CoinSelector +from torba.constants import COIN from torba.bcd_data_stream import BCDataStream from torba.hash import sha256 from torba.account import Account @@ -19,6 +21,17 @@ NULL_HASH = b'\x00'*32 class InputOutput(object): + def __init__(self, txid): + self._txid = txid # type: bytes + self.transaction = None # type: BaseTransaction + self.index = None # type: int + + @property + def txid(self): + if self._txid is None: + self._txid = self.transaction.id + return self._txid + @property def size(self): """ Size of this input / output in bytes. """ @@ -37,10 +50,11 @@ class BaseInput(InputOutput): NULL_SIGNATURE = b'\x00'*72 NULL_PUBLIC_KEY = b'\x00'*33 - def __init__(self, output_or_txid_index, script, sequence=0xFFFFFFFF): + def __init__(self, output_or_txid_index, script, sequence=0xFFFFFFFF, txid=None): + super(BaseInput, self).__init__(txid) if isinstance(output_or_txid_index, BaseOutput): self.output = output_or_txid_index # type: BaseOutput - self.output_txid = self.output.transaction.hash + self.output_txid = self.output.transaction.id self.output_index = self.output.index else: self.output = None # type: BaseOutput @@ -52,7 +66,7 @@ class BaseInput(InputOutput): def link_output(self, output): assert self.output is None - assert self.output_txid == output.transaction.hash + assert self.output_txid == output.transaction.id assert self.output_index == output.index self.output = output @@ -95,15 +109,14 @@ class BaseInput(InputOutput): stream.write_uint32(self.sequence) -class BaseOutputAmountEstimator(object): +class BaseOutputEffectiveAmountEstimator(object): __slots__ = 'coin', 'txi', 'txo', 'fee', 'effective_amount' - def __init__(self, coin, txo): # type: (BaseCoin, BaseOutput) -> None - self.coin = coin + def __init__(self, ledger, txo): # type: (baseledger.BaseLedger, BaseOutput) -> None self.txo = txo - self.txi = coin.transaction_class.input_class.spend(txo) - self.fee = coin.get_input_output_fee(self.txi) + self.txi = ledger.transaction_class.input_class.spend(txo) + self.fee = ledger.get_input_output_fee(self.txi) self.effective_amount = txo.amount - self.fee def __lt__(self, other): @@ -113,16 +126,15 @@ class BaseOutputAmountEstimator(object): class BaseOutput(InputOutput): script_class = None - estimator_class = BaseOutputAmountEstimator + estimator_class = BaseOutputEffectiveAmountEstimator - def __init__(self, amount, script): + def __init__(self, amount, script, txid=None): + super(BaseOutput, self).__init__(txid) self.amount = amount # type: int self.script = script # type: BaseOutputScript - self.transaction = None # type: BaseTransaction - self.index = None # type: int - def get_estimator(self, coin): - return self.estimator_class(coin, self) + def get_estimator(self, ledger): + return self.estimator_class(ledger, self) @classmethod def pay_pubkey_hash(cls, amount, pubkey_hash): @@ -145,23 +157,25 @@ class BaseTransaction: input_class = None output_class = None - def __init__(self, raw=None, version=1, locktime=0, height=None, is_saved=False): + def __init__(self, raw=None, version=1, locktime=0): self._raw = raw self._hash = None self._id = None self.version = version # type: int self.locktime = locktime # type: int - self.height = height # type: int self._inputs = [] # type: List[BaseInput] self._outputs = [] # type: List[BaseOutput] - self.is_saved = is_saved # type: bool if raw is not None: self._deserialize() + @property + def hex_id(self): + return hexlify(self.id) + @property def id(self): if self._id is None: - self._id = hexlify(self.hash[::-1]) + self._id = self.hash[::-1] return self._id @property @@ -189,18 +203,19 @@ class BaseTransaction: def outputs(self): # type: () -> ReadOnlyList[BaseOutput] return ReadOnlyList(self._outputs) - def add_inputs(self, inputs): - self._inputs.extend(inputs) + def _add(self, new_ios, existing_ios): + for txio in new_ios: + txio.transaction = self + txio.index = len(existing_ios) + existing_ios.append(txio) self._reset() return self + def add_inputs(self, inputs): + return self._add(inputs, self._inputs) + def add_outputs(self, outputs): - for txo in outputs: - txo.transaction = self - txo.index = len(self._outputs) - self._outputs.append(txo) - self._reset() - return self + return self._add(outputs, self._outputs) @property def fee(self): @@ -260,16 +275,76 @@ class BaseTransaction: ]) self.locktime = stream.read_uint32() - def sign(self, account): # type: (Account) -> BaseTransaction + @classmethod + def get_effective_amount_estimators(cls, funding_accounts): + # type: (Iterable[Account]) -> Generator[BaseOutputEffectiveAmountEstimator] + for account in funding_accounts: + for utxo in account.coin.ledger.get_unspent_outputs(account): + yield utxo.get_estimator(account.coin) + + @classmethod + def ensure_all_have_same_ledger(cls, funding_accounts, change_account=None): + # type: (Iterable[Account], Account) -> baseledger.BaseLedger + ledger = None + for account in funding_accounts: + if ledger is None: + ledger = account.coin.ledger + if ledger != account.coin.ledger: + raise ValueError( + 'All funding accounts used to create a transaction must be on the same ledger.' + ) + if change_account is not None and change_account.coin.ledger != ledger: + raise ValueError('Change account must use same ledger as funding accounts.') + return ledger + + @classmethod + def pay(cls, outputs, funding_accounts, change_account): + """ Efficiently spend utxos from funding_accounts to cover the new outputs. """ + + tx = cls().add_outputs(outputs) + ledger = cls.ensure_all_have_same_ledger(funding_accounts, change_account) + amount = ledger.get_transaction_base_fee(tx) + selector = CoinSelector( + list(cls.get_effective_amount_estimators(funding_accounts)), + amount, + ledger.get_input_output_fee( + cls.output_class.pay_pubkey_hash(COIN, NULL_HASH) + ) + ) + + spendables = selector.select() + if not spendables: + raise ValueError('Not enough funds to cover this transaction.') + + spent_sum = sum(s.effective_amount for s in spendables) + if spent_sum > amount: + change_address = change_account.get_least_used_change_address() + change_hash160 = change_account.coin.address_to_hash160(change_address) + change_amount = spent_sum - amount + tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) + + tx.add_inputs([s.txi for s in spendables]) + tx.sign(funding_accounts) + return tx + + @classmethod + def liquidate(cls, assets, funding_accounts, change_account): + """ Spend assets (utxos) supplementing with funding_accounts if fee is higher than asset value. """ + + def sign(self, funding_accounts): # type: (Iterable[Account]) -> BaseTransaction + ledger = self.ensure_all_have_same_ledger(funding_accounts) for i, txi in enumerate(self._inputs): txo_script = txi.output.script if txo_script.is_pay_pubkey_hash: - address = account.coin.hash160_to_address(txo_script.values['pubkey_hash']) + address = ledger.coin_class.hash160_to_address(txo_script.values['pubkey_hash']) + account = ledger.accounts.get_account_for_address(address) private_key = account.get_private_key_for_address(address) tx = self._serialize_for_signature(i) txi.script.values['signature'] = private_key.sign(tx)+six.int2byte(1) txi.script.values['pubkey'] = private_key.public_key.pubkey_bytes txi.script.generate() + else: + raise NotImplementedError("Don't know how to spend this output.") self._reset() return self diff --git a/torba/coin/bitcoincash.py b/torba/coin/bitcoincash.py new file mode 100644 index 000000000..6f41e126f --- /dev/null +++ b/torba/coin/bitcoincash.py @@ -0,0 +1,85 @@ +__coin__ = 'BitcoinCash' +__node_daemon__ = 'bitcoind' +__node_cli__ = 'bitcoin-cli' +__node_url__ = ( + 'https://download.bitcoinabc.org/0.17.2/linux/bitcoin-abc-0.17.2-x86_64-linux-gnu.tar.gz' +) + +from six import int2byte +from binascii import unhexlify +from torba.baseledger import BaseLedger, BaseHeaders +from torba.basenetwork import BaseNetwork +from torba.basescript import BaseInputScript, BaseOutputScript +from torba.basetransaction import BaseTransaction, BaseInput, BaseOutput +from torba.basecoin import BaseCoin +from torba.basedatabase import BaseSQLiteWalletStorage +from torba.basemanager import BaseWalletManager + + +class WalletManager(BaseWalletManager): + pass + + +class Input(BaseInput): + script_class = BaseInputScript + + +class Output(BaseOutput): + script_class = BaseOutputScript + + +class Transaction(BaseTransaction): + input_class = Input + output_class = Output + + +class BitcoinCashLedger(BaseLedger): + network_class = BaseNetwork + headers_class = BaseHeaders + database_class = BaseSQLiteWalletStorage + + +class MainNetLedger(BitcoinCashLedger): + pass + + +class UnverifiedHeaders(BaseHeaders): + verify_bits_to_target = False + + +class RegTestLedger(BitcoinCashLedger): + headers_class = UnverifiedHeaders + max_target = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + genesis_hash = '0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206' + genesis_bits = 0x207fffff + target_timespan = 1 + verify_bits_to_target = False + + +class BitcoinCash(BaseCoin): + name = 'BitcoinCash' + symbol = 'BCH' + network = 'mainnet' + + ledger_class = MainNetLedger + transaction_class = Transaction + + pubkey_address_prefix = int2byte(0x00) + script_address_prefix = int2byte(0x05) + extended_public_key_prefix = unhexlify('0488b21e') + extended_private_key_prefix = unhexlify('0488ade4') + + default_fee_per_byte = 50 + + def __init__(self, ledger, fee_per_byte=default_fee_per_byte): + super(BitcoinCash, self).__init__(ledger, fee_per_byte) + + +class BitcoinCashRegtest(BitcoinCash): + network = 'regtest' + ledger_class = RegTestLedger + pubkey_address_prefix = int2byte(111) + script_address_prefix = int2byte(196) + extended_public_key_prefix = unhexlify('043587cf') + extended_private_key_prefix = unhexlify('04358394') + diff --git a/torba/coin/bitcoinsegwit.py b/torba/coin/bitcoinsegwit.py new file mode 100644 index 000000000..82d0fcbb5 --- /dev/null +++ b/torba/coin/bitcoinsegwit.py @@ -0,0 +1,83 @@ +__coin__ = 'BitcoinSegwit' +__node_daemon__ = 'bitcoind' +__node_cli__ = 'bitcoin-cli' +__node_url__ = ( + 'https://bitcoin.org/bin/bitcoin-core-0.16.0/bitcoin-0.16.0-x86_64-linux-gnu.tar.gz' +) + +from six import int2byte +from binascii import unhexlify +from torba.baseledger import BaseLedger, BaseHeaders +from torba.basenetwork import BaseNetwork +from torba.basescript import BaseInputScript, BaseOutputScript +from torba.basetransaction import BaseTransaction, BaseInput, BaseOutput +from torba.basecoin import BaseCoin +from torba.basedatabase import BaseSQLiteWalletStorage +from torba.basemanager import BaseWalletManager + + +class WalletManager(BaseWalletManager): + pass + + +class SQLiteWalletStorage(BaseSQLiteWalletStorage): + pass + + +class Input(BaseInput): + script_class = BaseInputScript + + +class Output(BaseOutput): + script_class = BaseOutputScript + + +class Transaction(BaseTransaction): + input_class = Input + output_class = Output + + +class BitcoinSegwitLedger(BaseLedger): + network_class = BaseNetwork + headers_class = BaseHeaders + + +class MainNetLedger(BitcoinSegwitLedger): + pass + + +class UnverifiedHeaders(BaseHeaders): + verify_bits_to_target = False + + +class RegTestLedger(BitcoinSegwitLedger): + headers_class = UnverifiedHeaders + max_target = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + genesis_hash = '0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206' + genesis_bits = 0x207fffff + target_timespan = 1 + verify_bits_to_target = False + + +class BitcoinSegwit(BaseCoin): + name = 'BitcoinSegwit' + symbol = 'BTC' + network = 'mainnet' + + ledger_class = MainNetLedger + transaction_class = Transaction + + pubkey_address_prefix = int2byte(0x00) + script_address_prefix = int2byte(0x05) + extended_public_key_prefix = unhexlify('0488b21e') + extended_private_key_prefix = unhexlify('0488ade4') + + default_fee_per_byte = 50 + + def __init__(self, ledger, fee_per_byte=default_fee_per_byte): + super(BitcoinSegwit, self).__init__(ledger, fee_per_byte) + + +class BitcoinSegwitRegtest(BitcoinSegwit): + network = 'regtest' + ledger_class = RegTestLedger diff --git a/torba/coin/btc.py b/torba/coin/btc.py deleted file mode 100644 index d6f23127e..000000000 --- a/torba/coin/btc.py +++ /dev/null @@ -1,43 +0,0 @@ -from six import int2byte -from binascii import unhexlify -from torba.baseledger import BaseLedger -from torba.basenetwork import BaseNetwork -from torba.basescript import BaseInputScript, BaseOutputScript -from torba.basetransaction import BaseTransaction, BaseInput, BaseOutput -from torba.basecoin import BaseCoin - - -class Ledger(BaseLedger): - network_class = BaseNetwork - - -class Input(BaseInput): - script_class = BaseInputScript - - -class Output(BaseOutput): - script_class = BaseOutputScript - - -class Transaction(BaseTransaction): - input_class = Input - output_class = Output - - -class BTC(BaseCoin): - name = 'Bitcoin' - symbol = 'BTC' - network = 'mainnet' - - ledger_class = Ledger - transaction_class = Transaction - - pubkey_address_prefix = int2byte(0x00) - script_address_prefix = int2byte(0x05) - extended_public_key_prefix = unhexlify('0488b21e') - extended_private_key_prefix = unhexlify('0488ade4') - - default_fee_per_byte = 50 - - def __init__(self, ledger, fee_per_byte=default_fee_per_byte): - super(BTC, self).__init__(ledger, fee_per_byte) diff --git a/torba/coinselection.py b/torba/coinselection.py index c0bf38502..398781676 100644 --- a/torba/coinselection.py +++ b/torba/coinselection.py @@ -2,7 +2,7 @@ import six from random import Random from typing import List -from torba.basetransaction import BaseOutputAmountEstimator +import torba MAXIMUM_TRIES = 100000 @@ -10,7 +10,7 @@ MAXIMUM_TRIES = 100000 class CoinSelector: def __init__(self, txos, target, cost_of_change, seed=None): - # type: (List[BaseOutputAmountEstimator], int, int, str) -> None + # type: (List[torba.basetransaction.BaseOutputAmountEstimator], int, int, str) -> None self.txos = txos self.target = target self.cost_of_change = cost_of_change From eb6781481a5b66a3c1e4256082de11764087c537 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 11 Jun 2018 09:33:32 -0400 Subject: [PATCH 012/383] progress since thursday --- tests/unit/ftc.py | 43 ---- tests/unit/test_account.py | 96 +++---- tests/unit/test_coinselection.py | 12 +- tests/unit/test_ledger.py | 15 ++ tests/unit/test_transaction.py | 73 +++--- tests/unit/test_wallet.py | 2 +- torba/account.py | 191 -------------- torba/baseaccount.py | 184 +++++++++++++ torba/basecoin.py | 70 ----- torba/basedatabase.py | 356 +++++++++++++++---------- torba/baseheader.py | 243 +++++++++++++++++ torba/baseledger.py | 372 ++++++--------------------- torba/basetransaction.py | 30 +-- torba/bip32.py | 47 ++-- torba/coin/bitcoincash.py | 2 +- torba/coin/bitcoinsegwit.py | 75 ++---- torba/{basemanager.py => manager.py} | 11 +- torba/wallet.py | 52 ++-- 18 files changed, 919 insertions(+), 955 deletions(-) delete mode 100644 tests/unit/ftc.py delete mode 100644 torba/account.py create mode 100644 torba/baseaccount.py delete mode 100644 torba/basecoin.py create mode 100644 torba/baseheader.py rename torba/{basemanager.py => manager.py} (93%) diff --git a/tests/unit/ftc.py b/tests/unit/ftc.py deleted file mode 100644 index c838a3f28..000000000 --- a/tests/unit/ftc.py +++ /dev/null @@ -1,43 +0,0 @@ -from six import int2byte -from binascii import unhexlify -from torba.baseledger import BaseLedger -from torba.basenetwork import BaseNetwork -from torba.basescript import BaseInputScript, BaseOutputScript -from torba.basetransaction import BaseTransaction, BaseInput, BaseOutput -from torba.basecoin import BaseCoin - - -class Ledger(BaseLedger): - network_class = BaseNetwork - - -class Input(BaseInput): - script_class = BaseInputScript - - -class Output(BaseOutput): - script_class = BaseOutputScript - - -class Transaction(BaseTransaction): - input_class = Input - output_class = Output - - -class FTC(BaseCoin): - name = 'Fakecoin' - symbol = 'FTC' - network = 'mainnet' - - ledger_class = Ledger - transaction_class = Transaction - - pubkey_address_prefix = int2byte(0x00) - script_address_prefix = int2byte(0x05) - extended_public_key_prefix = unhexlify('0488b21e') - extended_private_key_prefix = unhexlify('0488ade4') - - default_fee_per_byte = 50 - - def __init__(self, ledger, fee_per_byte=default_fee_per_byte): - super(FTC, self).__init__(ledger, fee_per_byte) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index b75eb9b31..323420ba4 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -1,38 +1,48 @@ from binascii import hexlify from twisted.trial import unittest +from twisted.internet import defer -from torba.coin.bitcoinsegwit import BTC -from torba.basemanager import WalletManager -from torba.wallet import Account +from torba.coin.bitcoinsegwit import MainNetLedger class TestAccount(unittest.TestCase): def setUp(self): - ledger = WalletManager().get_or_create_ledger(BTC.get_id()) - self.coin = BTC(ledger) + self.ledger = MainNetLedger(db=':memory:') + return self.ledger.db.start() + @defer.inlineCallbacks def test_generate_account(self): - account = Account.generate(self.coin, u"torba") - self.assertEqual(account.coin, self.coin) + account = self.ledger.account_class.generate(self.ledger, u"torba") + self.assertEqual(account.ledger, self.ledger) self.assertIsNotNone(account.seed) - self.assertEqual(account.public_key.coin, self.coin) + self.assertEqual(account.public_key.ledger, self.ledger) self.assertEqual(account.private_key.public_key, account.public_key) - self.assertEqual(len(account.receiving_keys.child_keys), 0) - self.assertEqual(len(account.receiving_keys.addresses), 0) - self.assertEqual(len(account.change_keys.child_keys), 0) - self.assertEqual(len(account.change_keys.addresses), 0) + keys = yield account.receiving.get_keys() + addresses = yield account.receiving.get_addresses() + self.assertEqual(len(keys), 0) + self.assertEqual(len(addresses), 0) + keys = yield account.change.get_keys() + addresses = yield account.change.get_addresses() + self.assertEqual(len(keys), 0) + self.assertEqual(len(addresses), 0) - account.ensure_enough_addresses() - self.assertEqual(len(account.receiving_keys.child_keys), 20) - self.assertEqual(len(account.receiving_keys.addresses), 20) - self.assertEqual(len(account.change_keys.child_keys), 6) - self.assertEqual(len(account.change_keys.addresses), 6) + yield account.ensure_enough_useable_addresses() + keys = yield account.receiving.get_keys() + addresses = yield account.receiving.get_addresses() + self.assertEqual(len(keys), 20) + self.assertEqual(len(addresses), 20) + keys = yield account.change.get_keys() + addresses = yield account.change.get_addresses() + self.assertEqual(len(keys), 6) + self.assertEqual(len(addresses), 6) + + @defer.inlineCallbacks def test_generate_account_from_seed(self): - account = Account.from_seed( - self.coin, + account = self.ledger.account_class.from_seed( + self.ledger, u"carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" u"sent", u"torba" @@ -47,23 +57,22 @@ class TestAccount(unittest.TestCase): b'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' b'iW44g14WF52fYC5J483wqQ5ZP' ) - self.assertEqual( - account.receiving_keys.generate_next_address(), - b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP' - ) - private_key = account.get_private_key_for_address(b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') + address = yield account.receiving.ensure_enough_useable_addresses() + self.assertEqual(address[0], b'1PGDB1CRy8UxPCrkcakRqroVnHxqzvUZhp') + private_key = yield self.ledger.get_private_key_for_address(b'1PGDB1CRy8UxPCrkcakRqroVnHxqzvUZhp') self.assertEqual( private_key.extended_key_string(), - b'xprv9xNEfQ296VTRaEUDZ8oKq74xw2U6kpj486vFUB4K1wT9U25GX4UwuzFgJN1YuRrqkQ5TTwCpkYnjNpSoHS' - b'BaEigNHPkoeYbuPMRo6mRUjxg' + b'xprv9xNEfQ296VTRc5QF7AZZ1WTimGzMs54FepRXVxbyypJXCrUKjxsYSyk5EhHYNxU4ApsaBr8AQ4sYo86BbGh2dZSddGXU1CMGwExvnyckjQn' ) - self.assertIsNone(account.get_private_key_for_address(b'BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX')) + invalid_key = yield self.ledger.get_private_key_for_address(b'BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX') + self.assertIsNone(invalid_key) self.assertEqual( hexlify(private_key.wif()), - b'1cc27be89ad47ef932562af80e95085eb0ab2ae3e5c019b1369b8b05ff2e94512f01' + b'1c5664e848772b199644ab390b5c27d2f6664d9cdfdb62e1c7ac25151b00858b7a01' ) + @defer.inlineCallbacks def test_load_and_save_account(self): account_data = { 'seed': @@ -77,29 +86,22 @@ class TestAccount(unittest.TestCase): 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' 'iW44g14WF52fYC5J483wqQ5ZP', 'receiving_gap': 10, - 'receiving_keys': [ - '0222345947a59dca4a3363ffa81ac87dd907d2b2feff57383eaeddbab266ca5f2d', - '03fdc9826d5d00a484188cba8eb7dba5877c0323acb77905b7bcbbab35d94be9f6' - ], 'change_gap': 10, - 'change_keys': [ - '038836be4147836ed6b4df6a89e0d9f1b1c11cec529b7ff5407de57f2e5b032c83' - ] } - account = Account.from_dict(self.coin, account_data) + account = self.ledger.account_class.from_dict(self.ledger, account_data) - self.assertEqual(len(account.receiving_keys.addresses), 2) - self.assertEqual( - account.receiving_keys.addresses[0], - b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP' - ) - self.assertEqual(len(account.change_keys.addresses), 1) - self.assertEqual( - account.change_keys.addresses[0], - b'1PUbu1D1f3c244JPRSJKBCxRqui5NT6geR' - ) + yield account.ensure_enough_useable_addresses() + + keys = yield account.receiving.get_keys() + addresses = yield account.receiving.get_addresses() + self.assertEqual(len(keys), 10) + self.assertEqual(len(addresses), 10) + keys = yield account.change.get_keys() + addresses = yield account.change.get_addresses() + self.assertEqual(len(keys), 10) + self.assertEqual(len(addresses), 10) self.maxDiff = None - account_data['coin'] = 'btc_mainnet' + account_data['ledger'] = 'btc_mainnet' self.assertDictEqual(account_data, account.to_dict()) diff --git a/tests/unit/test_coinselection.py b/tests/unit/test_coinselection.py index 4e2c2b565..2e07ee73a 100644 --- a/tests/unit/test_coinselection.py +++ b/tests/unit/test_coinselection.py @@ -1,9 +1,9 @@ import unittest -from torba.coin.bitcoinsegwit import BTC +from torba.coin.bitcoinsegwit import MainNetLedger from torba.coinselection import CoinSelector, MAXIMUM_TRIES from torba.constants import CENT -from torba.basemanager import WalletManager +from torba.manager import WalletManager from .test_transaction import Output, get_output as utxo @@ -19,12 +19,12 @@ def search(*args, **kwargs): class BaseSelectionTestCase(unittest.TestCase): def setUp(self): - ledger = WalletManager().get_or_create_ledger(BTC.get_id()) - self.coin = BTC(ledger) + self.ledger = MainNetLedger(db=':memory:') + return self.ledger.db.start() def estimates(self, *args): txos = args if isinstance(args[0], Output) else args[0] - return [txo.get_estimator(self.coin) for txo in txos] + return [txo.get_estimator(self.ledger) for txo in txos] class TestCoinSelectionTests(BaseSelectionTestCase): @@ -33,7 +33,7 @@ class TestCoinSelectionTests(BaseSelectionTestCase): self.assertIsNone(CoinSelector([], 0, 0).select()) def test_skip_binary_search_if_total_not_enough(self): - fee = utxo(CENT).get_estimator(self.coin).fee + fee = utxo(CENT).get_estimator(self.ledger).fee big_pool = self.estimates(utxo(CENT+fee) for _ in range(100)) selector = CoinSelector(big_pool, 101 * CENT, 0) self.assertIsNone(selector.select()) diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index e69de29bb..d1aaec30d 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -0,0 +1,15 @@ +from twisted.trial import unittest +from twisted.internet import defer + +from torba.basedatabase import BaseSQLiteWalletStorage + + +class TestDatabase(unittest.TestCase): + + def setUp(self): + self.db = BaseSQLiteWalletStorage(':memory:') + return self.db.start() + + @defer.inlineCallbacks + def test_empty_db(self): + result = yield self.db. diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index bf34afc20..319658714 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -1,10 +1,10 @@ from binascii import hexlify, unhexlify from twisted.trial import unittest -from torba.account import Account -from torba.coin.bitcoinsegwit import BTC, Transaction, Output, Input +from torba.basetransaction import BaseTransaction, BaseInput, BaseOutput +from torba.coin.bitcoinsegwit import MainNetLedger from torba.constants import CENT, COIN -from torba.basemanager import WalletManager +from torba.manager import WalletManager from torba.wallet import Wallet @@ -14,34 +14,33 @@ FEE_PER_CHAR = 200000 def get_output(amount=CENT, pubkey_hash=NULL_HASH): - return Transaction() \ - .add_outputs([Output.pay_pubkey_hash(amount, pubkey_hash)]) \ + return BaseTransaction() \ + .add_outputs([BaseTransaction.output_class.pay_pubkey_hash(amount, pubkey_hash)]) \ .outputs[0] def get_input(): - return Input.spend(get_output()) + return BaseInput.spend(get_output()) def get_transaction(txo=None): - return Transaction() \ + return BaseTransaction() \ .add_inputs([get_input()]) \ - .add_outputs([txo or Output.pay_pubkey_hash(CENT, NULL_HASH)]) + .add_outputs([txo or BaseOutput.pay_pubkey_hash(CENT, NULL_HASH)]) -def get_wallet_and_coin(): - ledger = WalletManager().get_or_create_ledger(BTC.get_id()) - coin = BTC(ledger) - return Wallet('Main', [coin], [Account.generate(coin, u'torba')]), coin +def get_wallet_and_ledger(): + ledger = WalletManager().get_or_create_ledger(MainNetLedger.get_id()) + return Wallet('Main', [ledger], [ledger.account_class.generate(ledger, u'torba')]), ledger class TestSizeAndFeeEstimation(unittest.TestCase): def setUp(self): - self.wallet, self.coin = get_wallet_and_coin() + self.wallet, self.ledger = get_wallet_and_ledger() def io_fee(self, io): - return self.coin.get_input_output_fee(io) + return self.ledger.get_input_output_fee(io) def test_output_size_and_fee(self): txo = get_output() @@ -58,7 +57,7 @@ class TestSizeAndFeeEstimation(unittest.TestCase): base_size = tx.size - 1 - tx.inputs[0].size self.assertEqual(tx.size, 204) self.assertEqual(tx.base_size, base_size) - self.assertEqual(self.coin.get_transaction_base_fee(tx), FEE_PER_BYTE * base_size) + self.assertEqual(self.ledger.get_transaction_base_fee(tx), FEE_PER_BYTE * base_size) class TestTransactionSerialization(unittest.TestCase): @@ -71,20 +70,20 @@ class TestTransactionSerialization(unittest.TestCase): '000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4c' 'ef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000' ) - tx = Transaction(raw) + tx = BaseTransaction(raw) self.assertEqual(tx.version, 1) self.assertEqual(tx.locktime, 0) self.assertEqual(len(tx.inputs), 1) self.assertEqual(len(tx.outputs), 1) - coinbase = tx.inputs[0] - self.assertEqual(coinbase.output_txid, NULL_HASH) - self.assertEqual(coinbase.output_index, 0xFFFFFFFF) - self.assertEqual(coinbase.sequence, 4294967295) - self.assertTrue(coinbase.is_coinbase) - self.assertEqual(coinbase.script, None) + ledgerbase = tx.inputs[0] + self.assertEqual(ledgerbase.output_txid, NULL_HASH) + self.assertEqual(ledgerbase.output_index, 0xFFFFFFFF) + self.assertEqual(ledgerbase.sequence, 4294967295) + self.assertTrue(ledgerbase.is_ledgerbase) + self.assertEqual(ledgerbase.script, None) self.assertEqual( - coinbase.coinbase[8:], + ledgerbase.ledgerbase[8:], b'The Times 03/Jan/2009 Chancellor on brink of second bailout for banks' ) @@ -98,7 +97,7 @@ class TestTransactionSerialization(unittest.TestCase): tx._reset() self.assertEqual(tx.raw, raw) - def test_coinbase_transaction(self): + def test_ledgerbase_transaction(self): raw = unhexlify( '01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4e03' '1f5a070473319e592f4254432e434f4d2f4e59412ffabe6d6dcceb2a9d0444c51cabc4ee97a1a000036ca0' @@ -106,20 +105,20 @@ class TestTransactionSerialization(unittest.TestCase): '0000000017a914e083685a1097ce1ea9e91987ab9e94eae33d8a13870000000000000000266a24aa21a9ed' 'e6c99265a6b9e1d36c962fda0516b35709c49dc3b8176fa7e5d5f1f6197884b400000000' ) - tx = Transaction(raw) + tx = BaseTransaction(raw) self.assertEqual(tx.version, 1) self.assertEqual(tx.locktime, 0) self.assertEqual(len(tx.inputs), 1) self.assertEqual(len(tx.outputs), 2) - coinbase = tx.inputs[0] - self.assertEqual(coinbase.output_txid, NULL_HASH) - self.assertEqual(coinbase.output_index, 0xFFFFFFFF) - self.assertEqual(coinbase.sequence, 4294967295) - self.assertTrue(coinbase.is_coinbase) - self.assertEqual(coinbase.script, None) + ledgerbase = tx.inputs[0] + self.assertEqual(ledgerbase.output_txid, NULL_HASH) + self.assertEqual(ledgerbase.output_index, 0xFFFFFFFF) + self.assertEqual(ledgerbase.sequence, 4294967295) + self.assertTrue(ledgerbase.is_ledgerbase) + self.assertEqual(ledgerbase.script, None) self.assertEqual( - coinbase.coinbase[9:22], + ledgerbase.ledgerbase[9:22], b'/BTC.COM/NYA/' ) @@ -151,17 +150,17 @@ class TestTransactionSigning(unittest.TestCase): def test_sign(self): ledger = WalletManager().get_or_create_ledger(BTC.get_id()) - coin = BTC(ledger) - wallet = Wallet('Main', [coin], [Account.from_seed( - coin, u'carbon smart garage balance margin twelve chest sword toast envelope bottom stom' + ledger = BTC(ledger) + wallet = Wallet('Main', [ledger], [Account.from_seed( + ledger, u'carbon smart garage balance margin twelve chest sword toast envelope bottom stom' u'ach absent', u'torba' )]) account = wallet.default_account address1 = account.receiving_keys.generate_next_address() address2 = account.receiving_keys.generate_next_address() - pubkey_hash1 = account.coin.address_to_hash160(address1) - pubkey_hash2 = account.coin.address_to_hash160(address2) + pubkey_hash1 = account.ledger.address_to_hash160(address1) + pubkey_hash2 = account.ledger.address_to_hash160(address2) tx = Transaction() \ .add_inputs([Input.spend(get_output(2*COIN, pubkey_hash1))]) \ diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index 52e1240dd..63314303e 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -1,7 +1,7 @@ from twisted.trial import unittest from torba.coin.bitcoinsegwit import BTC -from torba.basemanager import WalletManager +from torba.manager import WalletManager from torba.wallet import Account, Wallet, WalletStorage from .ftc import FTC diff --git a/torba/account.py b/torba/account.py deleted file mode 100644 index acc518b5c..000000000 --- a/torba/account.py +++ /dev/null @@ -1,191 +0,0 @@ -import itertools -from typing import Dict, Generator -from binascii import hexlify, unhexlify -from twisted.internet import defer - -from torba.basecoin import BaseCoin -from torba.mnemonic import Mnemonic -from torba.bip32 import PrivateKey, PubKey, from_extended_key_string -from torba.hash import double_sha256, aes_encrypt, aes_decrypt - - -class KeyChain: - - def __init__(self, parent_key, child_keys, gap): - self.coin = parent_key.coin - self.parent_key = parent_key # type: PubKey - self.child_keys = child_keys - self.minimum_gap = gap - self.addresses = [ - self.coin.public_key_to_address(key) - for key in child_keys - ] - - @defer.inlineCallbacks - def has_gap(self): - if len(self.addresses) < self.minimum_gap: - defer.returnValue(False) - for address in self.addresses[-self.minimum_gap:]: - if (yield self.coin.ledger.is_address_old(address)): - defer.returnValue(False) - defer.returnValue(True) - - def generate_next_address(self): - child_key = self.parent_key.child(len(self.child_keys)) - self.child_keys.append(child_key.pubkey_bytes) - self.addresses.append(child_key.address) - return child_key.address - - @defer.inlineCallbacks - def ensure_enough_addresses(self): - starting_length = len(self.addresses) - while not (yield self.has_gap()): - self.generate_next_address() - defer.returnValue(self.addresses[starting_length:]) - - -class Account: - - def __init__(self, coin, seed, encrypted, private_key, public_key, - receiving_keys=None, receiving_gap=20, - change_keys=None, change_gap=6): - self.coin = coin # type: BaseCoin - self.seed = seed # type: str - self.encrypted = encrypted # type: bool - self.private_key = private_key # type: PrivateKey - self.public_key = public_key # type: PubKey - self.keychains = ( - KeyChain(public_key.child(0), receiving_keys or [], receiving_gap), - KeyChain(public_key.child(1), change_keys or [], change_gap) - ) - self.receiving_keys, self.change_keys = self.keychains - - @classmethod - def generate(cls, coin, password): # type: (BaseCoin, unicode) -> Account - seed = Mnemonic().make_seed() - return cls.from_seed(coin, seed, password) - - @classmethod - def from_seed(cls, coin, seed, password): # type: (BaseCoin, unicode, unicode) -> Account - private_key = cls.get_private_key_from_seed(coin, seed, password) - return cls( - coin=coin, seed=seed, encrypted=False, - private_key=private_key, - public_key=private_key.public_key - ) - - @staticmethod - def get_private_key_from_seed(coin, seed, password): # type: (BaseCoin, unicode, unicode) -> PrivateKey - return PrivateKey.from_seed(coin, Mnemonic.mnemonic_to_seed(seed, password)) - - @classmethod - def from_dict(cls, coin, d): # type: (BaseCoin, Dict) -> Account - if not d['encrypted']: - private_key = from_extended_key_string(coin, d['private_key']) - public_key = private_key.public_key - else: - private_key = d['private_key'] - public_key = from_extended_key_string(coin, d['public_key']) - return cls( - coin=coin, - seed=d['seed'], - encrypted=d['encrypted'], - private_key=private_key, - public_key=public_key, - receiving_keys=[unhexlify(k) for k in d['receiving_keys']], - receiving_gap=d['receiving_gap'], - change_keys=[unhexlify(k) for k in d['change_keys']], - change_gap=d['change_gap'] - ) - - def to_dict(self): - return { - 'coin': self.coin.get_id(), - 'seed': self.seed, - 'encrypted': self.encrypted, - 'private_key': self.private_key if self.encrypted else - self.private_key.extended_key_string().decode(), - 'public_key': self.public_key.extended_key_string().decode(), - 'receiving_keys': [hexlify(k).decode() for k in self.receiving_keys.child_keys], - 'receiving_gap': self.receiving_keys.minimum_gap, - 'change_keys': [hexlify(k).decode() for k in self.change_keys.child_keys], - 'change_gap': self.change_keys.minimum_gap - } - - def decrypt(self, password): - assert self.encrypted, "Key is not encrypted." - secret = double_sha256(password) - self.seed = aes_decrypt(secret, self.seed) - self.private_key = from_extended_key_string(self.coin, aes_decrypt(secret, self.private_key)) - self.encrypted = False - - def encrypt(self, password): - assert not self.encrypted, "Key is already encrypted." - secret = double_sha256(password) - self.seed = aes_encrypt(secret, self.seed) - self.private_key = aes_encrypt(secret, self.private_key.extended_key_string()) - self.encrypted = True - - @property - def addresses(self): - return itertools.chain(self.receiving_keys.addresses, self.change_keys.addresses) - - def get_private_key_for_address(self, address): - assert not self.encrypted, "Cannot get private key on encrypted wallet account." - for a, keychain in enumerate(self.keychains): - for b, match in enumerate(keychain.addresses): - if address == match: - return self.private_key.child(a).child(b) - - @defer.inlineCallbacks - def ensure_enough_addresses(self): - addresses = [] - for keychain in self.keychains: - for address in (yield keychain.ensure_enough_addresses()): - addresses.append(address) - defer.returnValue(addresses) - - def get_least_used_receiving_address(self, max_transactions=1000): - return self._get_least_used_address( - self.receiving_keys, - max_transactions - ) - - def get_least_used_change_address(self, max_transactions=100): - return self._get_least_used_address( - self.change_keys, - max_transactions - ) - - def _get_least_used_address(self, keychain, max_transactions): - ledger = self.coin.ledger - address = ledger.get_least_used_address(self, keychain, max_transactions) - if address: - return address - address = keychain.generate_next_address() - ledger.subscribe_history(address) - return address - - @defer.inlineCallbacks - def get_balance(self): - utxos = yield self.coin.ledger.get_unspent_outputs(self) - defer.returnValue(sum(utxo.amount for utxo in utxos)) - - -class AccountsView: - - def __init__(self, accounts): - self._accounts_generator = accounts - - def __iter__(self): # type: () -> Generator[Account] - return self._accounts_generator() - - def addresses(self): - for account in self: - for address in account.addresses: - yield address - - def get_account_for_address(self, address): - for account in self: - if address in account.addresses: - return account \ No newline at end of file diff --git a/torba/baseaccount.py b/torba/baseaccount.py new file mode 100644 index 000000000..8ef24e864 --- /dev/null +++ b/torba/baseaccount.py @@ -0,0 +1,184 @@ +from typing import Dict +from binascii import unhexlify +from twisted.internet import defer + +from torba.mnemonic import Mnemonic +from torba.bip32 import PrivateKey, PubKey, from_extended_key_string +from torba.hash import double_sha256, aes_encrypt, aes_decrypt + + +class KeyChain: + + def __init__(self, account, parent_key, chain_number, minimum_usable_addresses): + self.account = account + self.db = account.ledger.db + self.main_key = parent_key.child(chain_number) # type: PubKey + self.chain_number = chain_number + self.minimum_usable_addresses = minimum_usable_addresses + + def get_keys(self): + return self.db.get_keys(self.account, self.chain_number) + + def get_addresses(self): + return self.db.get_addresses(self.account, self.chain_number) + + @defer.inlineCallbacks + def ensure_enough_useable_addresses(self): + usable_address_count = yield self.db.get_usable_address_count( + self.account, self.chain_number + ) + + if usable_address_count >= self.minimum_usable_addresses: + defer.returnValue([]) + + new_addresses_needed = self.minimum_usable_addresses - usable_address_count + + start = yield self.db.get_last_address_index( + self.account, self.chain_number + ) + end = start + new_addresses_needed + + new_keys = [] + for index in range(start+1, end+1): + new_keys.append((index, self.main_key.child(index))) + + yield self.db.add_keys( + self.account, self.chain_number, new_keys + ) + + defer.returnValue([ + key[1].address for key in new_keys + ]) + + @defer.inlineCallbacks + def has_gap(self): + if len(self.addresses) < self.minimum_gap: + defer.returnValue(False) + for address in self.addresses[-self.minimum_gap:]: + if (yield self.ledger.is_address_old(address)): + defer.returnValue(False) + defer.returnValue(True) + + +class BaseAccount: + + mnemonic_class = Mnemonic + private_key_class = PrivateKey + public_key_class = PubKey + + def __init__(self, ledger, seed, encrypted, private_key, + public_key, receiving_gap=20, change_gap=6): + self.ledger = ledger # type: baseledger.BaseLedger + self.seed = seed # type: str + self.encrypted = encrypted # type: bool + self.private_key = private_key # type: PrivateKey + self.public_key = public_key # type: PubKey + self.receiving, self.change = self.keychains = ( + KeyChain(self, public_key, 0, receiving_gap), + KeyChain(self, public_key, 1, change_gap) + ) + ledger.account_created(self) + + @classmethod + def generate(cls, ledger, password): # type: (baseledger.BaseLedger, str) -> BaseAccount + seed = cls.mnemonic_class().make_seed() + return cls.from_seed(ledger, seed, password) + + @classmethod + def from_seed(cls, ledger, seed, password): + # type: (baseledger.BaseLedger, str, str) -> BaseAccount + private_key = cls.get_private_key_from_seed(ledger, seed, password) + return cls( + ledger=ledger, seed=seed, encrypted=False, + private_key=private_key, + public_key=private_key.public_key + ) + + @classmethod + def get_private_key_from_seed(cls, ledger, seed, password): + # type: (baseledger.BaseLedger, str, str) -> PrivateKey + return cls.private_key_class.from_seed( + ledger, cls.mnemonic_class.mnemonic_to_seed(seed, password) + ) + + @classmethod + def from_dict(cls, ledger, d): # type: (baseledger.BaseLedger, Dict) -> BaseAccount + if not d['encrypted']: + private_key = from_extended_key_string(ledger, d['private_key']) + public_key = private_key.public_key + else: + private_key = d['private_key'] + public_key = from_extended_key_string(ledger, d['public_key']) + return cls( + ledger=ledger, + seed=d['seed'], + encrypted=d['encrypted'], + private_key=private_key, + public_key=public_key, + receiving_gap=d['receiving_gap'], + change_gap=d['change_gap'] + ) + + def to_dict(self): + return { + 'ledger': self.ledger.get_id(), + 'seed': self.seed, + 'encrypted': self.encrypted, + 'private_key': self.private_key if self.encrypted else + self.private_key.extended_key_string(), + 'public_key': self.public_key.extended_key_string(), + 'receiving_gap': self.receiving.minimum_usable_addresses, + 'change_gap': self.change.minimum_usable_addresses, + } + + def decrypt(self, password): + assert self.encrypted, "Key is not encrypted." + secret = double_sha256(password) + self.seed = aes_decrypt(secret, self.seed) + self.private_key = from_extended_key_string(self.ledger, aes_decrypt(secret, self.private_key)) + self.encrypted = False + + def encrypt(self, password): + assert not self.encrypted, "Key is already encrypted." + secret = double_sha256(password) + self.seed = aes_encrypt(secret, self.seed) + self.private_key = aes_encrypt(secret, self.private_key.extended_key_string()) + self.encrypted = True + + @defer.inlineCallbacks + def ensure_enough_useable_addresses(self): + addresses = [] + for keychain in self.keychains: + new_addresses = yield keychain.ensure_enough_useable_addresses() + addresses.extend(new_addresses) + defer.returnValue(addresses) + + def get_private_key(self, chain, index): + assert not self.encrypted, "Cannot get private key on encrypted wallet account." + return self.private_key.child(chain).child(index) + + def get_least_used_receiving_address(self, max_transactions=1000): + return self._get_least_used_address( + self.receiving_keys, + max_transactions + ) + + def get_least_used_change_address(self, max_transactions=100): + return self._get_least_used_address( + self.change_keys, + max_transactions + ) + + def _get_least_used_address(self, keychain, max_transactions): + ledger = self.ledger + address = ledger.get_least_used_address(self, keychain, max_transactions) + if address: + return address + address = keychain.generate_next_address() + ledger.subscribe_history(address) + return address + + @defer.inlineCallbacks + def get_balance(self): + utxos = yield self.ledger.get_unspent_outputs(self) + defer.returnValue(sum(utxo.amount for utxo in utxos)) diff --git a/torba/basecoin.py b/torba/basecoin.py deleted file mode 100644 index 7b00115cd..000000000 --- a/torba/basecoin.py +++ /dev/null @@ -1,70 +0,0 @@ -import six -from typing import Dict, Type -from torba.hash import hash160, double_sha256, Base58 - - -class CoinRegistry(type): - coins = {} # type: Dict[str, Type[BaseCoin]] - - def __new__(mcs, name, bases, attrs): - cls = super(CoinRegistry, mcs).__new__(mcs, name, bases, attrs) # type: Type[BaseCoin] - if not (name == 'BaseCoin' and not bases): - coin_id = cls.get_id() - assert coin_id not in mcs.coins, 'Coin with id "{}" already registered.'.format(coin_id) - mcs.coins[coin_id] = cls - assert cls.ledger_class.coin_class is None, ( - "Ledger ({}) which this coin ({}) references is already referenced by another " - "coin ({}). One to one relationship between a coin and a ledger is strictly and " - "automatically enforced. Make sure that coin_class=None in the ledger and that " - "another Coin isn't already referencing this Ledger." - ).format(cls.ledger_class.__name__, name, cls.ledger_class.coin_class.__name__) - # create back reference from ledger to the coin - cls.ledger_class.coin_class = cls - return cls - - @classmethod - def get_coin_class(mcs, coin_id): # type: (str) -> Type[BaseCoin] - return mcs.coins[coin_id] - - -class BaseCoin(six.with_metaclass(CoinRegistry)): - - name = None - symbol = None - network = None - - ledger_class = None # type: Type[BaseLedger] - transaction_class = None # type: Type[BaseTransaction] - - secret_prefix = None - pubkey_address_prefix = None - script_address_prefix = None - extended_public_key_prefix = None - extended_private_key_prefix = None - - def __init__(self, ledger, fee_per_byte): - self.ledger = ledger - - @classmethod - def get_id(cls): - return '{}_{}'.format(cls.symbol.lower(), cls.network.lower()) - - def to_dict(self): - return {} - - def hash160_to_address(self, h160): - raw_address = self.pubkey_address_prefix + h160 - return Base58.encode(bytearray(raw_address + double_sha256(raw_address)[0:4])) - - @staticmethod - def address_to_hash160(address): - bytes = Base58.decode(address) - prefix, pubkey_bytes, addr_checksum = bytes[0], bytes[1:21], bytes[21:] - return pubkey_bytes - - def public_key_to_address(self, public_key): - return self.hash160_to_address(hash160(public_key)) - - @staticmethod - def private_key_to_wif(private_key): - return b'\x1c' + private_key + b'\x01' diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 1b8082690..c06995d88 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -1,5 +1,4 @@ import logging -import os import sqlite3 from twisted.internet import defer from twisted.enterprise import adbapi @@ -7,50 +6,12 @@ from twisted.enterprise import adbapi log = logging.getLogger(__name__) -class BaseSQLiteWalletStorage(object): +class SQLiteMixin(object): - CREATE_TX_TABLE = """ - create table if not exists tx ( - txid blob primary key, - raw blob not null, - height integer not null, - is_confirmed boolean not null, - is_verified boolean not null - ); - create table if not exists address_status ( - address blob not null, - status text not null - ); - """ + CREATE_TABLES_QUERY = None - CREATE_TXO_TABLE = """ - create table if not exists txo ( - txoid integer primary key, - account blob not null, - address blob not null, - txid blob references tx, - pos integer not null, - amount integer not null, - script blob not null - ); - """ - - CREATE_TXI_TABLE = """ - create table if not exists txi ( - account blob not null, - txid blob references tx, - txoid integer references txo - ); - """ - - CREATE_TABLES_QUERY = ( - CREATE_TX_TABLE + - CREATE_TXO_TABLE + - CREATE_TXI_TABLE - ) - - def __init__(self, ledger): - self._db_path = os.path.join(ledger.path, "blockchain.db") + def __init__(self, path): + self._db_path = path self.db = None def start(self): @@ -66,62 +27,160 @@ class BaseSQLiteWalletStorage(object): self.db.close() return defer.succeed(True) - @defer.inlineCallbacks - def run_and_return_one_or_none(self, query, *args): - result = yield self.db.runQuery(query, args) - if result: - defer.returnValue(result[0][0]) - else: - defer.returnValue(None) + def _debug_sql(self, sql): + """ For use during debugging to execute arbitrary SQL queries without waiting on reactor. """ + conn = self.db.connectionFactory(self.db) + trans = self.db.transactionFactory(self, conn) + return trans.execute(sql).fetchall() + + def _insert_sql(self, table, data): + columns, values = [], [] + for column, value in data.items(): + columns.append(column) + values.append(value) + sql = "REPLACE INTO %s (%s) VALUES (%s)".format( + table, ', '.join(columns), ', '.join(['?'] * len(values)) + ) + return sql, values @defer.inlineCallbacks - def run_and_return_list(self, query, *args): - result = yield self.db.runQuery(query, args) + def query_one_value_list(self, query, params): + result = yield self.db.runQuery(query, params) if result: defer.returnValue([i[0] for i in result]) else: defer.returnValue([]) - def run_and_return_id(self, query, *args): - def do_save(t): - t.execute(query, args) - return t.lastrowid - return self.db.runInteraction(do_save) - - def add_transaction(self, tx, height, is_confirmed, is_verified): - return self.run_and_return_id( - "insert into tx values (?, ?, ?, ?, ?)", - sqlite3.Binary(tx.id), - sqlite3.Binary(tx.raw), - height, - is_confirmed, - is_verified - ) + @defer.inlineCallbacks + def query_one_value(self, query, params=None, default=None): + result = yield self.db.runQuery(query, params) + if result: + defer.returnValue(result[0][0]) + else: + defer.returnValue(default) @defer.inlineCallbacks - def has_transaction(self, txid): - result = yield self.db.runQuery( - "select rowid from tx where txid=?", (txid,) - ) - defer.returnValue(bool(result)) + def query_dict_value_list(self, query, fields, params=None): + result = yield self.db.runQuery(query.format(', '.join(fields)), params) + if result: + defer.returnValue([dict(zip(fields, r)) for r in result]) + else: + defer.returnValue([]) - def add_tx_output(self, account, txo): - return self.db.runOperation( - "insert into txo values (?, ?, ?, ?, ?, ?, ?, ?, ?)", ( - sqlite3.Binary(account.public_key.address), - sqlite3.Binary(txo.script.values['pubkey_hash']), - sqlite3.Binary(txo.txid), - txo.index, - txo.amount, - sqlite3.Binary(txo.script.source), - txo.script.is_claim_name, - txo.script.is_support_claim, - txo.script.is_update_claim - ) + @defer.inlineCallbacks + def query_dict_value(self, query, fields, params=None, default=None): + result = yield self.query_dict_value_list(query, fields, params) + if result: + defer.returnValue(result[0]) + else: + defer.returnValue(default) + + def query_count(self, sql, params): + return self.query_one_value( + "SELECT count(*) FROM ({})".format(sql), params ) - def add_tx_input(self, account, txi): - def _ops(t): + def insert_and_return_id(self, table, data): + def do_insert(t): + t.execute(*self._insert_sql(table, data)) + return t.lastrowid + return self.db.runInteraction(do_insert) + + +class BaseDatabase(SQLiteMixin): + + CREATE_TX_TABLE = """ + create table if not exists tx ( + txid blob primary key, + raw blob not null, + height integer not null, + is_confirmed boolean not null, + is_verified boolean not null + ); + """ + + CREATE_PUBKEY_ADDRESS_TABLE = """ + create table if not exists pubkey_address ( + address blob primary key, + account blob not null, + chain integer not null, + position integer not null, + pubkey blob not null, + history text, + used_times integer default 0 + ); + """ + + CREATE_TXO_TABLE = """ + create table if not exists txo ( + txoid integer primary key, + txid blob references tx, + address blob references pubkey_address, + position integer not null, + amount integer not null, + script blob not null + ); + """ + + CREATE_TXI_TABLE = """ + create table if not exists txi ( + txid blob references tx, + address blob references pubkey_address, + txoid integer references txo + ); + """ + + CREATE_TABLES_QUERY = ( + CREATE_TX_TABLE + + CREATE_PUBKEY_ADDRESS_TABLE + + CREATE_TXO_TABLE + + CREATE_TXI_TABLE + ) + + def get_missing_transactions(self, address, txids): + def _steps(t): + missing = [] + chunk_size = 100 + for i in range(0, len(txids), chunk_size): + chunk = txids[i:i + chunk_size] + t.execute( + "SELECT 1 FROM tx WHERE txid=?", + (sqlite3.Binary(txid) for txid in chunk) + ) + if not t.execute("SELECT 1 FROM tx WHERE txid=?", (sqlite3.Binary(tx.id),)).fetchone(): + t.execute(*self._insert_sql('tx', { + 'txid': sqlite3.Binary(tx.id), + 'raw': sqlite3.Binary(tx.raw), + 'height': height, + 'is_confirmed': is_confirmed, + 'is_verified': is_verified + })) + return self.db.runInteraction(_steps) + + def add_transaction(self, address, tx, height, is_confirmed, is_verified): + def _steps(t): + if not t.execute("SELECT 1 FROM tx WHERE txid=?", (sqlite3.Binary(tx.id),)).fetchone(): + t.execute(*self._insert_sql('tx', { + 'txid': sqlite3.Binary(tx.id), + 'raw': sqlite3.Binary(tx.raw), + 'height': height, + 'is_confirmed': is_confirmed, + 'is_verified': is_verified + })) + t.execute(*self._insert_sql( + "insert into txo values (?, ?, ?, ?, ?, ?, ?, ?, ?)", ( + sqlite3.Binary(account.public_key.address), + sqlite3.Binary(txo.script.values['pubkey_hash']), + sqlite3.Binary(txo.txid), + txo.index, + txo.amount, + sqlite3.Binary(txo.script.source), + txo.script.is_claim_name, + txo.script.is_support_claim, + txo.script.is_update_claim + ) + + )) txoid = t.execute( "select rowid from txo where txid=? and pos=?", ( sqlite3.Binary(txi.output_txid), txi.output_index @@ -134,7 +193,15 @@ class BaseSQLiteWalletStorage(object): txoid ) ) - return self.db.runInteraction(_ops) + + return self.db.runInteraction(_steps) + + @defer.inlineCallbacks + def has_transaction(self, txid): + result = yield self.db.runQuery( + "select rowid from tx where txid=?", (txid,) + ) + defer.returnValue(bool(result)) @defer.inlineCallbacks def get_balance_for_account(self, account): @@ -147,41 +214,6 @@ class BaseSQLiteWalletStorage(object): else: defer.returnValue(0) - def get_used_addresses(self, account): - return self.db.runQuery( - """ - SELECT - txios.address, - sum(txios.used_count) as total - FROM - (SELECT address, count(*) as used_count FROM txo - WHERE account=:account GROUP BY address - UNION - SELECT address, count(*) as used_count FROM txi NATURAL JOIN txo - WHERE account=:account GROUP BY address) AS txios - GROUP BY txios.address - ORDER BY total - """, {'account': sqlite3.Binary(account.public_key.address)} - ) - - @defer.inlineCallbacks - def get_earliest_block_height_for_address(self, address): - result = yield self.db.runQuery( - """ - SELECT - height - FROM - (SELECT DISTINCT height FROM txi NATURAL JOIN txo NATURAL JOIN tx WHERE address=:address - UNION - SELECT DISTINCT height FROM txo NATURAL JOIN tx WHERE address=:address) AS txios - ORDER BY height LIMIT 1 - """, {'address': sqlite3.Binary(address)} - ) - if result: - defer.returnValue(result[0][0]) - else: - defer.returnValue(None) - @defer.inlineCallbacks def get_utxos(self, account, output_class): utxos = yield self.db.runQuery( @@ -203,17 +235,79 @@ class BaseSQLiteWalletStorage(object): ) for values in utxos ]) - @defer.inlineCallbacks - def get_address_status(self, address): - result = yield self.db.runQuery( - "select status from address_status where address=?", (address,) + def add_keys(self, account, chain, keys): + sql = ( + "insert into pubkey_address " + "(address, account, chain, position, pubkey) " + "values " + ) + ', '.join(['(?, ?, ?, ?, ?)'] * len(keys)) + values = [] + for position, pubkey in keys: + values.append(sqlite3.Binary(pubkey.address)) + values.append(sqlite3.Binary(account.public_key.address)) + values.append(chain) + values.append(position) + values.append(sqlite3.Binary(pubkey.pubkey_bytes)) + return self.db.runOperation(sql, values) + + def get_keys(self, account, chain): + return self.query_one_value_list( + "SELECT pubkey FROM pubkey_address WHERE account = ? AND chain = ?", + (sqlite3.Binary(account.public_key.address), chain) + ) + + def get_address_details(self, address): + return self.query_dict_value( + "SELECT {} FROM pubkey_address WHERE address = ?", + ('account', 'chain', 'position'), (sqlite3.Binary(address),) + ) + + def get_addresses(self, account, chain): + return self.query_one_value_list( + "SELECT address FROM pubkey_address WHERE account = ? AND chain = ?", + (sqlite3.Binary(account.public_key.address), chain) + ) + + def get_last_address_index(self, account, chain): + return self.query_one_value( + """ + SELECT position FROM pubkey_address + WHERE account = ? AND chain = ? + ORDER BY position DESC LIMIT 1""", + (sqlite3.Binary(account.public_key.address), chain), + default=0 + ) + + def _usable_address_sql(self, account, chain, exclude_used_times): + return """ + SELECT address FROM pubkey_address + WHERE + account = :account AND + chain = :chain AND + used_times <= :exclude_used_times + """, { + 'account': sqlite3.Binary(account.public_key.address), + 'chain': chain, + 'exclude_used_times': exclude_used_times + } + + def get_usable_addresses(self, account, chain, exclude_used_times=2): + return self.query_one_value_list(*self._usable_address_sql( + account, chain, exclude_used_times + )) + + def get_usable_address_count(self, account, chain, exclude_used_times=2): + return self.query_count(*self._usable_address_sql( + account, chain, exclude_used_times + )) + + def get_address_history(self, address): + return self.query_one_value( + "SELECT history FROM pubkey_address WHERE address = ?", (sqlite3.Binary(address),) ) - if result: - defer.returnValue(result[0][0]) - else: - defer.returnValue(None) def set_address_status(self, address, status): return self.db.runOperation( "replace into address_status (address, status) values (?, ?)", (address,status) ) + diff --git a/torba/baseheader.py b/torba/baseheader.py new file mode 100644 index 000000000..506cab22c --- /dev/null +++ b/torba/baseheader.py @@ -0,0 +1,243 @@ +import os +import struct +from binascii import unhexlify + +from twisted.internet import threads, defer + +import torba +from torba.stream import StreamController, execute_serially +from torba.util import int_to_hex, rev_hex, hash_encode +from torba.hash import double_sha256, pow_hash + + +class BaseHeaders: + + header_size = 80 + verify_bits_to_target = True + + def __init__(self, ledger): # type: (baseledger.BaseLedger) -> BaseHeaders + self.ledger = ledger + self._size = None + self._on_change_controller = StreamController() + self.on_changed = self._on_change_controller.stream + + @property + def path(self): + return os.path.join(self.ledger.path, 'headers') + + def touch(self): + if not os.path.exists(self.path): + with open(self.path, 'wb'): + pass + + @property + def height(self): + return len(self) - 1 + + def sync_read_length(self): + return os.path.getsize(self.path) // self.header_size + + def sync_read_header(self, height): + if 0 <= height < len(self): + with open(self.path, 'rb') as f: + f.seek(height * self.header_size) + return f.read(self.header_size) + + def __len__(self): + if self._size is None: + self._size = self.sync_read_length() + return self._size + + def __getitem__(self, height): + assert not isinstance(height, slice), \ + "Slicing of header chain has not been implemented yet." + header = self.sync_read_header(height) + return self._deserialize(height, header) + + @execute_serially + @defer.inlineCallbacks + def connect(self, start, headers): + yield threads.deferToThread(self._sync_connect, start, headers) + + def _sync_connect(self, start, headers): + previous_header = None + for header in self._iterate_headers(start, headers): + height = header['block_height'] + if previous_header is None and height > 0: + previous_header = self[height-1] + self._verify_header(height, header, previous_header) + previous_header = header + + with open(self.path, 'r+b') as f: + f.seek(start * self.header_size) + f.write(headers) + f.truncate() + + _old_size = self._size + self._size = self.sync_read_length() + change = self._size - _old_size + #log.info('saved {} header blocks'.format(change)) + self._on_change_controller.add(change) + + def _iterate_headers(self, height, headers): + assert len(headers) % self.header_size == 0 + for idx in range(len(headers) // self.header_size): + start, end = idx * self.header_size, (idx + 1) * self.header_size + header = headers[start:end] + yield self._deserialize(height+idx, header) + + def _verify_header(self, height, header, previous_header): + previous_hash = self._hash_header(previous_header) + assert previous_hash == header['prev_block_hash'], \ + "prev hash mismatch: {} vs {}".format(previous_hash, header['prev_block_hash']) + + bits, target = self._calculate_next_work_required(height, previous_header, header) + assert bits == header['bits'], \ + "bits mismatch: {} vs {} (hash: {})".format( + bits, header['bits'], self._hash_header(header)) + + # TODO: FIX ME!!! + #_pow_hash = self._pow_hash_header(header) + #assert int(b'0x' + _pow_hash, 16) <= target, \ + # "insufficient proof of work: {} vs target {}".format( + # int(b'0x' + _pow_hash, 16), target) + + @staticmethod + def _serialize(header): + return b''.join([ + int_to_hex(header['version'], 4), + rev_hex(header['prev_block_hash']), + rev_hex(header['merkle_root']), + int_to_hex(int(header['timestamp']), 4), + int_to_hex(int(header['bits']), 4), + int_to_hex(int(header['nonce']), 4) + ]) + + @staticmethod + def _deserialize(height, header): + version, = struct.unpack('> 24) & 0xff + assert 0x03 <= bitsN <= 0x1d, \ + "First part of bits should be in [0x03, 0x1d], but it was {}".format(hex(bitsN)) + bitsBase = bits & 0xffffff + assert 0x8000 <= bitsBase <= 0x7fffff, \ + "Second part of bits should be in [0x8000, 0x7fffff] but it was {}".format(bitsBase) + + # new target + retargetTimespan = self.ledger.target_timespan + nActualTimespan = last['timestamp'] - first['timestamp'] + + nModulatedTimespan = retargetTimespan + (nActualTimespan - retargetTimespan) // 8 + + nMinTimespan = retargetTimespan - (retargetTimespan // 8) + nMaxTimespan = retargetTimespan + (retargetTimespan // 2) + + # Limit adjustment step + if nModulatedTimespan < nMinTimespan: + nModulatedTimespan = nMinTimespan + elif nModulatedTimespan > nMaxTimespan: + nModulatedTimespan = nMaxTimespan + + # Retarget + bnPowLimit = _ArithUint256(self.ledger.max_target) + bnNew = _ArithUint256.SetCompact(last['bits']) + bnNew *= nModulatedTimespan + bnNew //= nModulatedTimespan + if bnNew > bnPowLimit: + bnNew = bnPowLimit + + return bnNew.GetCompact(), bnNew._value + + +class _ArithUint256: + """ See: lbrycrd/src/arith_uint256.cpp """ + + def __init__(self, value): + self._value = value + + def __str__(self): + return hex(self._value) + + @staticmethod + def fromCompact(nCompact): + """Convert a compact representation into its value""" + nSize = nCompact >> 24 + # the lower 23 bits + nWord = nCompact & 0x007fffff + if nSize <= 3: + return nWord >> 8 * (3 - nSize) + else: + return nWord << 8 * (nSize - 3) + + @classmethod + def SetCompact(cls, nCompact): + return cls(cls.fromCompact(nCompact)) + + def bits(self): + """Returns the position of the highest bit set plus one.""" + bn = bin(self._value)[2:] + for i, d in enumerate(bn): + if d: + return (len(bn) - i) + 1 + return 0 + + def GetLow64(self): + return self._value & 0xffffffffffffffff + + def GetCompact(self): + """Convert a value into its compact representation""" + nSize = (self.bits() + 7) // 8 + nCompact = 0 + if nSize <= 3: + nCompact = self.GetLow64() << 8 * (3 - nSize) + else: + bn = _ArithUint256(self._value >> 8 * (nSize - 3)) + nCompact = bn.GetLow64() + # The 0x00800000 bit denotes the sign. + # Thus, if it is already set, divide the mantissa by 256 and increase the exponent. + if nCompact & 0x00800000: + nCompact >>= 8 + nSize += 1 + assert (nCompact & ~0x007fffff) == 0 + assert nSize < 256 + nCompact |= nSize << 24 + return nCompact + + def __mul__(self, x): + # Take the mod because we are limited to an unsigned 256 bit number + return _ArithUint256((self._value * x) % 2 ** 256) + + def __ifloordiv__(self, x): + self._value = (self._value // x) + return self + + def __gt__(self, x): + return self._value > x._value diff --git a/torba/baseledger.py b/torba/baseledger.py index 9f913df38..dcad300db 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -1,71 +1,100 @@ import os +import six import hashlib -import struct from binascii import hexlify, unhexlify -from typing import List, Dict, Type +from typing import Dict, Type from operator import itemgetter -from twisted.internet import threads, defer, task, reactor +from twisted.internet import defer -from torba import basetransaction, basedatabase -from torba.account import Account, AccountsView -from torba.basecoin import BaseCoin -from torba.basenetwork import BaseNetwork +from torba import baseaccount +from torba import basedatabase +from torba import baseheader +from torba import basenetwork +from torba import basetransaction from torba.stream import StreamController, execute_serially -from torba.util import int_to_hex, rev_hex, hash_encode -from torba.hash import double_sha256, pow_hash +from torba.hash import hash160, double_sha256, Base58 -class Address: +class LedgerRegistry(type): + ledgers = {} # type: Dict[str, Type[BaseLedger]] - def __init__(self, pubkey_hash): - self.pubkey_hash = pubkey_hash - self.transactions = [] # type: List[BaseTransaction] + def __new__(mcs, name, bases, attrs): + cls = super(LedgerRegistry, mcs).__new__(mcs, name, bases, attrs) # type: Type[BaseLedger] + if not (name == 'BaseLedger' and not bases): + ledger_id = cls.get_id() + assert ledger_id not in mcs.ledgers,\ + 'Ledger with id "{}" already registered.'.format(ledger_id) + mcs.ledgers[ledger_id] = cls + return cls - def __iter__(self): - return iter(self.transactions) - - def __len__(self): - return len(self.transactions) - - def add_transaction(self, transaction): - if transaction not in self.transactions: - self.transactions.append(transaction) + @classmethod + def get_ledger_class(mcs, ledger_id): # type: (str) -> Type[BaseLedger] + return mcs.ledgers[ledger_id] -class BaseLedger(object): +class BaseLedger(six.with_metaclass(LedgerRegistry)): - # coin_class is automatically set by BaseCoin metaclass - # when it creates the Coin classes, there is a 1..1 relationship - # between a coin and a ledger (at the class level) but a 1..* relationship - # at instance level. Only one Ledger instance should exist per coin class, - # but many coin instances can exist linking back to the single Ledger instance. - coin_class = None # type: Type[BaseCoin] - network_class = None # type: Type[BaseNetwork] - headers_class = None # type: Type[BaseHeaders] - database_class = None # type: Type[basedatabase.BaseSQLiteWalletStorage] + name = None + symbol = None + network_name = None + + account_class = baseaccount.BaseAccount + database_class = basedatabase.BaseDatabase + headers_class = baseheader.BaseHeaders + network_class = basenetwork.BaseNetwork + transaction_class = basetransaction.BaseTransaction + + secret_prefix = None + pubkey_address_prefix = None + script_address_prefix = None + extended_public_key_prefix = None + extended_private_key_prefix = None default_fee_per_byte = 10 - def __init__(self, accounts, config=None, db=None, network=None, - fee_per_byte=default_fee_per_byte): - self.accounts = accounts # type: AccountsView + def __init__(self, config=None, db=None, network=None): self.config = config or {} - self.db = db or self.database_class(self) # type: basedatabase.BaseSQLiteWalletStorage + self.db = self.database_class( + db or os.path.join(self.path, "blockchain.db") + ) # type: basedatabase.BaseSQLiteWalletStorage self.network = network or self.network_class(self) self.network.on_header.listen(self.process_header) self.network.on_status.listen(self.process_status) + self.accounts = set() self.headers = self.headers_class(self) - self.fee_per_byte = fee_per_byte + self.fee_per_byte = self.config.get('fee_per_byte', self.default_fee_per_byte) self._on_transaction_controller = StreamController() self.on_transaction = self._on_transaction_controller.stream + @classmethod + def get_id(cls): + return '{}_{}'.format(cls.symbol.lower(), cls.network_name.lower()) + + def hash160_to_address(self, h160): + raw_address = self.pubkey_address_prefix + h160 + return Base58.encode(bytearray(raw_address + double_sha256(raw_address)[0:4])) + + def account_created(self, account): + self.accounts.add(account) + + @staticmethod + def address_to_hash160(address): + bytes = Base58.decode(address) + prefix, pubkey_bytes, addr_checksum = bytes[0], bytes[1:21], bytes[21:] + return pubkey_bytes + + def public_key_to_address(self, public_key): + return self.hash160_to_address(hash160(public_key)) + + @staticmethod + def private_key_to_wif(private_key): + return b'\x1c' + private_key + b'\x01' + @property def path(self): - return os.path.join( - self.config['wallet_path'], self.coin_class.get_id() - ) + return os.path.join(self.config['path'], self.get_id()) def get_input_output_fee(self, io): """ Fee based on size of the input / output. """ @@ -75,21 +104,8 @@ class BaseLedger(object): """ Fee for the transaction header and all outputs; without inputs. """ return self.fee_per_byte * tx.base_size - @property - def transaction_class(self): - return self.coin_class.transaction_class - - @classmethod - def from_json(cls, json_dict): - return cls(json_dict) - - @defer.inlineCallbacks - def is_address_old(self, address, age_limit=2): - height = yield self.db.get_earliest_block_height_for_address(address) - if height is None: - return False - age = self.headers.height - height + 1 - return age > age_limit + def get_keys(self, account, chain): + return self.db.get_keys(account, chain) @defer.inlineCallbacks def add_transaction(self, transaction, height): # type: (basetransaction.BaseTransaction, int) -> None @@ -108,6 +124,14 @@ class BaseLedger(object): if used_addresses and used_addresses[0][1] < max_transactions: defer.returnValue(used_addresses[0][0]) + @defer.inlineCallbacks + def get_private_key_for_address(self, address): + match = yield self.db.get_address_details(address) + if match: + for account in self.accounts: + if bytes(match['account']) == account.public_key.address: + defer.returnValue(account.get_private_key(match['chain'], match['position'])) + def get_unspent_outputs(self, account): return self.db.get_utxos(account, self.transaction_class.output_class) @@ -177,8 +201,7 @@ class BaseLedger(object): # need to update anyways. Continue to get history and create more addresses until # all missing addresses are created and history for them is fully restored. yield account.ensure_enough_addresses() - used_addresses = yield self.db.get_used_addresses(account) - addresses = set(account.addresses) - set(map(itemgetter(0), used_addresses)) + addresses = yield account.get_unused_addresses(account) while addresses: yield defer.DeferredList([ self.update_history(a) for a in addresses @@ -203,7 +226,9 @@ class BaseLedger(object): @defer.inlineCallbacks def update_history(self, address, remote_status=None): history = yield self.network.get_history(address) + hashes = list(map(itemgetter('tx_hash'), history)) for hash, height in map(itemgetter('tx_hash', 'height'), history): + if not (yield self.db.has_transaction(hash)): raw = yield self.network.get_transaction(hash) transaction = self.transaction_class(unhexlify(raw)) @@ -229,236 +254,3 @@ class BaseLedger(object): def broadcast(self, tx): return self.network.broadcast(hexlify(tx.raw)) - - -class BaseHeaders: - - header_size = 80 - verify_bits_to_target = True - - def __init__(self, ledger): - self.ledger = ledger - self._size = None - self._on_change_controller = StreamController() - self.on_changed = self._on_change_controller.stream - - @property - def path(self): - return os.path.join(self.ledger.path, 'headers') - - def touch(self): - if not os.path.exists(self.path): - with open(self.path, 'wb'): - pass - - @property - def height(self): - return len(self) - 1 - - def sync_read_length(self): - return os.path.getsize(self.path) // self.header_size - - def sync_read_header(self, height): - if 0 <= height < len(self): - with open(self.path, 'rb') as f: - f.seek(height * self.header_size) - return f.read(self.header_size) - - def __len__(self): - if self._size is None: - self._size = self.sync_read_length() - return self._size - - def __getitem__(self, height): - assert not isinstance(height, slice),\ - "Slicing of header chain has not been implemented yet." - header = self.sync_read_header(height) - return self._deserialize(height, header) - - @execute_serially - @defer.inlineCallbacks - def connect(self, start, headers): - yield threads.deferToThread(self._sync_connect, start, headers) - - def _sync_connect(self, start, headers): - previous_header = None - for header in self._iterate_headers(start, headers): - height = header['block_height'] - if previous_header is None and height > 0: - previous_header = self[height-1] - self._verify_header(height, header, previous_header) - previous_header = header - - with open(self.path, 'r+b') as f: - f.seek(start * self.header_size) - f.write(headers) - f.truncate() - - _old_size = self._size - self._size = self.sync_read_length() - change = self._size - _old_size - #log.info('saved {} header blocks'.format(change)) - self._on_change_controller.add(change) - - def _iterate_headers(self, height, headers): - assert len(headers) % self.header_size == 0 - for idx in range(len(headers) // self.header_size): - start, end = idx * self.header_size, (idx + 1) * self.header_size - header = headers[start:end] - yield self._deserialize(height+idx, header) - - def _verify_header(self, height, header, previous_header): - previous_hash = self._hash_header(previous_header) - assert previous_hash == header['prev_block_hash'], \ - "prev hash mismatch: {} vs {}".format(previous_hash, header['prev_block_hash']) - - bits, target = self._calculate_next_work_required(height, previous_header, header) - assert bits == header['bits'], \ - "bits mismatch: {} vs {} (hash: {})".format( - bits, header['bits'], self._hash_header(header)) - - # TODO: FIX ME!!! - #_pow_hash = self._pow_hash_header(header) - #assert int(b'0x' + _pow_hash, 16) <= target, \ - # "insufficient proof of work: {} vs target {}".format( - # int(b'0x' + _pow_hash, 16), target) - - @staticmethod - def _serialize(header): - return b''.join([ - int_to_hex(header['version'], 4), - rev_hex(header['prev_block_hash']), - rev_hex(header['merkle_root']), - int_to_hex(int(header['timestamp']), 4), - int_to_hex(int(header['bits']), 4), - int_to_hex(int(header['nonce']), 4) - ]) - - @staticmethod - def _deserialize(height, header): - version, = struct.unpack('> 24) & 0xff - assert 0x03 <= bitsN <= 0x1d, \ - "First part of bits should be in [0x03, 0x1d], but it was {}".format(hex(bitsN)) - bitsBase = bits & 0xffffff - assert 0x8000 <= bitsBase <= 0x7fffff, \ - "Second part of bits should be in [0x8000, 0x7fffff] but it was {}".format(bitsBase) - - # new target - retargetTimespan = self.ledger.target_timespan - nActualTimespan = last['timestamp'] - first['timestamp'] - - nModulatedTimespan = retargetTimespan + (nActualTimespan - retargetTimespan) // 8 - - nMinTimespan = retargetTimespan - (retargetTimespan // 8) - nMaxTimespan = retargetTimespan + (retargetTimespan // 2) - - # Limit adjustment step - if nModulatedTimespan < nMinTimespan: - nModulatedTimespan = nMinTimespan - elif nModulatedTimespan > nMaxTimespan: - nModulatedTimespan = nMaxTimespan - - # Retarget - bnPowLimit = _ArithUint256(self.ledger.max_target) - bnNew = _ArithUint256.SetCompact(last['bits']) - bnNew *= nModulatedTimespan - bnNew //= nModulatedTimespan - if bnNew > bnPowLimit: - bnNew = bnPowLimit - - return bnNew.GetCompact(), bnNew._value - - -class _ArithUint256: - """ See: lbrycrd/src/arith_uint256.cpp """ - - def __init__(self, value): - self._value = value - - def __str__(self): - return hex(self._value) - - @staticmethod - def fromCompact(nCompact): - """Convert a compact representation into its value""" - nSize = nCompact >> 24 - # the lower 23 bits - nWord = nCompact & 0x007fffff - if nSize <= 3: - return nWord >> 8 * (3 - nSize) - else: - return nWord << 8 * (nSize - 3) - - @classmethod - def SetCompact(cls, nCompact): - return cls(cls.fromCompact(nCompact)) - - def bits(self): - """Returns the position of the highest bit set plus one.""" - bn = bin(self._value)[2:] - for i, d in enumerate(bn): - if d: - return (len(bn) - i) + 1 - return 0 - - def GetLow64(self): - return self._value & 0xffffffffffffffff - - def GetCompact(self): - """Convert a value into its compact representation""" - nSize = (self.bits() + 7) // 8 - nCompact = 0 - if nSize <= 3: - nCompact = self.GetLow64() << 8 * (3 - nSize) - else: - bn = _ArithUint256(self._value >> 8 * (nSize - 3)) - nCompact = bn.GetLow64() - # The 0x00800000 bit denotes the sign. - # Thus, if it is already set, divide the mantissa by 256 and increase the exponent. - if nCompact & 0x00800000: - nCompact >>= 8 - nSize += 1 - assert (nCompact & ~0x007fffff) == 0 - assert nSize < 256 - nCompact |= nSize << 24 - return nCompact - - def __mul__(self, x): - # Take the mod because we are limited to an unsigned 256 bit number - return _ArithUint256((self._value * x) % 2 ** 256) - - def __ifloordiv__(self, x): - self._value = (self._value // x) - return self - - def __gt__(self, x): - return self._value > x._value diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 6963db4c0..813c4e555 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -3,13 +3,12 @@ import logging from typing import List, Iterable, Generator from binascii import hexlify -from torba import baseledger from torba.basescript import BaseInputScript, BaseOutputScript from torba.coinselection import CoinSelector from torba.constants import COIN from torba.bcd_data_stream import BCDataStream from torba.hash import sha256 -from torba.account import Account +from torba.baseaccount import BaseAccount from torba.util import ReadOnlyList @@ -45,7 +44,7 @@ class InputOutput(object): class BaseInput(InputOutput): - script_class = None + script_class = BaseInputScript NULL_SIGNATURE = b'\x00'*72 NULL_PUBLIC_KEY = b'\x00'*33 @@ -113,7 +112,7 @@ class BaseOutputEffectiveAmountEstimator(object): __slots__ = 'coin', 'txi', 'txo', 'fee', 'effective_amount' - def __init__(self, ledger, txo): # type: (baseledger.BaseLedger, BaseOutput) -> None + def __init__(self, ledger, txo): # type: (BaseLedger, BaseOutput) -> None self.txo = txo self.txi = ledger.transaction_class.input_class.spend(txo) self.fee = ledger.get_input_output_fee(self.txi) @@ -125,7 +124,7 @@ class BaseOutputEffectiveAmountEstimator(object): class BaseOutput(InputOutput): - script_class = None + script_class = BaseOutputScript estimator_class = BaseOutputEffectiveAmountEstimator def __init__(self, amount, script, txid=None): @@ -154,8 +153,8 @@ class BaseOutput(InputOutput): class BaseTransaction: - input_class = None - output_class = None + input_class = BaseInput + output_class = BaseOutput def __init__(self, raw=None, version=1, locktime=0): self._raw = raw @@ -277,23 +276,23 @@ class BaseTransaction: @classmethod def get_effective_amount_estimators(cls, funding_accounts): - # type: (Iterable[Account]) -> Generator[BaseOutputEffectiveAmountEstimator] + # type: (Iterable[BaseAccount]) -> Generator[BaseOutputEffectiveAmountEstimator] for account in funding_accounts: for utxo in account.coin.ledger.get_unspent_outputs(account): yield utxo.get_estimator(account.coin) @classmethod def ensure_all_have_same_ledger(cls, funding_accounts, change_account=None): - # type: (Iterable[Account], Account) -> baseledger.BaseLedger + # type: (Iterable[BaseAccount], BaseAccount) -> baseledger.BaseLedger ledger = None for account in funding_accounts: if ledger is None: - ledger = account.coin.ledger - if ledger != account.coin.ledger: + ledger = account.ledger + if ledger != account.ledger: raise ValueError( 'All funding accounts used to create a transaction must be on the same ledger.' ) - if change_account is not None and change_account.coin.ledger != ledger: + if change_account is not None and change_account.ledger != ledger: raise ValueError('Change account must use same ledger as funding accounts.') return ledger @@ -331,14 +330,13 @@ class BaseTransaction: def liquidate(cls, assets, funding_accounts, change_account): """ Spend assets (utxos) supplementing with funding_accounts if fee is higher than asset value. """ - def sign(self, funding_accounts): # type: (Iterable[Account]) -> BaseTransaction + def sign(self, funding_accounts): # type: (Iterable[BaseAccount]) -> BaseTransaction ledger = self.ensure_all_have_same_ledger(funding_accounts) for i, txi in enumerate(self._inputs): txo_script = txi.output.script if txo_script.is_pay_pubkey_hash: - address = ledger.coin_class.hash160_to_address(txo_script.values['pubkey_hash']) - account = ledger.accounts.get_account_for_address(address) - private_key = account.get_private_key_for_address(address) + address = ledger.hash160_to_address(txo_script.values['pubkey_hash']) + private_key = ledger.get_private_key_for_address(address) tx = self._serialize_for_signature(i) txi.script.values['signature'] = private_key.sign(tx)+six.int2byte(1) txi.script.values['pubkey'] = private_key.public_key.pubkey_bytes diff --git a/torba/bip32.py b/torba/bip32.py index bb65a51af..2f605f98a 100644 --- a/torba/bip32.py +++ b/torba/bip32.py @@ -16,7 +16,6 @@ import ecdsa import ecdsa.ellipticcurve as EC import ecdsa.numbertheory as NT -from torba.basecoin import BaseCoin from torba.hash import Base58, hmac_sha512, hash160, double_sha256 from torba.util import cachedproperty, bytes_to_int, int_to_bytes @@ -30,9 +29,7 @@ class _KeyBase(object): CURVE = ecdsa.SECP256k1 - def __init__(self, coin, chain_code, n, depth, parent): - if not isinstance(coin, BaseCoin): - raise TypeError('invalid coin') + def __init__(self, ledger, chain_code, n, depth, parent): if not isinstance(chain_code, (bytes, bytearray)): raise TypeError('chain code must be raw bytes') if len(chain_code) != 32: @@ -44,7 +41,7 @@ class _KeyBase(object): if parent is not None: if not isinstance(parent, type(self)): raise TypeError('parent key has bad type') - self.coin = coin + self.ledger = ledger self.chain_code = chain_code self.n = n self.depth = depth @@ -86,8 +83,8 @@ class _KeyBase(object): class PubKey(_KeyBase): """ A BIP32 public key. """ - def __init__(self, coin, pubkey, chain_code, n, depth, parent=None): - super(PubKey, self).__init__(coin, chain_code, n, depth, parent) + def __init__(self, ledger, pubkey, chain_code, n, depth, parent=None): + super(PubKey, self).__init__(ledger, chain_code, n, depth, parent) if isinstance(pubkey, ecdsa.VerifyingKey): self.verifying_key = pubkey else: @@ -129,7 +126,7 @@ class PubKey(_KeyBase): @cachedproperty def address(self): """ The public key as a P2PKH address. """ - return self.coin.public_key_to_address(self.pubkey_bytes) + return self.ledger.public_key_to_address(self.pubkey_bytes) def ec_point(self): return self.verifying_key.pubkey.point @@ -153,7 +150,7 @@ class PubKey(_KeyBase): verkey = ecdsa.VerifyingKey.from_public_point(point, curve=curve) - return PubKey(self.coin, verkey, R, n, self.depth + 1, self) + return PubKey(self.ledger, verkey, R, n, self.depth + 1, self) def identifier(self): """ Return the key's identifier as 20 bytes. """ @@ -162,7 +159,7 @@ class PubKey(_KeyBase): def extended_key(self): """ Return a raw extended public key. """ return self._extended_key( - self.coin.extended_public_key_prefix, + self.ledger.extended_public_key_prefix, self.pubkey_bytes ) @@ -186,8 +183,8 @@ class PrivateKey(_KeyBase): HARDENED = 1 << 31 - def __init__(self, coin, privkey, chain_code, n, depth, parent=None): - super(PrivateKey, self).__init__(coin, chain_code, n, depth, parent) + def __init__(self, ledger, privkey, chain_code, n, depth, parent=None): + super(PrivateKey, self).__init__(ledger, chain_code, n, depth, parent) if isinstance(privkey, ecdsa.SigningKey): self.signing_key = privkey else: @@ -212,11 +209,11 @@ class PrivateKey(_KeyBase): return exponent @classmethod - def from_seed(cls, coin, seed): + def from_seed(cls, ledger, seed): # This hard-coded message string seems to be coin-independent... hmac = hmac_sha512(b'Bitcoin seed', seed) privkey, chain_code = hmac[:32], hmac[32:] - return cls(coin, privkey, chain_code, 0, 0) + return cls(ledger, privkey, chain_code, 0, 0) @cachedproperty def private_key_bytes(self): @@ -228,7 +225,7 @@ class PrivateKey(_KeyBase): """ Return the corresponding extended public key. """ verifying_key = self.signing_key.get_verifying_key() parent_pubkey = self.parent.public_key if self.parent else None - return PubKey(self.coin, verifying_key, self.chain_code, self.n, self.depth, + return PubKey(self.ledger, verifying_key, self.chain_code, self.n, self.depth, parent_pubkey) def ec_point(self): @@ -240,7 +237,7 @@ class PrivateKey(_KeyBase): def wif(self): """ Return the private key encoded in Wallet Import Format. """ - return self.coin.private_key_to_wif(self.private_key_bytes) + return self.ledger.private_key_to_wif(self.private_key_bytes) def address(self): """ The public key as a P2PKH address. """ @@ -267,7 +264,7 @@ class PrivateKey(_KeyBase): privkey = _exponent_to_bytes(exponent) - return PrivateKey(self.coin, privkey, R, n, self.depth + 1, self) + return PrivateKey(self.ledger, privkey, R, n, self.depth + 1, self) def sign(self, data): """ Produce a signature for piece of data by double hashing it and signing the hash. """ @@ -282,7 +279,7 @@ class PrivateKey(_KeyBase): def extended_key(self): """Return a raw extended private key.""" return self._extended_key( - self.coin.extended_private_key_prefix, + self.ledger.extended_private_key_prefix, b'\0' + self.private_key_bytes ) @@ -292,7 +289,7 @@ def _exponent_to_bytes(exponent): return (int2byte(0)*32 + int_to_bytes(exponent))[-32:] -def _from_extended_key(coin, ekey): +def _from_extended_key(ledger, ekey): """Return a PubKey or PrivateKey from an extended key raw bytes.""" if not isinstance(ekey, (bytes, bytearray)): raise TypeError('extended key must be raw bytes') @@ -304,21 +301,21 @@ def _from_extended_key(coin, ekey): n, = struct.unpack('>I', ekey[9:13]) chain_code = ekey[13:45] - if ekey[:4] == coin.extended_public_key_prefix: + if ekey[:4] == ledger.extended_public_key_prefix: pubkey = ekey[45:] - key = PubKey(coin, pubkey, chain_code, n, depth) - elif ekey[:4] == coin.extended_private_key_prefix: + key = PubKey(ledger, pubkey, chain_code, n, depth) + elif ekey[:4] == ledger.extended_private_key_prefix: if indexbytes(ekey, 45) != 0: raise ValueError('invalid extended private key prefix byte') privkey = ekey[46:] - key = PrivateKey(coin, privkey, chain_code, n, depth) + key = PrivateKey(ledger, privkey, chain_code, n, depth) else: raise ValueError('version bytes unrecognised') return key -def from_extended_key_string(coin, ekey_str): +def from_extended_key_string(ledger, ekey_str): """Given an extended key string, such as xpub6BsnM1W2Y7qLMiuhi7f7dbAwQZ5Cz5gYJCRzTNainXzQXYjFwtuQXHd @@ -326,4 +323,4 @@ def from_extended_key_string(coin, ekey_str): return a PubKey or PrivateKey. """ - return _from_extended_key(coin, Base58.decode_check(ekey_str)) + return _from_extended_key(ledger, Base58.decode_check(ekey_str)) diff --git a/torba/coin/bitcoincash.py b/torba/coin/bitcoincash.py index 6f41e126f..f416ced41 100644 --- a/torba/coin/bitcoincash.py +++ b/torba/coin/bitcoincash.py @@ -13,7 +13,7 @@ from torba.basescript import BaseInputScript, BaseOutputScript from torba.basetransaction import BaseTransaction, BaseInput, BaseOutput from torba.basecoin import BaseCoin from torba.basedatabase import BaseSQLiteWalletStorage -from torba.basemanager import BaseWalletManager +from torba.manager import BaseWalletManager class WalletManager(BaseWalletManager): diff --git a/torba/coin/bitcoinsegwit.py b/torba/coin/bitcoinsegwit.py index 82d0fcbb5..d38cc71c2 100644 --- a/torba/coin/bitcoinsegwit.py +++ b/torba/coin/bitcoinsegwit.py @@ -7,65 +7,14 @@ __node_url__ = ( from six import int2byte from binascii import unhexlify -from torba.baseledger import BaseLedger, BaseHeaders -from torba.basenetwork import BaseNetwork -from torba.basescript import BaseInputScript, BaseOutputScript -from torba.basetransaction import BaseTransaction, BaseInput, BaseOutput -from torba.basecoin import BaseCoin -from torba.basedatabase import BaseSQLiteWalletStorage -from torba.basemanager import BaseWalletManager +from torba.baseledger import BaseLedger +from torba.baseheader import BaseHeaders -class WalletManager(BaseWalletManager): - pass - - -class SQLiteWalletStorage(BaseSQLiteWalletStorage): - pass - - -class Input(BaseInput): - script_class = BaseInputScript - - -class Output(BaseOutput): - script_class = BaseOutputScript - - -class Transaction(BaseTransaction): - input_class = Input - output_class = Output - - -class BitcoinSegwitLedger(BaseLedger): - network_class = BaseNetwork - headers_class = BaseHeaders - - -class MainNetLedger(BitcoinSegwitLedger): - pass - - -class UnverifiedHeaders(BaseHeaders): - verify_bits_to_target = False - - -class RegTestLedger(BitcoinSegwitLedger): - headers_class = UnverifiedHeaders - max_target = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - genesis_hash = '0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206' - genesis_bits = 0x207fffff - target_timespan = 1 - verify_bits_to_target = False - - -class BitcoinSegwit(BaseCoin): +class MainNetLedger(BaseLedger): name = 'BitcoinSegwit' symbol = 'BTC' - network = 'mainnet' - - ledger_class = MainNetLedger - transaction_class = Transaction + network_name = 'mainnet' pubkey_address_prefix = int2byte(0x00) script_address_prefix = int2byte(0x05) @@ -74,10 +23,16 @@ class BitcoinSegwit(BaseCoin): default_fee_per_byte = 50 - def __init__(self, ledger, fee_per_byte=default_fee_per_byte): - super(BitcoinSegwit, self).__init__(ledger, fee_per_byte) + +class UnverifiedHeaders(BaseHeaders): + verify_bits_to_target = False -class BitcoinSegwitRegtest(BitcoinSegwit): - network = 'regtest' - ledger_class = RegTestLedger +class RegTestLedger(MainNetLedger): + network_name = 'regtest' + headers_class = UnverifiedHeaders + max_target = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + genesis_hash = '0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206' + genesis_bits = 0x207fffff + target_timespan = 1 + verify_bits_to_target = False diff --git a/torba/basemanager.py b/torba/manager.py similarity index 93% rename from torba/basemanager.py rename to torba/manager.py index ea5b6e9f7..31b5ab107 100644 --- a/torba/basemanager.py +++ b/torba/manager.py @@ -2,8 +2,7 @@ import functools from typing import List, Dict, Type from twisted.internet import defer -from torba.account import AccountsView -from torba.basecoin import CoinRegistry +from torba.baseaccount import AccountsView from torba.baseledger import BaseLedger from torba.basetransaction import BaseTransaction, NULL_HASH from torba.coinselection import CoinSelector @@ -11,7 +10,7 @@ from torba.constants import COIN from torba.wallet import Wallet, WalletStorage -class BaseWalletManager(object): +class WalletManager(object): def __init__(self, wallets=None, ledgers=None): self.wallets = wallets or [] # type: List[Wallet] @@ -35,12 +34,12 @@ class BaseWalletManager(object): ledger_class = coin_class.ledger_class ledger = self.ledgers.get(ledger_class) if ledger is None: - ledger = self.create_ledger(ledger_class, self.get_accounts_view(coin_class), ledger_config or {}) + ledger = self.create_ledger(ledger_class, ledger_config or {}) self.ledgers[ledger_class] = ledger return ledger - def create_ledger(self, ledger_class, accounts, config): - return ledger_class(accounts, config) + def create_ledger(self, ledger_class, config): + return ledger_class(config) @defer.inlineCallbacks def get_balance(self): diff --git a/torba/wallet.py b/torba/wallet.py index 92a8b7019..38421c362 100644 --- a/torba/wallet.py +++ b/torba/wallet.py @@ -3,16 +3,15 @@ import json import os from typing import List, Dict -from torba.account import Account -from torba.basecoin import CoinRegistry, BaseCoin -from torba.baseledger import BaseLedger +from torba.baseaccount import BaseAccount +from torba.baseledger import LedgerRegistry, BaseLedger -def inflate_coin(manager, coin_id, coin_dict): - # type: ('WalletManager', str, Dict) -> BaseCoin - coin_class = CoinRegistry.get_coin_class(coin_id) - ledger = manager.get_or_create_ledger(coin_id) - return coin_class(ledger, **coin_dict) +def inflate_ledger(manager, ledger_id, ledger_dict): + # type: ('WalletManager', str, Dict) -> BaseLedger + ledger_class = LedgerRegistry.get_ledger_class(ledger_id) + ledger = manager.get_or_create_ledger(ledger_id) + return ledger_class(ledger, **ledger_dict) class Wallet: @@ -22,23 +21,14 @@ class Wallet: by physical files on the filesystem. """ - def __init__(self, name='Wallet', coins=None, accounts=None, storage=None): + def __init__(self, name='Wallet', ledgers=None, accounts=None, storage=None): self.name = name - self.coins = coins or [] # type: List[BaseCoin] - self.accounts = accounts or [] # type: List[Account] + self.ledgers = ledgers or [] # type: List[BaseLedger] + self.accounts = accounts or [] # type: List[BaseAccount] self.storage = storage or WalletStorage() - def get_or_create_coin(self, ledger, coin_dict=None): # type: (BaseLedger, Dict) -> BaseCoin - for coin in self.coins: - if coin.__class__ is ledger.coin_class: - return coin - coin = ledger.coin_class(ledger, **(coin_dict or {})) - self.coins.append(coin) - return coin - def generate_account(self, ledger): # type: (BaseLedger) -> Account - coin = self.get_or_create_coin(ledger) - account = Account.generate(coin, u'torba') + account = ledger.account_class.generate(ledger, u'torba') self.accounts.append(account) return account @@ -46,22 +36,22 @@ class Wallet: def from_storage(cls, storage, manager): # type: (WalletStorage, 'WalletManager') -> Wallet json_dict = storage.read() - coins = {} - for coin_id, coin_dict in json_dict.get('coins', {}).items(): - coins[coin_id] = inflate_coin(manager, coin_id, coin_dict) + ledgers = {} + for ledger_id, ledger_dict in json_dict.get('ledgers', {}).items(): + ledgers[ledger_id] = inflate_ledger(manager, ledger_id, ledger_dict) accounts = [] for account_dict in json_dict.get('accounts', []): - coin_id = account_dict['coin'] - coin = coins.get(coin_id) - if coin is None: - coin = coins[coin_id] = inflate_coin(manager, coin_id, {}) - account = Account.from_dict(coin, account_dict) + ledger_id = account_dict['ledger'] + ledger = ledgers.get(ledger_id) + if ledger is None: + ledger = ledgers[ledger_id] = inflate_ledger(manager, ledger_id, {}) + account = ledger.account_class.from_dict(ledger, account_dict) accounts.append(account) return cls( name=json_dict.get('name', 'Wallet'), - coins=list(coins.values()), + ledgers=list(ledgers.values()), accounts=accounts, storage=storage ) @@ -69,7 +59,7 @@ class Wallet: def to_dict(self): return { 'name': self.name, - 'coins': {c.get_id(): c.to_dict() for c in self.coins}, + 'ledgers': {c.get_id(): {} for c in self.ledgers}, 'accounts': [a.to_dict() for a in self.accounts] } From fbd1b2ec306c0015d24c1ce8c751dd3e160f94db Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 12 Jun 2018 10:02:04 -0400 Subject: [PATCH 013/383] monday progress --- tests/integration/test_transactions.py | 18 ++- tests/unit/test_account.py | 100 ++++++++++--- tests/unit/test_ledger.py | 69 ++++++++- torba/baseaccount.py | 147 +++++++++---------- torba/basedatabase.py | 193 +++++++++++-------------- torba/baseledger.py | 100 ++++++------- torba/basetransaction.py | 32 ++-- torba/coin/bitcoincash.py | 3 +- torba/coin/bitcoinsegwit.py | 11 +- torba/manager.py | 15 +- 10 files changed, 386 insertions(+), 302 deletions(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index fd16cc534..9cf9327aa 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -10,23 +10,29 @@ class BasicTransactionTests(IntegrationTestCase): async def test_sending_and_recieving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) + await account1.ensure_address_gap().asFuture(asyncio.get_event_loop()) + self.assertEqual(await self.get_balance(account1), 0) self.assertEqual(await self.get_balance(account2), 0) - address = await account1.get_least_used_receiving_address().asFuture(asyncio.get_event_loop()) + address = await account1.receiving.get_or_create_usable_address().asFuture(asyncio.get_event_loop()) sendtxid = await self.blockchain.send_to_address(address.decode(), 5.5) - await self.blockchain.generate(1) await self.on_transaction(sendtxid) + await self.blockchain.generate(1) + await asyncio.sleep(5) self.assertEqual(await self.get_balance(account1), int(5.5*COIN)) self.assertEqual(await self.get_balance(account2), 0) - address = await account2.get_least_used_receiving_address().asFuture(asyncio.get_event_loop()) - sendtxid = await self.blockchain.send_to_address(address.decode(), 5.5) + address = await account2.receiving.get_or_create_usable_address().asFuture(asyncio.get_event_loop()) + tx = await self.ledger.transaction_class.pay( + [self.ledger.transaction_class.output_class.pay_pubkey_hash(2, self.ledger.address_to_hash160(address))], + [account1], account1 + ).asFuture(asyncio.get_event_loop()) await self.broadcast(tx) await self.on_transaction(tx.id.decode()) await self.lbrycrd.generate(1) - self.assertEqual(await self.get_balance(account1), int(3.0*COIN)) - self.assertEqual(await self.get_balance(account2), int(2.5*COIN)) + self.assertEqual(await self.get_balance(account1), int(3.5*COIN)) + self.assertEqual(await self.get_balance(account2), int(2.0*COIN)) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index 323420ba4..393def1d4 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -5,6 +5,66 @@ from twisted.internet import defer from torba.coin.bitcoinsegwit import MainNetLedger +class TestKeyChain(unittest.TestCase): + + def setUp(self): + self.ledger = MainNetLedger(db=':memory:') + return self.ledger.db.start() + + @defer.inlineCallbacks + def test_address_gap_algorithm(self): + account = self.ledger.account_class.generate(self.ledger, u"torba") + + # save records out of order to make sure we're really testing ORDER BY + # and not coincidentally getting records in the correct order + yield account.receiving.generate_keys(4, 7) + yield account.receiving.generate_keys(0, 3) + yield account.receiving.generate_keys(8, 11) + keys = yield account.receiving.get_addresses(None, True) + self.assertEqual( + [key['position'] for key in keys], + [11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0] + ) + + # we have 12, but default gap is 20 + new_keys = yield account.receiving.ensure_address_gap() + self.assertEqual(len(new_keys), 8) + keys = yield account.receiving.get_addresses(None, True) + self.assertEqual( + [key['position'] for key in keys], + [19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0] + ) + + # case #1: no new addresses needed + empty = yield account.receiving.ensure_address_gap() + self.assertEqual(len(empty), 0) + + # case #2: only one new addressed needed + keys = yield account.receiving.get_addresses(None, True) + yield self.ledger.db.set_address_history(keys[19]['address'], 'a:1:') + new_keys = yield account.receiving.ensure_address_gap() + self.assertEqual(len(new_keys), 1) + + # case #3: 20 addresses needed + keys = yield account.receiving.get_addresses(None, True) + yield self.ledger.db.set_address_history(keys[0]['address'], 'a:1:') + new_keys = yield account.receiving.ensure_address_gap() + self.assertEqual(len(new_keys), 20) + + @defer.inlineCallbacks + def test_create_usable_address(self): + account = self.ledger.account_class.generate(self.ledger, u"torba") + + keys = yield account.receiving.get_addresses(None, True) + self.assertEqual(len(keys), 0) + + address = yield account.receiving.get_or_create_usable_address() + self.assertIsNotNone(address) + + keys = yield account.receiving.get_addresses(None, True) + self.assertEqual(len(keys), 20) + + class TestAccount(unittest.TestCase): def setUp(self): @@ -19,24 +79,16 @@ class TestAccount(unittest.TestCase): self.assertEqual(account.public_key.ledger, self.ledger) self.assertEqual(account.private_key.public_key, account.public_key) - keys = yield account.receiving.get_keys() addresses = yield account.receiving.get_addresses() - self.assertEqual(len(keys), 0) self.assertEqual(len(addresses), 0) - keys = yield account.change.get_keys() addresses = yield account.change.get_addresses() - self.assertEqual(len(keys), 0) self.assertEqual(len(addresses), 0) - yield account.ensure_enough_useable_addresses() + yield account.ensure_address_gap() - keys = yield account.receiving.get_keys() addresses = yield account.receiving.get_addresses() - self.assertEqual(len(keys), 20) self.assertEqual(len(addresses), 20) - keys = yield account.change.get_keys() addresses = yield account.change.get_addresses() - self.assertEqual(len(keys), 6) self.assertEqual(len(addresses), 6) @defer.inlineCallbacks @@ -57,19 +109,23 @@ class TestAccount(unittest.TestCase): b'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' b'iW44g14WF52fYC5J483wqQ5ZP' ) - address = yield account.receiving.ensure_enough_useable_addresses() - self.assertEqual(address[0], b'1PGDB1CRy8UxPCrkcakRqroVnHxqzvUZhp') - private_key = yield self.ledger.get_private_key_for_address(b'1PGDB1CRy8UxPCrkcakRqroVnHxqzvUZhp') + address = yield account.receiving.ensure_address_gap() + self.assertEqual(address[0], b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') + + self.maxDiff = None + private_key = yield self.ledger.get_private_key_for_address(b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') self.assertEqual( private_key.extended_key_string(), - b'xprv9xNEfQ296VTRc5QF7AZZ1WTimGzMs54FepRXVxbyypJXCrUKjxsYSyk5EhHYNxU4ApsaBr8AQ4sYo86BbGh2dZSddGXU1CMGwExvnyckjQn' + b'xprv9xNEfQ296VTRaEUDZ8oKq74xw2U6kpj486vFUB4K1wT9U25GX4UwuzFgJN1YuRrqkQ5TTwCpkYnjNpSoH' + b'SBaEigNHPkoeYbuPMRo6mRUjxg' ) + invalid_key = yield self.ledger.get_private_key_for_address(b'BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX') self.assertIsNone(invalid_key) self.assertEqual( hexlify(private_key.wif()), - b'1c5664e848772b199644ab390b5c27d2f6664d9cdfdb62e1c7ac25151b00858b7a01' + b'1cc27be89ad47ef932562af80e95085eb0ab2ae3e5c019b1369b8b05ff2e94512f01' ) @defer.inlineCallbacks @@ -80,26 +136,24 @@ class TestAccount(unittest.TestCase): "h absent", 'encrypted': False, 'private_key': - 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - '6yz3jMbycrLrRMpeAJxR8qDg8', + b'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + b'6yz3jMbycrLrRMpeAJxR8qDg8', 'public_key': - 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' - 'iW44g14WF52fYC5J483wqQ5ZP', + b'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' + b'iW44g14WF52fYC5J483wqQ5ZP', 'receiving_gap': 10, + 'receiving_maximum_use_per_address': 2, 'change_gap': 10, + 'change_maximum_use_per_address': 2 } account = self.ledger.account_class.from_dict(self.ledger, account_data) - yield account.ensure_enough_useable_addresses() + yield account.ensure_address_gap() - keys = yield account.receiving.get_keys() addresses = yield account.receiving.get_addresses() - self.assertEqual(len(keys), 10) self.assertEqual(len(addresses), 10) - keys = yield account.change.get_keys() addresses = yield account.change.get_addresses() - self.assertEqual(len(keys), 10) self.assertEqual(len(addresses), 10) self.maxDiff = None diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index d1aaec30d..eb281888a 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -1,15 +1,72 @@ +from binascii import hexlify from twisted.trial import unittest from twisted.internet import defer -from torba.basedatabase import BaseSQLiteWalletStorage +from torba.coin.bitcoinsegwit import MainNetLedger + +from .test_transaction import get_transaction -class TestDatabase(unittest.TestCase): +class MockNetwork: + + def __init__(self, history, transaction): + self.history = history + self.transaction = transaction + self.address = None + self.get_history_called = [] + self.get_transaction_called = [] + + def get_history(self, address): + self.get_history_called.append(address) + self.address = address + return defer.succeed(self.history) + + def get_transaction(self, tx_hash): + self.get_transaction_called.append(tx_hash) + return defer.succeed(self.transaction[tx_hash]) + + +class TestSynchronization(unittest.TestCase): def setUp(self): - self.db = BaseSQLiteWalletStorage(':memory:') - return self.db.start() + self.ledger = MainNetLedger(db=':memory:') + return self.ledger.db.start() @defer.inlineCallbacks - def test_empty_db(self): - result = yield self.db. + def test_update_history(self): + account = self.ledger.account_class.generate(self.ledger, u"torba") + address = yield account.receiving.get_or_create_usable_address() + address_details = yield self.ledger.db.get_address(address) + self.assertEqual(address_details['history'], None) + + self.ledger.network = MockNetwork([ + {'tx_hash': b'abc', 'height': 1}, + {'tx_hash': b'def', 'height': 2}, + {'tx_hash': b'ghi', 'height': 3}, + ], { + b'abc': hexlify(get_transaction().raw), + b'def': hexlify(get_transaction().raw), + b'ghi': hexlify(get_transaction().raw), + }) + yield self.ledger.update_history(address) + self.assertEqual(self.ledger.network.get_history_called, [address]) + self.assertEqual(self.ledger.network.get_transaction_called, [b'abc', b'def', b'ghi']) + + address_details = yield self.ledger.db.get_address(address) + self.assertEqual(address_details['history'], b'abc:1:def:2:ghi:3:') + + self.ledger.network.get_history_called = [] + self.ledger.network.get_transaction_called = [] + yield self.ledger.update_history(address) + self.assertEqual(self.ledger.network.get_history_called, [address]) + self.assertEqual(self.ledger.network.get_transaction_called, []) + + self.ledger.network.history.append({'tx_hash': b'jkl', 'height': 4}) + self.ledger.network.transaction[b'jkl'] = hexlify(get_transaction().raw) + self.ledger.network.get_history_called = [] + self.ledger.network.get_transaction_called = [] + yield self.ledger.update_history(address) + self.assertEqual(self.ledger.network.get_history_called, [address]) + self.assertEqual(self.ledger.network.get_transaction_called, [b'jkl']) + address_details = yield self.ledger.db.get_address(address) + self.assertEqual(address_details['history'], b'abc:1:def:2:ghi:3:jkl:4:') diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 8ef24e864..194f287ba 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -1,7 +1,7 @@ from typing import Dict -from binascii import unhexlify from twisted.internet import defer +import torba.baseledger from torba.mnemonic import Mnemonic from torba.bip32 import PrivateKey, PubKey, from_extended_key_string from torba.hash import double_sha256, aes_encrypt, aes_decrypt @@ -9,55 +9,59 @@ from torba.hash import double_sha256, aes_encrypt, aes_decrypt class KeyChain: - def __init__(self, account, parent_key, chain_number, minimum_usable_addresses): + def __init__(self, account, parent_key, chain_number, gap, maximum_use_per_address): + # type: ('BaseAccount', PubKey, int, int, int) -> None self.account = account self.db = account.ledger.db - self.main_key = parent_key.child(chain_number) # type: PubKey + self.main_key = parent_key.child(chain_number) self.chain_number = chain_number - self.minimum_usable_addresses = minimum_usable_addresses + self.gap = gap + self.maximum_use_per_address = maximum_use_per_address - def get_keys(self): - return self.db.get_keys(self.account, self.chain_number) + def get_addresses(self, limit=None, details=False): + return self.db.get_addresses(self.account, self.chain_number, limit, details) - def get_addresses(self): - return self.db.get_addresses(self.account, self.chain_number) + def get_usable_addresses(self, limit=None): + return self.db.get_usable_addresses( + self.account, self.chain_number, self.maximum_use_per_address, limit + ) @defer.inlineCallbacks - def ensure_enough_useable_addresses(self): - usable_address_count = yield self.db.get_usable_address_count( - self.account, self.chain_number - ) - - if usable_address_count >= self.minimum_usable_addresses: - defer.returnValue([]) - - new_addresses_needed = self.minimum_usable_addresses - usable_address_count - - start = yield self.db.get_last_address_index( - self.account, self.chain_number - ) - end = start + new_addresses_needed - + def generate_keys(self, start, end): new_keys = [] - for index in range(start+1, end+1): + for index in range(start, end+1): new_keys.append((index, self.main_key.child(index))) - yield self.db.add_keys( self.account, self.chain_number, new_keys ) - - defer.returnValue([ - key[1].address for key in new_keys - ]) + defer.returnValue([key[1].address for key in new_keys]) @defer.inlineCallbacks - def has_gap(self): - if len(self.addresses) < self.minimum_gap: - defer.returnValue(False) - for address in self.addresses[-self.minimum_gap:]: - if (yield self.ledger.is_address_old(address)): - defer.returnValue(False) - defer.returnValue(True) + def ensure_address_gap(self): + addresses = yield self.get_addresses(self.gap, True) + + existing_gap = 0 + for address in addresses: + if address['used_times'] == 0: + existing_gap += 1 + else: + break + + if existing_gap == self.gap: + defer.returnValue([]) + + start = addresses[0]['position']+1 if addresses else 0 + end = start + (self.gap - existing_gap) + new_keys = yield self.generate_keys(start, end-1) + defer.returnValue(new_keys) + + @defer.inlineCallbacks + def get_or_create_usable_address(self): + addresses = yield self.get_usable_addresses(1) + if addresses: + return addresses[0] + addresses = yield self.ensure_address_gap() + return addresses[0] class BaseAccount: @@ -67,26 +71,28 @@ class BaseAccount: public_key_class = PubKey def __init__(self, ledger, seed, encrypted, private_key, - public_key, receiving_gap=20, change_gap=6): - self.ledger = ledger # type: baseledger.BaseLedger - self.seed = seed # type: str - self.encrypted = encrypted # type: bool - self.private_key = private_key # type: PrivateKey - self.public_key = public_key # type: PubKey + public_key, receiving_gap=20, change_gap=6, + receiving_maximum_use_per_address=2, change_maximum_use_per_address=2): + # type: (torba.baseledger.BaseLedger, str, bool, PrivateKey, PubKey, int, int, int, int) -> None + self.ledger = ledger + self.seed = seed + self.encrypted = encrypted + self.private_key = private_key + self.public_key = public_key self.receiving, self.change = self.keychains = ( - KeyChain(self, public_key, 0, receiving_gap), - KeyChain(self, public_key, 1, change_gap) + KeyChain(self, public_key, 0, receiving_gap, receiving_maximum_use_per_address), + KeyChain(self, public_key, 1, change_gap, change_maximum_use_per_address) ) ledger.account_created(self) @classmethod - def generate(cls, ledger, password): # type: (baseledger.BaseLedger, str) -> BaseAccount + def generate(cls, ledger, password): # type: (torba.baseledger.BaseLedger, str) -> BaseAccount seed = cls.mnemonic_class().make_seed() return cls.from_seed(ledger, seed, password) @classmethod def from_seed(cls, ledger, seed, password): - # type: (baseledger.BaseLedger, str, str) -> BaseAccount + # type: (torba.baseledger.BaseLedger, str, str) -> BaseAccount private_key = cls.get_private_key_from_seed(ledger, seed, password) return cls( ledger=ledger, seed=seed, encrypted=False, @@ -96,13 +102,13 @@ class BaseAccount: @classmethod def get_private_key_from_seed(cls, ledger, seed, password): - # type: (baseledger.BaseLedger, str, str) -> PrivateKey + # type: (torba.baseledger.BaseLedger, str, str) -> PrivateKey return cls.private_key_class.from_seed( ledger, cls.mnemonic_class.mnemonic_to_seed(seed, password) ) @classmethod - def from_dict(cls, ledger, d): # type: (baseledger.BaseLedger, Dict) -> BaseAccount + def from_dict(cls, ledger, d): # type: (torba.baseledger.BaseLedger, Dict) -> BaseAccount if not d['encrypted']: private_key = from_extended_key_string(ledger, d['private_key']) public_key = private_key.public_key @@ -116,7 +122,9 @@ class BaseAccount: private_key=private_key, public_key=public_key, receiving_gap=d['receiving_gap'], - change_gap=d['change_gap'] + change_gap=d['change_gap'], + receiving_maximum_use_per_address=d['receiving_maximum_use_per_address'], + change_maximum_use_per_address=d['change_maximum_use_per_address'] ) def to_dict(self): @@ -127,8 +135,10 @@ class BaseAccount: 'private_key': self.private_key if self.encrypted else self.private_key.extended_key_string(), 'public_key': self.public_key.extended_key_string(), - 'receiving_gap': self.receiving.minimum_usable_addresses, - 'change_gap': self.change.minimum_usable_addresses, + 'receiving_gap': self.receiving.gap, + 'change_gap': self.change.gap, + 'receiving_maximum_use_per_address': self.receiving.maximum_use_per_address, + 'change_maximum_use_per_address': self.change.maximum_use_per_address } def decrypt(self, password): @@ -146,39 +156,22 @@ class BaseAccount: self.encrypted = True @defer.inlineCallbacks - def ensure_enough_useable_addresses(self): + def ensure_address_gap(self): addresses = [] for keychain in self.keychains: - new_addresses = yield keychain.ensure_enough_useable_addresses() + new_addresses = yield keychain.ensure_address_gap() addresses.extend(new_addresses) defer.returnValue(addresses) + def get_addresses(self, limit=None, details=False): + return self.ledger.db.get_addresses(self, None, limit, details) + + def get_unused_addresses(self): + return self.ledger.db.get_unused_addresses(self, None) + def get_private_key(self, chain, index): assert not self.encrypted, "Cannot get private key on encrypted wallet account." return self.private_key.child(chain).child(index) - def get_least_used_receiving_address(self, max_transactions=1000): - return self._get_least_used_address( - self.receiving_keys, - max_transactions - ) - - def get_least_used_change_address(self, max_transactions=100): - return self._get_least_used_address( - self.change_keys, - max_transactions - ) - - def _get_least_used_address(self, keychain, max_transactions): - ledger = self.ledger - address = ledger.get_least_used_address(self, keychain, max_transactions) - if address: - return address - address = keychain.generate_next_address() - ledger.subscribe_history(address) - return address - - @defer.inlineCallbacks def get_balance(self): - utxos = yield self.ledger.get_unspent_outputs(self) - defer.returnValue(sum(utxo.amount for utxo in utxos)) + return self.ledger.db.get_balance_for_account(self) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index c06995d88..5f7d4f2a6 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -1,8 +1,12 @@ import logging +from typing import List, Union + import sqlite3 from twisted.internet import defer from twisted.enterprise import adbapi +import torba.baseaccount + log = logging.getLogger(__name__) @@ -34,17 +38,19 @@ class SQLiteMixin(object): return trans.execute(sql).fetchall() def _insert_sql(self, table, data): + # type: (str, dict) -> tuple[str, List] columns, values = [], [] for column, value in data.items(): columns.append(column) values.append(value) - sql = "REPLACE INTO %s (%s) VALUES (%s)".format( + sql = "REPLACE INTO {} ({}) VALUES ({})".format( table, ', '.join(columns), ', '.join(['?'] * len(values)) ) return sql, values @defer.inlineCallbacks def query_one_value_list(self, query, params): + # type: (str, Union[dict,tuple]) -> defer.Deferred[List] result = yield self.db.runQuery(query, params) if result: defer.returnValue([i[0] for i in result]) @@ -137,27 +143,7 @@ class BaseDatabase(SQLiteMixin): CREATE_TXI_TABLE ) - def get_missing_transactions(self, address, txids): - def _steps(t): - missing = [] - chunk_size = 100 - for i in range(0, len(txids), chunk_size): - chunk = txids[i:i + chunk_size] - t.execute( - "SELECT 1 FROM tx WHERE txid=?", - (sqlite3.Binary(txid) for txid in chunk) - ) - if not t.execute("SELECT 1 FROM tx WHERE txid=?", (sqlite3.Binary(tx.id),)).fetchone(): - t.execute(*self._insert_sql('tx', { - 'txid': sqlite3.Binary(tx.id), - 'raw': sqlite3.Binary(tx.raw), - 'height': height, - 'is_confirmed': is_confirmed, - 'is_verified': is_verified - })) - return self.db.runInteraction(_steps) - - def add_transaction(self, address, tx, height, is_confirmed, is_verified): + def add_transaction(self, address, hash, tx, height, is_confirmed, is_verified): def _steps(t): if not t.execute("SELECT 1 FROM tx WHERE txid=?", (sqlite3.Binary(tx.id),)).fetchone(): t.execute(*self._insert_sql('tx', { @@ -167,46 +153,37 @@ class BaseDatabase(SQLiteMixin): 'is_confirmed': is_confirmed, 'is_verified': is_verified })) - t.execute(*self._insert_sql( - "insert into txo values (?, ?, ?, ?, ?, ?, ?, ?, ?)", ( - sqlite3.Binary(account.public_key.address), - sqlite3.Binary(txo.script.values['pubkey_hash']), - sqlite3.Binary(txo.txid), - txo.index, - txo.amount, - sqlite3.Binary(txo.script.source), - txo.script.is_claim_name, - txo.script.is_support_claim, - txo.script.is_update_claim - ) - - )) - txoid = t.execute( - "select rowid from txo where txid=? and pos=?", ( - sqlite3.Binary(txi.output_txid), txi.output_index - ) - ).fetchone()[0] - t.execute( - "insert into txi values (?, ?, ?)", ( - sqlite3.Binary(account.public_key.address), - sqlite3.Binary(txi.txid), - txoid - ) - ) + for txo in tx.outputs: + if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == hash: + t.execute(*self._insert_sql("txo", { + 'txid': sqlite3.Binary(tx.id), + 'address': sqlite3.Binary(address), + 'position': txo.index, + 'amount': txo.amount, + 'script': sqlite3.Binary(txo.script.source) + })) + elif txo.script.is_pay_script_hash: + # TODO: implement script hash payments + print('Database.add_transaction pay script hash is not implemented!') + for txi in tx.inputs: + txoid = t.execute( + "SELECT txoid, address FROM txo WHERE txid = ? AND position = ?", + (sqlite3.Binary(txi.output_txid), txi.output_index) + ).fetchone() + if txoid: + t.execute(*self._insert_sql("txi", { + 'txid': sqlite3.Binary(tx.id), + 'address': sqlite3.Binary(address), + 'txoid': txoid, + })) return self.db.runInteraction(_steps) - @defer.inlineCallbacks - def has_transaction(self, txid): - result = yield self.db.runQuery( - "select rowid from tx where txid=?", (txid,) - ) - defer.returnValue(bool(result)) - @defer.inlineCallbacks def get_balance_for_account(self, account): result = yield self.db.runQuery( - "select sum(amount) from txo where account=:account and rowid not in (select txo from txi where account=:account)", + "SELECT SUM(amount) FROM txo NATURAL JOIN pubkey_address WHERE account=:account AND " + "txoid NOT IN (SELECT txoid FROM txi)", {'account': sqlite3.Binary(account.public_key.address)} ) if result: @@ -218,12 +195,9 @@ class BaseDatabase(SQLiteMixin): def get_utxos(self, account, output_class): utxos = yield self.db.runQuery( """ - SELECT - amount, script, txid - FROM txo - WHERE - account=:account AND - txoid NOT IN (SELECT txoid FROM txi WHERE account=:account) + SELECT amount, script, txid, position + FROM txo NATURAL JOIN pubkey_address + WHERE account=:account AND txoid NOT IN (SELECT txoid FROM txi) """, {'account': sqlite3.Binary(account.public_key.address)} ) @@ -231,7 +205,8 @@ class BaseDatabase(SQLiteMixin): output_class( values[0], output_class.script_class(values[1]), - values[2] + values[2], + index=values[3] ) for values in utxos ]) @@ -250,64 +225,58 @@ class BaseDatabase(SQLiteMixin): values.append(sqlite3.Binary(pubkey.pubkey_bytes)) return self.db.runOperation(sql, values) - def get_keys(self, account, chain): - return self.query_one_value_list( - "SELECT pubkey FROM pubkey_address WHERE account = ? AND chain = ?", - (sqlite3.Binary(account.public_key.address), chain) - ) + def get_addresses(self, account, chain, limit=None, details=False): + sql = ["SELECT {} FROM pubkey_address WHERE account = :account"] + params = {'account': sqlite3.Binary(account.public_key.address)} + if chain is not None: + sql.append("AND chain = :chain") + params['chain'] = chain + sql.append("ORDER BY position DESC") + if limit is not None: + sql.append("LIMIT {}".format(limit)) + if details: + return self.query_dict_value_list(' '.join(sql), ('address', 'position', 'used_times'), params) + else: + return self.query_one_value_list(' '.join(sql).format('address'), params) - def get_address_details(self, address): - return self.query_dict_value( - "SELECT {} FROM pubkey_address WHERE address = ?", - ('account', 'chain', 'position'), (sqlite3.Binary(address),) - ) - - def get_addresses(self, account, chain): - return self.query_one_value_list( - "SELECT address FROM pubkey_address WHERE account = ? AND chain = ?", - (sqlite3.Binary(account.public_key.address), chain) - ) - - def get_last_address_index(self, account, chain): - return self.query_one_value( - """ - SELECT position FROM pubkey_address - WHERE account = ? AND chain = ? - ORDER BY position DESC LIMIT 1""", - (sqlite3.Binary(account.public_key.address), chain), - default=0 - ) - - def _usable_address_sql(self, account, chain, exclude_used_times): - return """ - SELECT address FROM pubkey_address - WHERE - account = :account AND - chain = :chain AND - used_times <= :exclude_used_times - """, { + def _used_address_sql(self, account, chain, comparison_op, used_times, limit=None): + sql = [ + "SELECT address FROM pubkey_address", + "WHERE account = :account AND" + ] + params = { 'account': sqlite3.Binary(account.public_key.address), - 'chain': chain, - 'exclude_used_times': exclude_used_times + 'used_times': used_times } + if chain is not None: + sql.append("chain = :chain AND") + params['chain'] = chain + sql.append("used_times {} :used_times".format(comparison_op)) + sql.append("ORDER BY used_times ASC") + if limit is not None: + sql.append('LIMIT {}'.format(limit)) + return ' '.join(sql), params - def get_usable_addresses(self, account, chain, exclude_used_times=2): - return self.query_one_value_list(*self._usable_address_sql( - account, chain, exclude_used_times + def get_unused_addresses(self, account, chain): + # type: (torba.baseaccount.BaseAccount, int) -> defer.Deferred[List[str]] + return self.query_one_value_list(*self._used_address_sql( + account, chain, '=', 0 )) - def get_usable_address_count(self, account, chain, exclude_used_times=2): - return self.query_count(*self._usable_address_sql( - account, chain, exclude_used_times + def get_usable_addresses(self, account, chain, max_used_times, limit): + return self.query_one_value_list(*self._used_address_sql( + account, chain, '<=', max_used_times, limit )) - def get_address_history(self, address): - return self.query_one_value( - "SELECT history FROM pubkey_address WHERE address = ?", (sqlite3.Binary(address),) + def get_address(self, address): + return self.query_dict_value( + "SELECT {} FROM pubkey_address WHERE address= :address", + ('address', 'account', 'chain', 'position', 'pubkey', 'history', 'used_times'), + {'address': sqlite3.Binary(address)} ) - def set_address_status(self, address, status): + def set_address_history(self, address, history): return self.db.runOperation( - "replace into address_status (address, status) values (?, ?)", (address,status) + "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", + (sqlite3.Binary(history), history.count(b':')//2, sqlite3.Binary(address)) ) - diff --git a/torba/baseledger.py b/torba/baseledger.py index dcad300db..1acc1c1a1 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -76,7 +76,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): raw_address = self.pubkey_address_prefix + h160 return Base58.encode(bytearray(raw_address + double_sha256(raw_address)[0:4])) - def account_created(self, account): + def account_created(self, account): # type: (baseaccount.BaseAccount) -> None self.accounts.add(account) @staticmethod @@ -94,7 +94,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): @property def path(self): - return os.path.join(self.config['path'], self.get_id()) + return os.path.join(self.config['wallet_path'], self.get_id()) def get_input_output_fee(self, io): """ Fee based on size of the input / output. """ @@ -104,29 +104,17 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): """ Fee for the transaction header and all outputs; without inputs. """ return self.fee_per_byte * tx.base_size - def get_keys(self, account, chain): - return self.db.get_keys(account, chain) - @defer.inlineCallbacks - def add_transaction(self, transaction, height): # type: (basetransaction.BaseTransaction, int) -> None - yield self.db.add_transaction(transaction, height, False, False) + def add_transaction(self, address, transaction, height): + # type: (bytes, basetransaction.BaseTransaction, int) -> None + yield self.db.add_transaction( + address, self.address_to_hash160(address), transaction, height, False, False + ) self._on_transaction_controller.add(transaction) - def has_address(self, address): - return address in self.accounts.addresses - - @defer.inlineCallbacks - def get_least_used_address(self, account, keychain, max_transactions=100): - used_addresses = yield self.db.get_used_addresses(account) - unused_set = set(keychain.addresses) - set(map(itemgetter(0), used_addresses)) - if unused_set: - defer.returnValue(unused_set.pop()) - if used_addresses and used_addresses[0][1] < max_transactions: - defer.returnValue(used_addresses[0][0]) - @defer.inlineCallbacks def get_private_key_for_address(self, address): - match = yield self.db.get_address_details(address) + match = yield self.db.get_address(address) if match: for account in self.accounts: if bytes(match['account']) == account.public_key.address: @@ -148,6 +136,19 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): # if output[1:] not in inputs: # yield output[0] + @defer.inlineCallbacks + def get_local_status(self, address): + address_details = yield self.db.get_address(address) + hash = hashlib.sha256(address_details['history']).digest() + defer.returnValue(hexlify(hash)) + + @defer.inlineCallbacks + def get_local_history(self, address): + address_details = yield self.db.get_address(address) + history = address_details['history'] or b'' + parts = history.split(b':')[:-1] + defer.returnValue(list(zip(parts[0::2], map(int, parts[1::2])))) + @defer.inlineCallbacks def start(self): if not os.path.exists(self.path): @@ -195,62 +196,57 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): ]) @defer.inlineCallbacks - def update_account(self, account): # type: (Account) -> defer.Defferred + def update_account(self, account): # type: (baseaccount.BaseAccount) -> defer.Defferred # Before subscribing, download history for any addresses that don't have any, # this avoids situation where we're getting status updates to addresses we know # need to update anyways. Continue to get history and create more addresses until # all missing addresses are created and history for them is fully restored. - yield account.ensure_enough_addresses() - addresses = yield account.get_unused_addresses(account) + yield account.ensure_address_gap() + addresses = yield account.get_unused_addresses() while addresses: yield defer.DeferredList([ self.update_history(a) for a in addresses ]) - addresses = yield account.ensure_enough_addresses() + addresses = yield account.ensure_address_gap() # By this point all of the addresses should be restored and we # can now subscribe all of them to receive updates. - yield defer.DeferredList([ - self.subscribe_history(address) - for address in account.addresses - ]) - - def _get_status_from_history(self, history): - hashes = [ - '{}:{}:'.format(hash.decode(), height).encode() - for hash, height in map(itemgetter('tx_hash', 'height'), history) - ] - if hashes: - return hexlify(hashlib.sha256(b''.join(hashes)).digest()) + all_addresses = yield account.get_addresses() + yield defer.DeferredList( + list(map(self.subscribe_history, all_addresses)) + ) @defer.inlineCallbacks - def update_history(self, address, remote_status=None): - history = yield self.network.get_history(address) - hashes = list(map(itemgetter('tx_hash'), history)) - for hash, height in map(itemgetter('tx_hash', 'height'), history): + def update_history(self, address): + remote_history = yield self.network.get_history(address) + local = yield self.get_local_history(address) - if not (yield self.db.has_transaction(hash)): - raw = yield self.network.get_transaction(hash) - transaction = self.transaction_class(unhexlify(raw)) - yield self.add_transaction(transaction, height) - if remote_status is None: - remote_status = self._get_status_from_history(history) - if remote_status: - yield self.db.set_address_status(address, remote_status) + history_parts = [] + for i, (hash, height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): + history_parts.append('{}:{}:'.format(hash.decode(), height)) + if i < len(local) and local[i] == (hash, height): + continue + raw = yield self.network.get_transaction(hash) + transaction = self.transaction_class(unhexlify(raw)) + yield self.add_transaction(address, transaction, height) + + yield self.db.set_address_history( + address, ''.join(history_parts).encode() + ) @defer.inlineCallbacks def subscribe_history(self, address): remote_status = yield self.network.subscribe_address(address) - local_status = yield self.db.get_address_status(address) + local_status = yield self.get_local_status(address) if local_status != remote_status: - yield self.update_history(address, remote_status) + yield self.update_history(address) @defer.inlineCallbacks def process_status(self, response): address, remote_status = response - local_status = yield self.db.get_address_status(address) + local_status = yield self.get_local_status(address) if local_status != remote_status: - yield self.update_history(address, remote_status) + yield self.update_history(address) def broadcast(self, tx): return self.network.broadcast(hexlify(tx.raw)) diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 813c4e555..54e46cb7a 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -3,6 +3,8 @@ import logging from typing import List, Iterable, Generator from binascii import hexlify +from twisted.internet import defer + from torba.basescript import BaseInputScript, BaseOutputScript from torba.coinselection import CoinSelector from torba.constants import COIN @@ -20,10 +22,10 @@ NULL_HASH = b'\x00'*32 class InputOutput(object): - def __init__(self, txid): + def __init__(self, txid, index=None): self._txid = txid # type: bytes self.transaction = None # type: BaseTransaction - self.index = None # type: int + self.index = index # type: int @property def txid(self): @@ -53,7 +55,7 @@ class BaseInput(InputOutput): super(BaseInput, self).__init__(txid) if isinstance(output_or_txid_index, BaseOutput): self.output = output_or_txid_index # type: BaseOutput - self.output_txid = self.output.transaction.id + self.output_txid = self.output.txid self.output_index = self.output.index else: self.output = None # type: BaseOutput @@ -127,8 +129,8 @@ class BaseOutput(InputOutput): script_class = BaseOutputScript estimator_class = BaseOutputEffectiveAmountEstimator - def __init__(self, amount, script, txid=None): - super(BaseOutput, self).__init__(txid) + def __init__(self, amount, script, txid=None, index=None): + super(BaseOutput, self).__init__(txid, index) self.amount = amount # type: int self.script = script # type: BaseOutputScript @@ -275,11 +277,15 @@ class BaseTransaction: self.locktime = stream.read_uint32() @classmethod + @defer.inlineCallbacks def get_effective_amount_estimators(cls, funding_accounts): # type: (Iterable[BaseAccount]) -> Generator[BaseOutputEffectiveAmountEstimator] + estimators = [] for account in funding_accounts: - for utxo in account.coin.ledger.get_unspent_outputs(account): - yield utxo.get_estimator(account.coin) + utxos = yield account.ledger.get_unspent_outputs(account) + for utxo in utxos: + estimators.append(utxo.get_estimator(account.ledger)) + defer.returnValue(estimators) @classmethod def ensure_all_have_same_ledger(cls, funding_accounts, change_account=None): @@ -297,15 +303,17 @@ class BaseTransaction: return ledger @classmethod + @defer.inlineCallbacks def pay(cls, outputs, funding_accounts, change_account): + # type: (List[BaseOutput], List[BaseAccount], BaseAccount) -> BaseTransaction """ Efficiently spend utxos from funding_accounts to cover the new outputs. """ tx = cls().add_outputs(outputs) ledger = cls.ensure_all_have_same_ledger(funding_accounts, change_account) amount = ledger.get_transaction_base_fee(tx) + txos = yield cls.get_effective_amount_estimators(funding_accounts) selector = CoinSelector( - list(cls.get_effective_amount_estimators(funding_accounts)), - amount, + txos, amount, ledger.get_input_output_fee( cls.output_class.pay_pubkey_hash(COIN, NULL_HASH) ) @@ -317,14 +325,14 @@ class BaseTransaction: spent_sum = sum(s.effective_amount for s in spendables) if spent_sum > amount: - change_address = change_account.get_least_used_change_address() - change_hash160 = change_account.coin.address_to_hash160(change_address) + change_address = change_account.change.get_or_create_usable_address() + change_hash160 = change_account.ledger.address_to_hash160(change_address) change_amount = spent_sum - amount tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) tx.add_inputs([s.txi for s in spendables]) tx.sign(funding_accounts) - return tx + defer.returnValue(tx) @classmethod def liquidate(cls, assets, funding_accounts, change_account): diff --git a/torba/coin/bitcoincash.py b/torba/coin/bitcoincash.py index f416ced41..1830f9cdb 100644 --- a/torba/coin/bitcoincash.py +++ b/torba/coin/bitcoincash.py @@ -1,6 +1,6 @@ -__coin__ = 'BitcoinCash' __node_daemon__ = 'bitcoind' __node_cli__ = 'bitcoin-cli' +__node_bin__ = 'bitcoin-abc-0.17.2/bin' __node_url__ = ( 'https://download.bitcoinabc.org/0.17.2/linux/bitcoin-abc-0.17.2-x86_64-linux-gnu.tar.gz' ) @@ -11,7 +11,6 @@ from torba.baseledger import BaseLedger, BaseHeaders from torba.basenetwork import BaseNetwork from torba.basescript import BaseInputScript, BaseOutputScript from torba.basetransaction import BaseTransaction, BaseInput, BaseOutput -from torba.basecoin import BaseCoin from torba.basedatabase import BaseSQLiteWalletStorage from torba.manager import BaseWalletManager diff --git a/torba/coin/bitcoinsegwit.py b/torba/coin/bitcoinsegwit.py index d38cc71c2..6739d87f2 100644 --- a/torba/coin/bitcoinsegwit.py +++ b/torba/coin/bitcoinsegwit.py @@ -1,6 +1,6 @@ -__coin__ = 'BitcoinSegwit' __node_daemon__ = 'bitcoind' __node_cli__ = 'bitcoin-cli' +__node_bin__ = 'bitcoin-0.16.0/bin' __node_url__ = ( 'https://bitcoin.org/bin/bitcoin-core-0.16.0/bitcoin-0.16.0-x86_64-linux-gnu.tar.gz' ) @@ -29,10 +29,15 @@ class UnverifiedHeaders(BaseHeaders): class RegTestLedger(MainNetLedger): - network_name = 'regtest' headers_class = UnverifiedHeaders + network_name = 'regtest' + + pubkey_address_prefix = int2byte(111) + script_address_prefix = int2byte(196) + extended_public_key_prefix = unhexlify('043587cf') + extended_private_key_prefix = unhexlify('04358394') + max_target = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff genesis_hash = '0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206' genesis_bits = 0x207fffff target_timespan = 1 - verify_bits_to_target = False diff --git a/torba/manager.py b/torba/manager.py index 31b5ab107..104200352 100644 --- a/torba/manager.py +++ b/torba/manager.py @@ -2,8 +2,7 @@ import functools from typing import List, Dict, Type from twisted.internet import defer -from torba.baseaccount import AccountsView -from torba.baseledger import BaseLedger +from torba.baseledger import BaseLedger, LedgerRegistry from torba.basetransaction import BaseTransaction, NULL_HASH from torba.coinselection import CoinSelector from torba.constants import COIN @@ -29,9 +28,8 @@ class WalletManager(object): wallets.append(wallet) return manager - def get_or_create_ledger(self, coin_id, ledger_config=None): - coin_class = CoinRegistry.get_coin_class(coin_id) - ledger_class = coin_class.ledger_class + def get_or_create_ledger(self, ledger_id, ledger_config=None): + ledger_class = LedgerRegistry.get_ledger_class(ledger_id) ledger = self.ledgers.get(ledger_class) if ledger is None: ledger = self.create_ledger(ledger_class, ledger_config or {}) @@ -100,17 +98,16 @@ class WalletManager(object): amount = int(amount * COIN) account = self.default_account - coin = account.coin - ledger = coin.ledger + ledger = account.ledger tx_class = ledger.transaction_class # type: BaseTransaction in_class, out_class = tx_class.input_class, tx_class.output_class estimators = [ - txo.get_estimator(coin) for txo in account.get_unspent_utxos() + txo.get_estimator(ledger) for txo in account.get_unspent_utxos() ] tx_class.create() - cost_of_output = coin.get_input_output_fee( + cost_of_output = ledger.get_input_output_fee( out_class.pay_pubkey_hash(COIN, NULL_HASH) ) From 99ae39012f26ffd263d48557c7a6845686bd3cf1 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 12 Jun 2018 10:04:11 -0400 Subject: [PATCH 014/383] tests/__init__.py --- tests/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 tests/__init__.py diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 000000000..e69de29bb From e9fbc875e08bc379c8b71cc9e0b21e2039583ee0 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 13 Jun 2018 20:57:57 -0400 Subject: [PATCH 015/383] passing tests --- .travis.yml | 6 +- tests/__init__.py | 0 tests/integration/test_transactions.py | 17 ++--- tests/unit/test_account.py | 4 +- tests/unit/test_coinselection.py | 22 +++--- tests/unit/test_ledger.py | 8 ++- tests/unit/test_transaction.py | 94 +++++++++++++------------- tests/unit/test_wallet.py | 72 +++++--------------- torba/baseaccount.py | 6 +- torba/basedatabase.py | 62 +++++++++++------ torba/baseledger.py | 26 +++---- torba/basenetwork.py | 2 +- torba/basetransaction.py | 79 +++++++++++----------- torba/coin/bitcoincash.py | 71 ++++++------------- torba/coin/bitcoinsegwit.py | 1 + torba/hash.py | 3 + torba/wallet.py | 39 +++-------- tox.ini | 12 ++-- 18 files changed, 231 insertions(+), 293 deletions(-) delete mode 100644 tests/__init__.py diff --git a/.travis.yml b/.travis.yml index e37918195..bdd37d199 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,7 +4,11 @@ python: - "2.7" - "3.6" -install: pip install tox-travis coverage +install: + - pip install tox-travis coverage + - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch packages && popd + - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd + script: tox after_success: diff --git a/tests/__init__.py b/tests/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 9cf9327aa..4de043124 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -17,22 +17,23 @@ class BasicTransactionTests(IntegrationTestCase): address = await account1.receiving.get_or_create_usable_address().asFuture(asyncio.get_event_loop()) sendtxid = await self.blockchain.send_to_address(address.decode(), 5.5) - await self.on_transaction(sendtxid) + await self.on_transaction(sendtxid) #mempool await self.blockchain.generate(1) - await asyncio.sleep(5) + await self.on_transaction(sendtxid) #confirmed self.assertEqual(await self.get_balance(account1), int(5.5*COIN)) self.assertEqual(await self.get_balance(account2), 0) address = await account2.receiving.get_or_create_usable_address().asFuture(asyncio.get_event_loop()) tx = await self.ledger.transaction_class.pay( - [self.ledger.transaction_class.output_class.pay_pubkey_hash(2, self.ledger.address_to_hash160(address))], + [self.ledger.transaction_class.output_class.pay_pubkey_hash(2*COIN, self.ledger.address_to_hash160(address))], [account1], account1 ).asFuture(asyncio.get_event_loop()) + await self.blockchain.decode_raw_transaction(tx) await self.broadcast(tx) - await self.on_transaction(tx.id.decode()) - await self.lbrycrd.generate(1) - - self.assertEqual(await self.get_balance(account1), int(3.5*COIN)) - self.assertEqual(await self.get_balance(account2), int(2.0*COIN)) + await self.on_transaction(tx.hex_id.decode()) #mempool + await self.blockchain.generate(1) + await self.on_transaction(tx.hex_id.decode()) #confirmed + self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 3.5) + self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index 393def1d4..c62e9fcaf 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -41,13 +41,13 @@ class TestKeyChain(unittest.TestCase): # case #2: only one new addressed needed keys = yield account.receiving.get_addresses(None, True) - yield self.ledger.db.set_address_history(keys[19]['address'], 'a:1:') + yield self.ledger.db.set_address_history(keys[19]['address'], b'a:1:') new_keys = yield account.receiving.ensure_address_gap() self.assertEqual(len(new_keys), 1) # case #3: 20 addresses needed keys = yield account.receiving.get_addresses(None, True) - yield self.ledger.db.set_address_history(keys[0]['address'], 'a:1:') + yield self.ledger.db.set_address_history(keys[0]['address'], b'a:1:') new_keys = yield account.receiving.ensure_address_gap() self.assertEqual(len(new_keys), 20) diff --git a/tests/unit/test_coinselection.py b/tests/unit/test_coinselection.py index 2e07ee73a..c6f8582db 100644 --- a/tests/unit/test_coinselection.py +++ b/tests/unit/test_coinselection.py @@ -1,11 +1,11 @@ -import unittest +from twisted.trial import unittest +from types import GeneratorType from torba.coin.bitcoinsegwit import MainNetLedger from torba.coinselection import CoinSelector, MAXIMUM_TRIES from torba.constants import CENT -from torba.manager import WalletManager -from .test_transaction import Output, get_output as utxo +from .test_transaction import get_output as utxo NULL_HASH = b'\x00'*32 @@ -13,7 +13,7 @@ NULL_HASH = b'\x00'*32 def search(*args, **kwargs): selection = CoinSelector(*args, **kwargs).branch_and_bound() - return [o.output.amount for o in selection] if selection else selection + return [o.txo.amount for o in selection] if selection else selection class BaseSelectionTestCase(unittest.TestCase): @@ -23,7 +23,7 @@ class BaseSelectionTestCase(unittest.TestCase): return self.ledger.db.start() def estimates(self, *args): - txos = args if isinstance(args[0], Output) else args[0] + txos = args[0] if isinstance(args[0], (GeneratorType, list)) else args return [txo.get_estimator(self.ledger) for txo in txos] @@ -44,7 +44,7 @@ class TestCoinSelectionTests(BaseSelectionTestCase): self.assertEqual(selector.tries, 201) def test_exact_match(self): - fee = utxo(CENT).get_estimator(self.coin).fee + fee = utxo(CENT).get_estimator(self.ledger).fee utxo_pool = self.estimates( utxo(CENT + fee), utxo(CENT), @@ -52,7 +52,7 @@ class TestCoinSelectionTests(BaseSelectionTestCase): ) selector = CoinSelector(utxo_pool, CENT, 0) match = selector.select() - self.assertEqual([CENT + fee], [c.output.amount for c in match]) + self.assertEqual([CENT + fee], [c.txo.amount for c in match]) self.assertTrue(selector.exact_match) def test_random_draw(self): @@ -63,7 +63,7 @@ class TestCoinSelectionTests(BaseSelectionTestCase): ) selector = CoinSelector(utxo_pool, CENT, 0, '\x00') match = selector.select() - self.assertEqual([2 * CENT], [c.output.amount for c in match]) + self.assertEqual([2 * CENT], [c.txo.amount for c in match]) self.assertFalse(selector.exact_match) @@ -78,10 +78,6 @@ class TestOfficialBitcoinCoinSelectionTests(BaseSelectionTestCase): # Branch and Bound coin selection white paper: # https://murch.one/wp-content/uploads/2016/11/erhardt2016coinselection.pdf - def setUp(self): - ledger = WalletManager().get_or_create_ledger(BTC.get_id()) - self.coin = BTC(ledger, 0) - def make_hard_case(self, utxos): target = 0 utxo_pool = [] @@ -93,6 +89,8 @@ class TestOfficialBitcoinCoinSelectionTests(BaseSelectionTestCase): return self.estimates(utxo_pool), target def test_branch_and_bound_coin_selection(self): + self.ledger.fee_per_byte = 0 + utxo_pool = self.estimates( utxo(1 * CENT), utxo(2 * CENT), diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index eb281888a..0a354648d 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -1,3 +1,4 @@ +import six from binascii import hexlify from twisted.trial import unittest from twisted.internet import defer @@ -6,6 +7,9 @@ from torba.coin.bitcoinsegwit import MainNetLedger from .test_transaction import get_transaction +if six.PY3: + buffer = memoryview + class MockNetwork: @@ -53,7 +57,7 @@ class TestSynchronization(unittest.TestCase): self.assertEqual(self.ledger.network.get_transaction_called, [b'abc', b'def', b'ghi']) address_details = yield self.ledger.db.get_address(address) - self.assertEqual(address_details['history'], b'abc:1:def:2:ghi:3:') + self.assertEqual(address_details['history'], buffer(b'abc:1:def:2:ghi:3:')) self.ledger.network.get_history_called = [] self.ledger.network.get_transaction_called = [] @@ -69,4 +73,4 @@ class TestSynchronization(unittest.TestCase): self.assertEqual(self.ledger.network.get_history_called, [address]) self.assertEqual(self.ledger.network.get_transaction_called, [b'jkl']) address_details = yield self.ledger.db.get_address(address) - self.assertEqual(address_details['history'], b'abc:1:def:2:ghi:3:jkl:4:') + self.assertEqual(address_details['history'], buffer(b'abc:1:def:2:ghi:3:jkl:4:')) diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index 319658714..afb2b0da7 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -1,8 +1,8 @@ from binascii import hexlify, unhexlify from twisted.trial import unittest +from twisted.internet import defer -from torba.basetransaction import BaseTransaction, BaseInput, BaseOutput -from torba.coin.bitcoinsegwit import MainNetLedger +from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class from torba.constants import CENT, COIN from torba.manager import WalletManager from torba.wallet import Wallet @@ -14,30 +14,26 @@ FEE_PER_CHAR = 200000 def get_output(amount=CENT, pubkey_hash=NULL_HASH): - return BaseTransaction() \ - .add_outputs([BaseTransaction.output_class.pay_pubkey_hash(amount, pubkey_hash)]) \ + return ledger_class.transaction_class() \ + .add_outputs([ledger_class.transaction_class.output_class.pay_pubkey_hash(amount, pubkey_hash)]) \ .outputs[0] def get_input(): - return BaseInput.spend(get_output()) + return ledger_class.transaction_class.input_class.spend(get_output()) def get_transaction(txo=None): - return BaseTransaction() \ + return ledger_class.transaction_class() \ .add_inputs([get_input()]) \ - .add_outputs([txo or BaseOutput.pay_pubkey_hash(CENT, NULL_HASH)]) - - -def get_wallet_and_ledger(): - ledger = WalletManager().get_or_create_ledger(MainNetLedger.get_id()) - return Wallet('Main', [ledger], [ledger.account_class.generate(ledger, u'torba')]), ledger + .add_outputs([txo or ledger_class.transaction_class.output_class.pay_pubkey_hash(CENT, NULL_HASH)]) class TestSizeAndFeeEstimation(unittest.TestCase): def setUp(self): - self.wallet, self.ledger = get_wallet_and_ledger() + self.ledger = ledger_class(db=':memory:') + return self.ledger.db.start() def io_fee(self, io): return self.ledger.get_input_output_fee(io) @@ -70,20 +66,20 @@ class TestTransactionSerialization(unittest.TestCase): '000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4c' 'ef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000' ) - tx = BaseTransaction(raw) + tx = ledger_class.transaction_class(raw) self.assertEqual(tx.version, 1) self.assertEqual(tx.locktime, 0) self.assertEqual(len(tx.inputs), 1) self.assertEqual(len(tx.outputs), 1) - ledgerbase = tx.inputs[0] - self.assertEqual(ledgerbase.output_txid, NULL_HASH) - self.assertEqual(ledgerbase.output_index, 0xFFFFFFFF) - self.assertEqual(ledgerbase.sequence, 4294967295) - self.assertTrue(ledgerbase.is_ledgerbase) - self.assertEqual(ledgerbase.script, None) + coinbase = tx.inputs[0] + self.assertEqual(coinbase.output_txhash, NULL_HASH) + self.assertEqual(coinbase.output_index, 0xFFFFFFFF) + self.assertEqual(coinbase.sequence, 4294967295) + self.assertTrue(coinbase.is_coinbase) + self.assertEqual(coinbase.script, None) self.assertEqual( - ledgerbase.ledgerbase[8:], + coinbase.coinbase[8:], b'The Times 03/Jan/2009 Chancellor on brink of second bailout for banks' ) @@ -97,7 +93,7 @@ class TestTransactionSerialization(unittest.TestCase): tx._reset() self.assertEqual(tx.raw, raw) - def test_ledgerbase_transaction(self): + def test_coinbase_transaction(self): raw = unhexlify( '01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4e03' '1f5a070473319e592f4254432e434f4d2f4e59412ffabe6d6dcceb2a9d0444c51cabc4ee97a1a000036ca0' @@ -105,20 +101,20 @@ class TestTransactionSerialization(unittest.TestCase): '0000000017a914e083685a1097ce1ea9e91987ab9e94eae33d8a13870000000000000000266a24aa21a9ed' 'e6c99265a6b9e1d36c962fda0516b35709c49dc3b8176fa7e5d5f1f6197884b400000000' ) - tx = BaseTransaction(raw) + tx = ledger_class.transaction_class(raw) self.assertEqual(tx.version, 1) self.assertEqual(tx.locktime, 0) self.assertEqual(len(tx.inputs), 1) self.assertEqual(len(tx.outputs), 2) - ledgerbase = tx.inputs[0] - self.assertEqual(ledgerbase.output_txid, NULL_HASH) - self.assertEqual(ledgerbase.output_index, 0xFFFFFFFF) - self.assertEqual(ledgerbase.sequence, 4294967295) - self.assertTrue(ledgerbase.is_ledgerbase) - self.assertEqual(ledgerbase.script, None) + coinbase = tx.inputs[0] + self.assertEqual(coinbase.output_txhash, NULL_HASH) + self.assertEqual(coinbase.output_index, 0xFFFFFFFF) + self.assertEqual(coinbase.sequence, 4294967295) + self.assertTrue(coinbase.is_coinbase) + self.assertEqual(coinbase.script, None) self.assertEqual( - ledgerbase.ledgerbase[9:22], + coinbase.coinbase[9:22], b'/BTC.COM/NYA/' ) @@ -148,26 +144,32 @@ class TestTransactionSerialization(unittest.TestCase): class TestTransactionSigning(unittest.TestCase): + def setUp(self): + self.ledger = ledger_class(db=':memory:') + return self.ledger.db.start() + + @defer.inlineCallbacks def test_sign(self): - ledger = WalletManager().get_or_create_ledger(BTC.get_id()) - ledger = BTC(ledger) - wallet = Wallet('Main', [ledger], [Account.from_seed( - ledger, u'carbon smart garage balance margin twelve chest sword toast envelope bottom stom' - u'ach absent', u'torba' - )]) - account = wallet.default_account + account = self.ledger.account_class.from_seed( + self.ledger, + u"carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" + u"sent", u"torba" + ) - address1 = account.receiving_keys.generate_next_address() - address2 = account.receiving_keys.generate_next_address() - pubkey_hash1 = account.ledger.address_to_hash160(address1) - pubkey_hash2 = account.ledger.address_to_hash160(address2) + yield account.ensure_address_gap() + address1 = (yield account.receiving.get_addresses())[0] + address2 = (yield account.receiving.get_addresses())[0] + pubkey_hash1 = self.ledger.address_to_hash160(address1) + pubkey_hash2 = self.ledger.address_to_hash160(address2) - tx = Transaction() \ - .add_inputs([Input.spend(get_output(2*COIN, pubkey_hash1))]) \ - .add_outputs([Output.pay_pubkey_hash(int(1.9*COIN), pubkey_hash2)]) \ - .sign(account) + tx = ledger_class.transaction_class() \ + .add_inputs([ledger_class.transaction_class.input_class.spend(get_output(2*COIN, pubkey_hash1))]) \ + .add_outputs([ledger_class.transaction_class.output_class.pay_pubkey_hash(int(1.9*COIN), pubkey_hash2)]) \ + + yield tx.sign([account]) self.assertEqual( hexlify(tx.inputs[0].script.values['signature']), - b'304402203d463519290d06891e461ea5256c56097ccdad53379b1bb4e51ec5abc6e9fd02022034ed15b9d7c678716c4aa7c0fd26c688e8f9db8075838f2839ab55d551b62c0a01' + b'3044022064cd6b95c9e0084253c10dd56bcec2bfd816c29aad05fbea490511d79540462b02201aa9d6f73' + b'48bb0c76b28d1ad87cf4ffd51cf4de0b299af8bf0ecad70e3369ef201' ) diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index 63314303e..86521fdd5 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -1,75 +1,50 @@ from twisted.trial import unittest -from torba.coin.bitcoinsegwit import BTC +from torba.coin.bitcoinsegwit import MainNetLedger as BTCLedger +from torba.coin.bitcoincash import MainNetLedger as BCHLedger from torba.manager import WalletManager -from torba.wallet import Account, Wallet, WalletStorage - -from .ftc import FTC +from torba.wallet import Wallet, WalletStorage class TestWalletCreation(unittest.TestCase): def setUp(self): self.manager = WalletManager() - self.btc_ledger = self.manager.get_or_create_ledger(BTC.get_id()) - self.ftc_ledger = self.manager.get_or_create_ledger(FTC.get_id()) + config = {'wallet_path': '/tmp/wallet'} + self.btc_ledger = self.manager.get_or_create_ledger(BTCLedger.get_id(), config) + self.bch_ledger = self.manager.get_or_create_ledger(BCHLedger.get_id(), config) def test_create_wallet_and_accounts(self): wallet = Wallet() self.assertEqual(wallet.name, 'Wallet') - self.assertEqual(wallet.coins, []) self.assertEqual(wallet.accounts, []) account1 = wallet.generate_account(self.btc_ledger) - account2 = wallet.generate_account(self.btc_ledger) - account3 = wallet.generate_account(self.ftc_ledger) + wallet.generate_account(self.btc_ledger) + wallet.generate_account(self.bch_ledger) self.assertEqual(wallet.default_account, account1) - self.assertEqual(len(wallet.coins), 2) self.assertEqual(len(wallet.accounts), 3) - self.assertIsInstance(wallet.coins[0], BTC) - self.assertIsInstance(wallet.coins[1], FTC) - - self.assertEqual(len(account1.receiving_keys.addresses), 0) - self.assertEqual(len(account1.change_keys.addresses), 0) - self.assertEqual(len(account2.receiving_keys.addresses), 0) - self.assertEqual(len(account2.change_keys.addresses), 0) - self.assertEqual(len(account3.receiving_keys.addresses), 0) - self.assertEqual(len(account3.change_keys.addresses), 0) - account1.ensure_enough_addresses() - account2.ensure_enough_addresses() - account3.ensure_enough_addresses() - self.assertEqual(len(account1.receiving_keys.addresses), 20) - self.assertEqual(len(account1.change_keys.addresses), 6) - self.assertEqual(len(account2.receiving_keys.addresses), 20) - self.assertEqual(len(account2.change_keys.addresses), 6) - self.assertEqual(len(account3.receiving_keys.addresses), 20) - self.assertEqual(len(account3.change_keys.addresses), 6) def test_load_and_save_wallet(self): wallet_dict = { 'name': 'Main Wallet', 'accounts': [ { - 'coin': 'btc_mainnet', + 'ledger': 'btc_mainnet', 'seed': "carbon smart garage balance margin twelve chest sword toast envelope bottom stomac" "h absent", 'encrypted': False, 'private_key': - 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - '6yz3jMbycrLrRMpeAJxR8qDg8', + b'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + b'6yz3jMbycrLrRMpeAJxR8qDg8', 'public_key': - 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' - 'iW44g14WF52fYC5J483wqQ5ZP', + b'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' + b'iW44g14WF52fYC5J483wqQ5ZP', 'receiving_gap': 10, - 'receiving_keys': [ - '0222345947a59dca4a3363ffa81ac87dd907d2b2feff57383eaeddbab266ca5f2d', - '03fdc9826d5d00a484188cba8eb7dba5877c0323acb77905b7bcbbab35d94be9f6' - ], + 'receiving_maximum_use_per_address': 2, 'change_gap': 10, - 'change_keys': [ - '038836be4147836ed6b4df6a89e0d9f1b1c11cec529b7ff5407de57f2e5b032c83' - ] + 'change_maximum_use_per_address': 2, } ] } @@ -77,21 +52,8 @@ class TestWalletCreation(unittest.TestCase): storage = WalletStorage(default=wallet_dict) wallet = Wallet.from_storage(storage, self.manager) self.assertEqual(wallet.name, 'Main Wallet') - self.assertEqual(len(wallet.coins), 1) - self.assertIsInstance(wallet.coins[0], BTC) self.assertEqual(len(wallet.accounts), 1) account = wallet.default_account - self.assertIsInstance(account, Account) - - self.assertEqual(len(account.receiving_keys.addresses), 2) - self.assertEqual( - account.receiving_keys.addresses[0], - b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP' - ) - self.assertEqual(len(account.change_keys.addresses), 1) - self.assertEqual( - account.change_keys.addresses[0], - b'1PUbu1D1f3c244JPRSJKBCxRqui5NT6geR' - ) - wallet_dict['coins'] = {'btc_mainnet': {'fee_per_byte': 50}} + self.assertIsInstance(account, BTCLedger.account_class) + self.maxDiff = None self.assertDictEqual(wallet_dict, wallet.to_dict()) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 194f287ba..f753732df 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -59,9 +59,9 @@ class KeyChain: def get_or_create_usable_address(self): addresses = yield self.get_usable_addresses(1) if addresses: - return addresses[0] + defer.returnValue(addresses[0]) addresses = yield self.ensure_address_gap() - return addresses[0] + defer.returnValue(addresses[0]) class BaseAccount: @@ -83,7 +83,7 @@ class BaseAccount: KeyChain(self, public_key, 0, receiving_gap, receiving_maximum_use_per_address), KeyChain(self, public_key, 1, change_gap, change_maximum_use_per_address) ) - ledger.account_created(self) + ledger.add_account(self) @classmethod def generate(cls, ledger, password): # type: (torba.baseledger.BaseLedger, str) -> BaseAccount diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 5f7d4f2a6..378fbdea3 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -1,5 +1,6 @@ import logging from typing import List, Union +from operator import itemgetter import sqlite3 from twisted.internet import defer @@ -97,11 +98,10 @@ class BaseDatabase(SQLiteMixin): CREATE_TX_TABLE = """ create table if not exists tx ( - txid blob primary key, + txhash blob primary key, raw blob not null, height integer not null, - is_confirmed boolean not null, - is_verified boolean not null + is_verified boolean not null default false ); """ @@ -113,14 +113,14 @@ class BaseDatabase(SQLiteMixin): position integer not null, pubkey blob not null, history text, - used_times integer default 0 + used_times integer not null default 0 ); """ CREATE_TXO_TABLE = """ create table if not exists txo ( txoid integer primary key, - txid blob references tx, + txhash blob references tx, address blob references pubkey_address, position integer not null, amount integer not null, @@ -130,7 +130,7 @@ class BaseDatabase(SQLiteMixin): CREATE_TXI_TABLE = """ create table if not exists txi ( - txid blob references tx, + txhash blob references tx, address blob references pubkey_address, txoid integer references txo ); @@ -143,20 +143,33 @@ class BaseDatabase(SQLiteMixin): CREATE_TXI_TABLE ) - def add_transaction(self, address, hash, tx, height, is_confirmed, is_verified): + def add_transaction(self, address, hash, tx, height, is_verified): def _steps(t): - if not t.execute("SELECT 1 FROM tx WHERE txid=?", (sqlite3.Binary(tx.id),)).fetchone(): + current_height = t.execute("SELECT height FROM tx WHERE txhash=?", (sqlite3.Binary(tx.hash),)).fetchone() + if current_height is None: t.execute(*self._insert_sql('tx', { - 'txid': sqlite3.Binary(tx.id), + 'txhash': sqlite3.Binary(tx.hash), 'raw': sqlite3.Binary(tx.raw), 'height': height, - 'is_confirmed': is_confirmed, 'is_verified': is_verified })) + elif current_height[0] != height: + t.execute("UPDATE tx SET height = :height WHERE txhash = :txhash", { + 'txhash': sqlite3.Binary(tx.hash), + 'height': height, + }) + + existing_txos = list(map(itemgetter(0), t.execute( + "SELECT position FROM txo WHERE txhash = ?", + (sqlite3.Binary(tx.hash),) + ).fetchall())) + for txo in tx.outputs: + if txo.index in existing_txos: + continue if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == hash: t.execute(*self._insert_sql("txo", { - 'txid': sqlite3.Binary(tx.id), + 'txhash': sqlite3.Binary(tx.hash), 'address': sqlite3.Binary(address), 'position': txo.index, 'amount': txo.amount, @@ -166,24 +179,33 @@ class BaseDatabase(SQLiteMixin): # TODO: implement script hash payments print('Database.add_transaction pay script hash is not implemented!') + existing_txis = [txi[0] for txi in t.execute( + "SELECT txoid FROM txi WHERE txhash = ? AND address = ?", + (sqlite3.Binary(tx.hash), sqlite3.Binary(address))).fetchall()] + for txi in tx.inputs: txoid = t.execute( - "SELECT txoid, address FROM txo WHERE txid = ? AND position = ?", - (sqlite3.Binary(txi.output_txid), txi.output_index) + "SELECT txoid FROM txo WHERE txhash = ? AND position = ?", + (sqlite3.Binary(txi.output_txhash), txi.output_index) ).fetchone() - if txoid: + if txoid is not None and txoid[0] not in existing_txis: t.execute(*self._insert_sql("txi", { - 'txid': sqlite3.Binary(tx.id), + 'txhash': sqlite3.Binary(tx.hash), 'address': sqlite3.Binary(address), - 'txoid': txoid, + 'txoid': txoid[0], })) + return self.db.runInteraction(_steps) @defer.inlineCallbacks def get_balance_for_account(self, account): result = yield self.db.runQuery( - "SELECT SUM(amount) FROM txo NATURAL JOIN pubkey_address WHERE account=:account AND " - "txoid NOT IN (SELECT txoid FROM txi)", + """ + SELECT SUM(amount) FROM txo + JOIN pubkey_address ON pubkey_address.address=txo.address + WHERE account=:account AND + txoid NOT IN (SELECT txoid FROM txi) + """, {'account': sqlite3.Binary(account.public_key.address)} ) if result: @@ -195,8 +217,8 @@ class BaseDatabase(SQLiteMixin): def get_utxos(self, account, output_class): utxos = yield self.db.runQuery( """ - SELECT amount, script, txid, position - FROM txo NATURAL JOIN pubkey_address + SELECT amount, script, txhash, txo.position + FROM txo JOIN pubkey_address ON pubkey_address.address=txo.address WHERE account=:account AND txoid NOT IN (SELECT txoid FROM txi) """, {'account': sqlite3.Binary(account.public_key.address)} diff --git a/torba/baseledger.py b/torba/baseledger.py index 1acc1c1a1..8c28d70bc 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -76,9 +76,6 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): raw_address = self.pubkey_address_prefix + h160 return Base58.encode(bytearray(raw_address + double_sha256(raw_address)[0:4])) - def account_created(self, account): # type: (baseaccount.BaseAccount) -> None - self.accounts.add(account) - @staticmethod def address_to_hash160(address): bytes = Base58.decode(address) @@ -108,10 +105,16 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): def add_transaction(self, address, transaction, height): # type: (bytes, basetransaction.BaseTransaction, int) -> None yield self.db.add_transaction( - address, self.address_to_hash160(address), transaction, height, False, False + address, self.address_to_hash160(address), transaction, height, False ) self._on_transaction_controller.add(transaction) + @defer.inlineCallbacks + def add_account(self, account): # type: (baseaccount.BaseAccount) -> None + self.accounts.add(account) + if self.network.is_connected: + yield self.update_account(account) + @defer.inlineCallbacks def get_private_key_for_address(self, address): match = yield self.db.get_address(address) @@ -123,19 +126,6 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): def get_unspent_outputs(self, account): return self.db.get_utxos(account, self.transaction_class.output_class) -# def get_unspent_outputs(self, account): -# inputs, outputs, utxos = set(), set(), set() -# for address in self.addresses.values(): -# for tx in address: -# for txi in tx.inputs: -# inputs.add((hexlify(txi.output_txid), txi.output_index)) -# for txo in tx.outputs: -# if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == address.pubkey_hash: -# outputs.add((txo, txo.transaction.id, txo.index)) -# for output in outputs: -# if output[1:] not in inputs: -# yield output[0] - @defer.inlineCallbacks def get_local_status(self, address): address_details = yield self.db.get_address(address) @@ -146,6 +136,8 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): def get_local_history(self, address): address_details = yield self.db.get_address(address) history = address_details['history'] or b'' + if six.PY2: + history = str(history) parts = history.split(b':')[:-1] defer.returnValue(list(zip(parts[0::2], map(int, parts[1::2])))) diff --git a/torba/basenetwork.py b/torba/basenetwork.py index 2b16ee767..509eea87f 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -95,7 +95,7 @@ class StratumClientProtocol(LineOnlyReceiver): try: d = self.lookup_table.pop(message['id']) if message.get('error'): - d.errback(RuntimeError(*message['error'])) + d.errback(RuntimeError(message['error'])) else: d.callback(message.get('result')) except KeyError: diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 54e46cb7a..91e43efa4 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -5,12 +5,13 @@ from binascii import hexlify from twisted.internet import defer +import torba.baseaccount +import torba.baseledger from torba.basescript import BaseInputScript, BaseOutputScript from torba.coinselection import CoinSelector from torba.constants import COIN from torba.bcd_data_stream import BCDataStream from torba.hash import sha256 -from torba.baseaccount import BaseAccount from torba.util import ReadOnlyList @@ -22,16 +23,16 @@ NULL_HASH = b'\x00'*32 class InputOutput(object): - def __init__(self, txid, index=None): - self._txid = txid # type: bytes + def __init__(self, txhash, index=None): + self._txhash = txhash # type: bytes self.transaction = None # type: BaseTransaction self.index = index # type: int @property - def txid(self): - if self._txid is None: - self._txid = self.transaction.id - return self._txid + def txhash(self): + if self._txhash is None: + self._txhash = self.transaction.hash + return self._txhash @property def size(self): @@ -51,26 +52,20 @@ class BaseInput(InputOutput): NULL_SIGNATURE = b'\x00'*72 NULL_PUBLIC_KEY = b'\x00'*33 - def __init__(self, output_or_txid_index, script, sequence=0xFFFFFFFF, txid=None): - super(BaseInput, self).__init__(txid) - if isinstance(output_or_txid_index, BaseOutput): - self.output = output_or_txid_index # type: BaseOutput - self.output_txid = self.output.txid + def __init__(self, output_or_txhash_index, script, sequence=0xFFFFFFFF, txhash=None): + super(BaseInput, self).__init__(txhash) + if isinstance(output_or_txhash_index, BaseOutput): + self.output = output_or_txhash_index # type: BaseOutput + self.output_txhash = self.output.txhash self.output_index = self.output.index else: self.output = None # type: BaseOutput - self.output_txid, self.output_index = output_or_txid_index + self.output_txhash, self.output_index = output_or_txhash_index self.sequence = sequence - self.is_coinbase = self.output_txid == NULL_HASH + self.is_coinbase = self.output_txhash == NULL_HASH self.coinbase = script if self.is_coinbase else None self.script = script if not self.is_coinbase else None # type: BaseInputScript - def link_output(self, output): - assert self.output is None - assert self.output_txid == output.transaction.id - assert self.output_index == output.index - self.output = output - @classmethod def spend(cls, output): """ Create an input to spend the output.""" @@ -87,18 +82,18 @@ class BaseInput(InputOutput): @classmethod def deserialize_from(cls, stream): - txid = stream.read(32) + txhash = stream.read(32) index = stream.read_uint32() script = stream.read_string() sequence = stream.read_uint32() return cls( - (txid, index), - cls.script_class(script) if not txid == NULL_HASH else script, + (txhash, index), + cls.script_class(script) if not txhash == NULL_HASH else script, sequence ) def serialize_to(self, stream, alternate_script=None): - stream.write(self.output_txid) + stream.write(self.output_txhash) stream.write_uint32(self.output_index) if alternate_script is not None: stream.write_string(alternate_script) @@ -114,7 +109,7 @@ class BaseOutputEffectiveAmountEstimator(object): __slots__ = 'coin', 'txi', 'txo', 'fee', 'effective_amount' - def __init__(self, ledger, txo): # type: (BaseLedger, BaseOutput) -> None + def __init__(self, ledger, txo): # type: (torba.baseledger.BaseLedger, BaseOutput) -> None self.txo = txo self.txi = ledger.transaction_class.input_class.spend(txo) self.fee = ledger.get_input_output_fee(self.txi) @@ -129,8 +124,8 @@ class BaseOutput(InputOutput): script_class = BaseOutputScript estimator_class = BaseOutputEffectiveAmountEstimator - def __init__(self, amount, script, txid=None, index=None): - super(BaseOutput, self).__init__(txid, index) + def __init__(self, amount, script, txhash=None, index=None): + super(BaseOutput, self).__init__(txhash, index) self.amount = amount # type: int self.script = script # type: BaseOutputScript @@ -259,7 +254,7 @@ class BaseTransaction: for txout in self._outputs: txout.serialize_to(stream) stream.write_uint32(self.locktime) - stream.write_uint32(1) # signature hash type: SIGHASH_ALL + stream.write_uint32(self.signature_hash_type(1)) # signature hash type: SIGHASH_ALL return stream.get_bytes() def _deserialize(self): @@ -279,7 +274,7 @@ class BaseTransaction: @classmethod @defer.inlineCallbacks def get_effective_amount_estimators(cls, funding_accounts): - # type: (Iterable[BaseAccount]) -> Generator[BaseOutputEffectiveAmountEstimator] + # type: (Iterable[torba.baseaccount.BaseAccount]) -> Generator[BaseOutputEffectiveAmountEstimator] estimators = [] for account in funding_accounts: utxos = yield account.ledger.get_unspent_outputs(account) @@ -289,7 +284,7 @@ class BaseTransaction: @classmethod def ensure_all_have_same_ledger(cls, funding_accounts, change_account=None): - # type: (Iterable[BaseAccount], BaseAccount) -> baseledger.BaseLedger + # type: (Iterable[torba.baseaccount.BaseAccount], torba.baseaccount.BaseAccount) -> torba.baseledger.BaseLedger ledger = None for account in funding_accounts: if ledger is None: @@ -305,12 +300,12 @@ class BaseTransaction: @classmethod @defer.inlineCallbacks def pay(cls, outputs, funding_accounts, change_account): - # type: (List[BaseOutput], List[BaseAccount], BaseAccount) -> BaseTransaction + # type: (List[BaseOutput], List[torba.baseaccount.BaseAccount], torba.baseaccount.BaseAccount) -> BaseTransaction """ Efficiently spend utxos from funding_accounts to cover the new outputs. """ tx = cls().add_outputs(outputs) ledger = cls.ensure_all_have_same_ledger(funding_accounts, change_account) - amount = ledger.get_transaction_base_fee(tx) + amount = tx.output_sum + ledger.get_transaction_base_fee(tx) txos = yield cls.get_effective_amount_estimators(funding_accounts) selector = CoinSelector( txos, amount, @@ -325,34 +320,38 @@ class BaseTransaction: spent_sum = sum(s.effective_amount for s in spendables) if spent_sum > amount: - change_address = change_account.change.get_or_create_usable_address() + change_address = yield change_account.change.get_or_create_usable_address() change_hash160 = change_account.ledger.address_to_hash160(change_address) change_amount = spent_sum - amount tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) tx.add_inputs([s.txi for s in spendables]) - tx.sign(funding_accounts) + yield tx.sign(funding_accounts) defer.returnValue(tx) @classmethod def liquidate(cls, assets, funding_accounts, change_account): """ Spend assets (utxos) supplementing with funding_accounts if fee is higher than asset value. """ - def sign(self, funding_accounts): # type: (Iterable[BaseAccount]) -> BaseTransaction + def signature_hash_type(self, hash_type): + return hash_type + + @defer.inlineCallbacks + def sign(self, funding_accounts): # type: (Iterable[torba.baseaccount.BaseAccount]) -> BaseTransaction ledger = self.ensure_all_have_same_ledger(funding_accounts) for i, txi in enumerate(self._inputs): txo_script = txi.output.script if txo_script.is_pay_pubkey_hash: address = ledger.hash160_to_address(txo_script.values['pubkey_hash']) - private_key = ledger.get_private_key_for_address(address) + private_key = yield ledger.get_private_key_for_address(address) tx = self._serialize_for_signature(i) - txi.script.values['signature'] = private_key.sign(tx)+six.int2byte(1) + txi.script.values['signature'] = \ + private_key.sign(tx) + six.int2byte(self.signature_hash_type(1)) txi.script.values['pubkey'] = private_key.public_key.pubkey_bytes txi.script.generate() else: raise NotImplementedError("Don't know how to spend this output.") self._reset() - return self def sort(self): # See https://github.com/kristovatlas/rfc/blob/master/bips/bip-li01.mediawiki @@ -361,8 +360,8 @@ class BaseTransaction: @property def input_sum(self): - return sum(i.amount for i in self._inputs) + return sum(i.amount for i in self.inputs) @property def output_sum(self): - return sum(o.amount for o in self._outputs) + return sum(o.amount for o in self.outputs) diff --git a/torba/coin/bitcoincash.py b/torba/coin/bitcoincash.py index 1830f9cdb..ca9a76a41 100644 --- a/torba/coin/bitcoincash.py +++ b/torba/coin/bitcoincash.py @@ -4,63 +4,26 @@ __node_bin__ = 'bitcoin-abc-0.17.2/bin' __node_url__ = ( 'https://download.bitcoinabc.org/0.17.2/linux/bitcoin-abc-0.17.2-x86_64-linux-gnu.tar.gz' ) +__electrumx__ = 'electrumx.lib.coins.BitcoinCashRegtest' from six import int2byte from binascii import unhexlify -from torba.baseledger import BaseLedger, BaseHeaders -from torba.basenetwork import BaseNetwork -from torba.basescript import BaseInputScript, BaseOutputScript -from torba.basetransaction import BaseTransaction, BaseInput, BaseOutput -from torba.basedatabase import BaseSQLiteWalletStorage -from torba.manager import BaseWalletManager - - -class WalletManager(BaseWalletManager): - pass - - -class Input(BaseInput): - script_class = BaseInputScript - - -class Output(BaseOutput): - script_class = BaseOutputScript +from torba.baseledger import BaseLedger +from torba.baseheader import BaseHeaders +from torba.basetransaction import BaseTransaction class Transaction(BaseTransaction): - input_class = Input - output_class = Output + + def signature_hash_type(self, hash_type): + return hash_type | 0x40 -class BitcoinCashLedger(BaseLedger): - network_class = BaseNetwork - headers_class = BaseHeaders - database_class = BaseSQLiteWalletStorage - - -class MainNetLedger(BitcoinCashLedger): - pass - - -class UnverifiedHeaders(BaseHeaders): - verify_bits_to_target = False - - -class RegTestLedger(BitcoinCashLedger): - headers_class = UnverifiedHeaders - max_target = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - genesis_hash = '0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206' - genesis_bits = 0x207fffff - target_timespan = 1 - verify_bits_to_target = False - - -class BitcoinCash(BaseCoin): +class MainNetLedger(BaseLedger): name = 'BitcoinCash' symbol = 'BCH' - network = 'mainnet' + network_name = 'mainnet' - ledger_class = MainNetLedger transaction_class = Transaction pubkey_address_prefix = int2byte(0x00) @@ -70,15 +33,21 @@ class BitcoinCash(BaseCoin): default_fee_per_byte = 50 - def __init__(self, ledger, fee_per_byte=default_fee_per_byte): - super(BitcoinCash, self).__init__(ledger, fee_per_byte) + +class UnverifiedHeaders(BaseHeaders): + verify_bits_to_target = False -class BitcoinCashRegtest(BitcoinCash): - network = 'regtest' - ledger_class = RegTestLedger +class RegTestLedger(MainNetLedger): + headers_class = UnverifiedHeaders + network_name = 'regtest' + pubkey_address_prefix = int2byte(111) script_address_prefix = int2byte(196) extended_public_key_prefix = unhexlify('043587cf') extended_private_key_prefix = unhexlify('04358394') + max_target = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + genesis_hash = '0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206' + genesis_bits = 0x207fffff + target_timespan = 1 diff --git a/torba/coin/bitcoinsegwit.py b/torba/coin/bitcoinsegwit.py index 6739d87f2..68301a57a 100644 --- a/torba/coin/bitcoinsegwit.py +++ b/torba/coin/bitcoinsegwit.py @@ -4,6 +4,7 @@ __node_bin__ = 'bitcoin-0.16.0/bin' __node_url__ = ( 'https://bitcoin.org/bin/bitcoin-core-0.16.0/bitcoin-0.16.0-x86_64-linux-gnu.tar.gz' ) +__electrumx__ = 'electrumx.lib.coins.BitcoinSegwitRegtest' from six import int2byte from binascii import unhexlify diff --git a/torba/hash.py b/torba/hash.py index 243ecdcde..3d7092e58 100644 --- a/torba/hash.py +++ b/torba/hash.py @@ -120,6 +120,9 @@ class Base58(object): @classmethod def decode(cls, txt): """ Decodes txt into a big-endian bytearray. """ + if six.PY2 and isinstance(txt, buffer): + txt = str(txt) + if isinstance(txt, six.binary_type): txt = txt.decode() diff --git a/torba/wallet.py b/torba/wallet.py index 38421c362..a93b77f25 100644 --- a/torba/wallet.py +++ b/torba/wallet.py @@ -1,17 +1,10 @@ import stat import json import os -from typing import List, Dict +from typing import List -from torba.baseaccount import BaseAccount -from torba.baseledger import LedgerRegistry, BaseLedger - - -def inflate_ledger(manager, ledger_id, ledger_dict): - # type: ('WalletManager', str, Dict) -> BaseLedger - ledger_class = LedgerRegistry.get_ledger_class(ledger_id) - ledger = manager.get_or_create_ledger(ledger_id) - return ledger_class(ledger, **ledger_dict) +import torba.baseaccount +import torba.baseledger class Wallet: @@ -21,13 +14,14 @@ class Wallet: by physical files on the filesystem. """ - def __init__(self, name='Wallet', ledgers=None, accounts=None, storage=None): + def __init__(self, name='Wallet', accounts=None, storage=None): + # type: (str, List[torba.baseaccount.BaseAccount], WalletStorage) -> None self.name = name - self.ledgers = ledgers or [] # type: List[BaseLedger] - self.accounts = accounts or [] # type: List[BaseAccount] + self.accounts = accounts or [] self.storage = storage or WalletStorage() - def generate_account(self, ledger): # type: (BaseLedger) -> Account + def generate_account(self, ledger): + # type: (torba.baseledger.BaseLedger) -> torba.baseaccount.BaseAccount account = ledger.account_class.generate(ledger, u'torba') self.accounts.append(account) return account @@ -36,22 +30,14 @@ class Wallet: def from_storage(cls, storage, manager): # type: (WalletStorage, 'WalletManager') -> Wallet json_dict = storage.read() - ledgers = {} - for ledger_id, ledger_dict in json_dict.get('ledgers', {}).items(): - ledgers[ledger_id] = inflate_ledger(manager, ledger_id, ledger_dict) - accounts = [] for account_dict in json_dict.get('accounts', []): - ledger_id = account_dict['ledger'] - ledger = ledgers.get(ledger_id) - if ledger is None: - ledger = ledgers[ledger_id] = inflate_ledger(manager, ledger_id, {}) + ledger = manager.get_or_create_ledger(account_dict['ledger']) account = ledger.account_class.from_dict(ledger, account_dict) accounts.append(account) return cls( name=json_dict.get('name', 'Wallet'), - ledgers=list(ledgers.values()), accounts=accounts, storage=storage ) @@ -59,7 +45,6 @@ class Wallet: def to_dict(self): return { 'name': self.name, - 'ledgers': {c.get_id(): {} for c in self.ledgers}, 'accounts': [a.to_dict() for a in self.accounts] } @@ -71,12 +56,6 @@ class Wallet: for account in self.accounts: return account - def get_account_private_key_for_address(self, address): - for account in self.accounts: - private_key = account.get_private_key_for_address(address) - if private_key is not None: - return account, private_key - class WalletStorage: diff --git a/tox.ini b/tox.ini index 7099b9dd7..798e9778b 100644 --- a/tox.ini +++ b/tox.ini @@ -1,12 +1,14 @@ [tox] -envlist = py{27,36} +envlist = py27,py36-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} [testenv] deps = coverage - mock - + py36: ../orchstr8 + py36: ../electrumx +extras = test changedir = {toxinidir}/tests - +setenv = py36: LEDGER={envname} commands = - coverage run -p --source={envsitepackagesdir}/torba -m unittest discover -v + coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial unit + py36: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration From f0ecf5875299c20f5d5499e2996b52c240d2d700 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 13 Jun 2018 21:01:48 -0400 Subject: [PATCH 016/383] use wip branch of orchstr8 --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index bdd37d199..a794b4bc1 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,7 +7,7 @@ python: install: - pip install tox-travis coverage - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch packages && popd - - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd + - pushd .. && git clone https://github.com/lbryio/orchstr8.git --branch wip && popd script: tox From b7cbe16159afca40346d55bb5172375b55a7d418 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 13 Jun 2018 21:37:02 -0400 Subject: [PATCH 017/383] spelling fix and cleaned up tox.ini --- tests/integration/test_transactions.py | 2 +- tox.ini | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 4de043124..d718aee27 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -7,7 +7,7 @@ class BasicTransactionTests(IntegrationTestCase): VERBOSE = True - async def test_sending_and_recieving(self): + async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) await account1.ensure_address_gap().asFuture(asyncio.get_event_loop()) diff --git a/tox.ini b/tox.ini index 798e9778b..cc24df999 100644 --- a/tox.ini +++ b/tox.ini @@ -1,14 +1,14 @@ [tox] -envlist = py27,py36-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} +envlist = py{27,36}-unit,py36-integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} [testenv] deps = coverage - py36: ../orchstr8 - py36: ../electrumx + py36-integration: ../orchstr8 + py36-integration: ../electrumx extras = test changedir = {toxinidir}/tests -setenv = py36: LEDGER={envname} +setenv = py36-integration: LEDGER={envname} commands = - coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial unit - py36: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration + py{27,36}-unit: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial unit + py36-integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration From 05ec13394c841e0367b13cb343fa0ab2bff08ada Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 13 Jun 2018 21:44:36 -0400 Subject: [PATCH 018/383] only run py36 and bitcoinsegwit integration tests until we work out the kinks --- tox.ini | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tox.ini b/tox.ini index cc24df999..dac3fb12f 100644 --- a/tox.ini +++ b/tox.ini @@ -1,5 +1,6 @@ [tox] -envlist = py{27,36}-unit,py36-integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} +#envlist = py{27,36}-unit,py36-integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} +envlist = py36-unit,py36-integration-torba.coin.bitcoinsegwit [testenv] deps = From 13444ae6c39509d33f04342949f5641e07a31c38 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 13 Jun 2018 23:29:13 -0400 Subject: [PATCH 019/383] try downloading blockchain binary before tests run to prevent timeout during testing --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index a794b4bc1..d7b9f24f0 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,6 +8,7 @@ install: - pip install tox-travis coverage - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch packages && popd - pushd .. && git clone https://github.com/lbryio/orchstr8.git --branch wip && popd + - pushd ../orchstr8 && pip install -e . && LEDGER=torba.coin.bitcoinsegwit orchstr8 download && popd script: tox From 643998332ed3f2121678e271a3b21242bbbc9023 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 13 Jun 2018 23:31:20 -0400 Subject: [PATCH 020/383] orchstr8 download needs torba installed --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index d7b9f24f0..763e1ca35 100644 --- a/.travis.yml +++ b/.travis.yml @@ -6,6 +6,7 @@ python: install: - pip install tox-travis coverage + - pip install -e . - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch packages && popd - pushd .. && git clone https://github.com/lbryio/orchstr8.git --branch wip && popd - pushd ../orchstr8 && pip install -e . && LEDGER=torba.coin.bitcoinsegwit orchstr8 download && popd From 9977a398af1c2ab28d486f66750956842e5efa00 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 13 Jun 2018 23:34:09 -0400 Subject: [PATCH 021/383] orchstr8 download needs electrumx installed --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index 763e1ca35..731f0b3d5 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,6 +8,7 @@ install: - pip install tox-travis coverage - pip install -e . - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch packages && popd + - pushd ../electrumx && pip install -e . && popd - pushd .. && git clone https://github.com/lbryio/orchstr8.git --branch wip && popd - pushd ../orchstr8 && pip install -e . && LEDGER=torba.coin.bitcoinsegwit orchstr8 download && popd From ac0c88768df100016b38e9caa9e3734ce079a2d2 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 13 Jun 2018 23:47:13 -0400 Subject: [PATCH 022/383] moved orchstr8 download into tox.ini instead of .travis.yml --- .travis.yml | 3 --- tox.ini | 1 + 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 731f0b3d5..a794b4bc1 100644 --- a/.travis.yml +++ b/.travis.yml @@ -6,11 +6,8 @@ python: install: - pip install tox-travis coverage - - pip install -e . - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch packages && popd - - pushd ../electrumx && pip install -e . && popd - pushd .. && git clone https://github.com/lbryio/orchstr8.git --branch wip && popd - - pushd ../orchstr8 && pip install -e . && LEDGER=torba.coin.bitcoinsegwit orchstr8 download && popd script: tox diff --git a/tox.ini b/tox.ini index dac3fb12f..2744f3b9a 100644 --- a/tox.ini +++ b/tox.ini @@ -12,4 +12,5 @@ changedir = {toxinidir}/tests setenv = py36-integration: LEDGER={envname} commands = py{27,36}-unit: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial unit + py36-integration: orchstr8 download py36-integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration From 52846a3b24d55f8dadd8fa41e07697b42101d049 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 14 Jun 2018 00:03:52 -0400 Subject: [PATCH 023/383] switch to master branch of orchstr8 --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index a794b4bc1..bdd37d199 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,7 +7,7 @@ python: install: - pip install tox-travis coverage - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch packages && popd - - pushd .. && git clone https://github.com/lbryio/orchstr8.git --branch wip && popd + - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd script: tox From 4dee59a49d1f3862ff19e80bd79af0f082b45054 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 14 Jun 2018 15:17:59 -0400 Subject: [PATCH 024/383] better customization during testing --- tests/unit/test_account.py | 4 +- tests/unit/test_coinselection.py | 2 +- tests/unit/test_ledger.py | 2 +- tests/unit/test_transaction.py | 6 +-- torba/baseledger.py | 6 +-- torba/basetransaction.py | 2 +- torba/manager.py | 83 ++++++-------------------------- tox.ini | 2 +- 8 files changed, 25 insertions(+), 82 deletions(-) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index c62e9fcaf..ad82d2540 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -8,7 +8,7 @@ from torba.coin.bitcoinsegwit import MainNetLedger class TestKeyChain(unittest.TestCase): def setUp(self): - self.ledger = MainNetLedger(db=':memory:') + self.ledger = MainNetLedger(db=MainNetLedger.database_class(':memory:')) return self.ledger.db.start() @defer.inlineCallbacks @@ -68,7 +68,7 @@ class TestKeyChain(unittest.TestCase): class TestAccount(unittest.TestCase): def setUp(self): - self.ledger = MainNetLedger(db=':memory:') + self.ledger = MainNetLedger(db=MainNetLedger.database_class(':memory:')) return self.ledger.db.start() @defer.inlineCallbacks diff --git a/tests/unit/test_coinselection.py b/tests/unit/test_coinselection.py index c6f8582db..b304fdefb 100644 --- a/tests/unit/test_coinselection.py +++ b/tests/unit/test_coinselection.py @@ -19,7 +19,7 @@ def search(*args, **kwargs): class BaseSelectionTestCase(unittest.TestCase): def setUp(self): - self.ledger = MainNetLedger(db=':memory:') + self.ledger = MainNetLedger(db=MainNetLedger.database_class(':memory:')) return self.ledger.db.start() def estimates(self, *args): diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index 0a354648d..b36dd7eb5 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -33,7 +33,7 @@ class MockNetwork: class TestSynchronization(unittest.TestCase): def setUp(self): - self.ledger = MainNetLedger(db=':memory:') + self.ledger = MainNetLedger(db=MainNetLedger.database_class(':memory:')) return self.ledger.db.start() @defer.inlineCallbacks diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index afb2b0da7..56b25caa0 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -4,8 +4,6 @@ from twisted.internet import defer from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class from torba.constants import CENT, COIN -from torba.manager import WalletManager -from torba.wallet import Wallet NULL_HASH = b'\x00'*32 @@ -32,7 +30,7 @@ def get_transaction(txo=None): class TestSizeAndFeeEstimation(unittest.TestCase): def setUp(self): - self.ledger = ledger_class(db=':memory:') + self.ledger = ledger_class(db=ledger_class.database_class(':memory:')) return self.ledger.db.start() def io_fee(self, io): @@ -145,7 +143,7 @@ class TestTransactionSerialization(unittest.TestCase): class TestTransactionSigning(unittest.TestCase): def setUp(self): - self.ledger = ledger_class(db=':memory:') + self.ledger = ledger_class(db=ledger_class.database_class(':memory:')) return self.ledger.db.start() @defer.inlineCallbacks diff --git a/torba/baseledger.py b/torba/baseledger.py index 8c28d70bc..072825b49 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -55,9 +55,9 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): def __init__(self, config=None, db=None, network=None): self.config = config or {} - self.db = self.database_class( - db or os.path.join(self.path, "blockchain.db") - ) # type: basedatabase.BaseSQLiteWalletStorage + self.db = db or self.database_class( + os.path.join(self.path, "blockchain.db") + ) # type: basedatabase.BaseDatabase self.network = network or self.network_class(self) self.network.on_header.listen(self.process_header) self.network.on_status.listen(self.process_status) diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 91e43efa4..8ae403675 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -300,7 +300,7 @@ class BaseTransaction: @classmethod @defer.inlineCallbacks def pay(cls, outputs, funding_accounts, change_account): - # type: (List[BaseOutput], List[torba.baseaccount.BaseAccount], torba.baseaccount.BaseAccount) -> BaseTransaction + # type: (List[BaseOutput], List[torba.baseaccount.BaseAccount], torba.baseaccount.BaseAccount) -> defer.Deferred """ Efficiently spend utxos from funding_accounts to cover the new outputs. """ tx = cls().add_outputs(outputs) diff --git a/torba/manager.py b/torba/manager.py index 104200352..42f8e58b2 100644 --- a/torba/manager.py +++ b/torba/manager.py @@ -1,23 +1,20 @@ -import functools from typing import List, Dict, Type from twisted.internet import defer from torba.baseledger import BaseLedger, LedgerRegistry -from torba.basetransaction import BaseTransaction, NULL_HASH -from torba.coinselection import CoinSelector -from torba.constants import COIN from torba.wallet import Wallet, WalletStorage class WalletManager(object): def __init__(self, wallets=None, ledgers=None): - self.wallets = wallets or [] # type: List[Wallet] - self.ledgers = ledgers or {} # type: Dict[Type[BaseLedger],BaseLedger] + # type: (List[Wallet], Dict[Type[BaseLedger],BaseLedger]) -> None + self.wallets = wallets or [] + self.ledgers = ledgers or {} self.running = False @classmethod - def from_config(cls, config): + def from_config(cls, config): # type: (Dict) -> WalletManager wallets = [] manager = cls(wallets) for coin_id, ledger_config in config.get('ledgers', {}).items(): @@ -32,20 +29,23 @@ class WalletManager(object): ledger_class = LedgerRegistry.get_ledger_class(ledger_id) ledger = self.ledgers.get(ledger_class) if ledger is None: - ledger = self.create_ledger(ledger_class, ledger_config or {}) + ledger = ledger_class(ledger_config or {}) self.ledgers[ledger_class] = ledger return ledger - def create_ledger(self, ledger_class, config): - return ledger_class(config) + def create_wallet(self, path): + storage = WalletStorage(path) + wallet = Wallet.from_storage(storage, self) + self.wallets.append(wallet) + return wallet @defer.inlineCallbacks def get_balance(self): balances = {} - for ledger in self.ledgers: - for account in self.get_accounts(ledger.coin_class): - balances.setdefault(ledger.coin_class.name, 0) - balances[ledger.coin_class.name] += yield account.get_balance() + for ledger in self.ledgers.values(): + for account in ledger.accounts: + balances.setdefault(ledger.get_id(), 0) + balances[ledger.get_id()] += yield account.get_balance() defer.returnValue(balances) @property @@ -64,22 +64,6 @@ class WalletManager(object): if account.coin.__class__ is coin_class: yield account - def get_accounts_view(self, coin_class): - return AccountsView( - functools.partial(self.get_accounts, coin_class) - ) - - def create_wallet(self, path, coin_class): - storage = WalletStorage(path) - wallet = Wallet.from_storage(storage, self) - self.wallets.append(wallet) - self.create_account(wallet, coin_class) - return wallet - - def create_account(self, wallet, coin_class): - ledger = self.get_or_create_ledger(coin_class.get_id()) - return wallet.generate_account(ledger) - @defer.inlineCallbacks def start(self): self.running = True @@ -93,42 +77,3 @@ class WalletManager(object): l.stop() for l in self.ledgers.values() ]) self.running = False - - def send_amount_to_address(self, amount, address): - amount = int(amount * COIN) - - account = self.default_account - ledger = account.ledger - tx_class = ledger.transaction_class # type: BaseTransaction - in_class, out_class = tx_class.input_class, tx_class.output_class - - estimators = [ - txo.get_estimator(ledger) for txo in account.get_unspent_utxos() - ] - tx_class.create() - - cost_of_output = ledger.get_input_output_fee( - out_class.pay_pubkey_hash(COIN, NULL_HASH) - ) - - selector = CoinSelector(estimators, amount, cost_of_output) - spendables = selector.select() - if not spendables: - raise ValueError('Not enough funds to cover this transaction.') - - outputs = [ - out_class.pay_pubkey_hash(amount, coin.address_to_hash160(address)) - ] - - spent_sum = sum(s.effective_amount for s in spendables) - if spent_sum > amount: - change_address = account.get_least_used_change_address() - change_hash160 = coin.address_to_hash160(change_address) - outputs.append(out_class.pay_pubkey_hash(spent_sum - amount, change_hash160)) - - tx = tx_class() \ - .add_inputs([s.txi for s in spendables]) \ - .add_outputs(outputs) \ - .sign(account) - - return tx diff --git a/tox.ini b/tox.ini index 2744f3b9a..d006596dc 100644 --- a/tox.ini +++ b/tox.ini @@ -1,6 +1,6 @@ [tox] #envlist = py{27,36}-unit,py36-integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} -envlist = py36-unit,py36-integration-torba.coin.bitcoinsegwit +envlist = py{27,36}-unit,py36-integration-torba.coin.bitcoinsegwit [testenv] deps = From 43cd9c4100c5e7aa4d5429ce660cc16a880087bc Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 14 Jun 2018 16:27:17 -0400 Subject: [PATCH 025/383] removed unused msqr module --- torba/msqr.py | 96 --------------------------------------------------- 1 file changed, 96 deletions(-) delete mode 100644 torba/msqr.py diff --git a/torba/msqr.py b/torba/msqr.py deleted file mode 100644 index beb5bed7f..000000000 --- a/torba/msqr.py +++ /dev/null @@ -1,96 +0,0 @@ -# from http://eli.thegreenplace.net/2009/03/07/computing-modular-square-roots-in-python/ - - -def modular_sqrt(a, p): - """ Find a quadratic residue (mod p) of 'a'. p - must be an odd prime. - - Solve the congruence of the form: - x^2 = a (mod p) - And returns x. Note that p - x is also a root. - - 0 is returned is no square root exists for - these a and p. - - The Tonelli-Shanks algorithm is used (except - for some simple cases in which the solution - is known from an identity). This algorithm - runs in polynomial time (unless the - generalized Riemann hypothesis is false). - """ - # Simple cases - # - if legendre_symbol(a, p) != 1: - return 0 - elif a == 0: - return 0 - elif p == 2: - return p - elif p % 4 == 3: - return pow(a, (p + 1) / 4, p) - - # Partition p-1 to s * 2^e for an odd s (i.e. - # reduce all the powers of 2 from p-1) - # - s = p - 1 - e = 0 - while s % 2 == 0: - s /= 2 - e += 1 - - # Find some 'n' with a legendre symbol n|p = -1. - # Shouldn't take long. - # - n = 2 - while legendre_symbol(n, p) != -1: - n += 1 - - # Here be dragons! - # Read the paper "Square roots from 1; 24, 51, - # 10 to Dan Shanks" by Ezra Brown for more - # information - # - - # x is a guess of the square root that gets better - # with each iteration. - # b is the "fudge factor" - by how much we're off - # with the guess. The invariant x^2 = ab (mod p) - # is maintained throughout the loop. - # g is used for successive powers of n to update - # both a and b - # r is the exponent - decreases with each update - # - x = pow(a, (s + 1) / 2, p) - b = pow(a, s, p) - g = pow(n, s, p) - r = e - - while True: - t = b - m = 0 - for m in xrange(r): - if t == 1: - break - t = pow(t, 2, p) - - if m == 0: - return x - - gs = pow(g, 2 ** (r - m - 1), p) - g = (gs * gs) % p - x = (x * gs) % p - b = (b * g) % p - r = m - - -def legendre_symbol(a, p): - """ Compute the Legendre symbol a|p using - Euler's criterion. p is a prime, a is - relatively prime to p (if p divides - a, then a|p = 0) - - Returns 1 if a has a square root modulo - p, -1 otherwise. - """ - ls = pow(a, (p - 1) / 2, p) - return -1 if ls == p - 1 else ls From 833ef98ff5722c98ce868b5a45d121ebcc5fa35c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 17 Jun 2018 23:22:15 -0400 Subject: [PATCH 026/383] refactoring and added basic test for reading/writing wallet file --- tests/unit/test_wallet.py | 30 ++++++++++++++++++++++++++---- torba/baseaccount.py | 4 ++-- torba/baseledger.py | 12 +++++++++++- torba/basetransaction.py | 15 ++------------- torba/wallet.py | 2 +- 5 files changed, 42 insertions(+), 21 deletions(-) diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index 86521fdd5..5ca3bd904 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -1,3 +1,4 @@ +import tempfile from twisted.trial import unittest from torba.coin.bitcoinsegwit import MainNetLedger as BTCLedger @@ -36,11 +37,11 @@ class TestWalletCreation(unittest.TestCase): "h absent", 'encrypted': False, 'private_key': - b'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - b'6yz3jMbycrLrRMpeAJxR8qDg8', + 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + '6yz3jMbycrLrRMpeAJxR8qDg8', 'public_key': - b'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' - b'iW44g14WF52fYC5J483wqQ5ZP', + 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' + 'iW44g14WF52fYC5J483wqQ5ZP', 'receiving_gap': 10, 'receiving_maximum_use_per_address': 2, 'change_gap': 10, @@ -57,3 +58,24 @@ class TestWalletCreation(unittest.TestCase): self.assertIsInstance(account, BTCLedger.account_class) self.maxDiff = None self.assertDictEqual(wallet_dict, wallet.to_dict()) + + def test_read_write(self): + manager = WalletManager() + config = {'wallet_path': '/tmp/wallet'} + ledger = manager.get_or_create_ledger(BTCLedger.get_id(), config) + + with tempfile.NamedTemporaryFile(suffix='.json') as wallet_file: + wallet_file.write(b'{}') + wallet_file.seek(0) + + # create and write wallet to a file + wallet_storage = WalletStorage(wallet_file.name) + wallet = Wallet.from_storage(wallet_storage, manager) + account = wallet.generate_account(ledger) + wallet.save() + + # read wallet from file + wallet_storage = WalletStorage(wallet_file.name) + wallet = Wallet.from_storage(wallet_storage, manager) + + self.assertEqual(account.public_key.address, wallet.default_account.public_key.address) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index f753732df..d2a5b0c82 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -133,8 +133,8 @@ class BaseAccount: 'seed': self.seed, 'encrypted': self.encrypted, 'private_key': self.private_key if self.encrypted else - self.private_key.extended_key_string(), - 'public_key': self.public_key.extended_key_string(), + self.private_key.extended_key_string().decode(), + 'public_key': self.public_key.extended_key_string().decode(), 'receiving_gap': self.receiving.gap, 'change_gap': self.change.gap, 'receiving_maximum_use_per_address': self.receiving.maximum_use_per_address, diff --git a/torba/baseledger.py b/torba/baseledger.py index 072825b49..2e9e53463 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -2,7 +2,7 @@ import os import six import hashlib from binascii import hexlify, unhexlify -from typing import Dict, Type +from typing import Dict, Type, Iterable, Generator from operator import itemgetter from twisted.internet import defer @@ -126,6 +126,16 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): def get_unspent_outputs(self, account): return self.db.get_utxos(account, self.transaction_class.output_class) + @defer.inlineCallbacks + def get_effective_amount_estimators(self, funding_accounts): + # type: (Iterable[baseaccount.BaseAccount]) -> defer.Deferred + estimators = [] + for account in funding_accounts: + utxos = yield self.get_unspent_outputs(account) + for utxo in utxos: + estimators.append(utxo.get_estimator(self)) + defer.returnValue(estimators) + @defer.inlineCallbacks def get_local_status(self, address): address_details = yield self.db.get_address(address) diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 8ae403675..8914b9173 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -1,6 +1,6 @@ import six import logging -from typing import List, Iterable, Generator +from typing import List, Iterable from binascii import hexlify from twisted.internet import defer @@ -271,17 +271,6 @@ class BaseTransaction: ]) self.locktime = stream.read_uint32() - @classmethod - @defer.inlineCallbacks - def get_effective_amount_estimators(cls, funding_accounts): - # type: (Iterable[torba.baseaccount.BaseAccount]) -> Generator[BaseOutputEffectiveAmountEstimator] - estimators = [] - for account in funding_accounts: - utxos = yield account.ledger.get_unspent_outputs(account) - for utxo in utxos: - estimators.append(utxo.get_estimator(account.ledger)) - defer.returnValue(estimators) - @classmethod def ensure_all_have_same_ledger(cls, funding_accounts, change_account=None): # type: (Iterable[torba.baseaccount.BaseAccount], torba.baseaccount.BaseAccount) -> torba.baseledger.BaseLedger @@ -306,7 +295,7 @@ class BaseTransaction: tx = cls().add_outputs(outputs) ledger = cls.ensure_all_have_same_ledger(funding_accounts, change_account) amount = tx.output_sum + ledger.get_transaction_base_fee(tx) - txos = yield cls.get_effective_amount_estimators(funding_accounts) + txos = yield ledger.get_effective_amount_estimators(funding_accounts) selector = CoinSelector( txos, amount, ledger.get_input_output_fee( diff --git a/torba/wallet.py b/torba/wallet.py index a93b77f25..9ac2d9f76 100644 --- a/torba/wallet.py +++ b/torba/wallet.py @@ -17,7 +17,7 @@ class Wallet: def __init__(self, name='Wallet', accounts=None, storage=None): # type: (str, List[torba.baseaccount.BaseAccount], WalletStorage) -> None self.name = name - self.accounts = accounts or [] + self.accounts = accounts or [] # type: List[torba.baseaccount.BaseAccount] self.storage = storage or WalletStorage() def generate_account(self, ledger): From 22b897db2e4954c91af3a04288818bcb8688f996 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 17 Jun 2018 23:29:23 -0400 Subject: [PATCH 027/383] unit test fix --- tests/unit/test_account.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index ad82d2540..95d3a68ab 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -136,11 +136,11 @@ class TestAccount(unittest.TestCase): "h absent", 'encrypted': False, 'private_key': - b'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - b'6yz3jMbycrLrRMpeAJxR8qDg8', + 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + '6yz3jMbycrLrRMpeAJxR8qDg8', 'public_key': - b'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' - b'iW44g14WF52fYC5J483wqQ5ZP', + 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' + 'iW44g14WF52fYC5J483wqQ5ZP', 'receiving_gap': 10, 'receiving_maximum_use_per_address': 2, 'change_gap': 10, From aba3ed7ca0182fe167cfce5211477a0ab2e6d101 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 25 Jun 2018 09:54:35 -0400 Subject: [PATCH 028/383] SPV support --- tests/integration/test_transactions.py | 16 ++++- torba/basedatabase.py | 53 +++++++++++----- torba/baseledger.py | 87 +++++++++++++++++++------- 3 files changed, 115 insertions(+), 41 deletions(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index d718aee27..883b39d45 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -29,11 +29,21 @@ class BasicTransactionTests(IntegrationTestCase): [self.ledger.transaction_class.output_class.pay_pubkey_hash(2*COIN, self.ledger.address_to_hash160(address))], [account1], account1 ).asFuture(asyncio.get_event_loop()) - await self.blockchain.decode_raw_transaction(tx) await self.broadcast(tx) await self.on_transaction(tx.hex_id.decode()) #mempool + + tx2 = await self.ledger.transaction_class.pay( + [self.ledger.transaction_class.output_class.pay_pubkey_hash(1*COIN, self.ledger.address_to_hash160(address))], + [account1], account1 + ).asFuture(asyncio.get_event_loop()) + await self.broadcast(tx2) + await self.on_transaction(tx2.hex_id.decode()) #mempool + await self.blockchain.generate(1) await self.on_transaction(tx.hex_id.decode()) #confirmed - self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 3.5) - self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) + #self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 3.5) + #self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) + + self.assertTrue(await self.ledger.is_valid_transaction(tx, 202).asFuture(asyncio.get_event_loop())) + self.assertTrue(await self.ledger.is_valid_transaction(tx2, 202).asFuture(asyncio.get_event_loop())) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 378fbdea3..b58845d74 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -44,11 +44,23 @@ class SQLiteMixin(object): for column, value in data.items(): columns.append(column) values.append(value) - sql = "REPLACE INTO {} ({}) VALUES ({})".format( + sql = "INSERT INTO {} ({}) VALUES ({})".format( table, ', '.join(columns), ', '.join(['?'] * len(values)) ) return sql, values + def _update_sql(self, table, data, where, constraints): + # type: (str, dict) -> tuple[str, List] + columns, values = [], [] + for column, value in data.items(): + columns.append("{} = ?".format(column)) + values.append(value) + values.extend(constraints) + sql = "UPDATE {} SET {} WHERE {}".format( + table, ', '.join(columns), where + ) + return sql, values + @defer.inlineCallbacks def query_one_value_list(self, query, params): # type: (str, Union[dict,tuple]) -> defer.Deferred[List] @@ -143,21 +155,21 @@ class BaseDatabase(SQLiteMixin): CREATE_TXI_TABLE ) - def add_transaction(self, address, hash, tx, height, is_verified): + def save_transaction_io(self, save_tx, tx, height, is_verified, address, hash, history): + def _steps(t): - current_height = t.execute("SELECT height FROM tx WHERE txhash=?", (sqlite3.Binary(tx.hash),)).fetchone() - if current_height is None: + if save_tx == 'insert': t.execute(*self._insert_sql('tx', { 'txhash': sqlite3.Binary(tx.hash), 'raw': sqlite3.Binary(tx.raw), 'height': height, 'is_verified': is_verified })) - elif current_height[0] != height: - t.execute("UPDATE tx SET height = :height WHERE txhash = :txhash", { - 'txhash': sqlite3.Binary(tx.hash), - 'height': height, - }) + elif save_tx == 'update': + t.execute(*self._update_sql("tx", { + 'height': height, 'is_verified': is_verified + }, 'WHERE txhash = ?', (sqlite3.Binary(tx.hash),) + )) existing_txos = list(map(itemgetter(0), t.execute( "SELECT position FROM txo WHERE txhash = ?", @@ -177,7 +189,7 @@ class BaseDatabase(SQLiteMixin): })) elif txo.script.is_pay_script_hash: # TODO: implement script hash payments - print('Database.add_transaction pay script hash is not implemented!') + print('Database.save_transaction_io: pay script hash is not implemented!') existing_txis = [txi[0] for txi in t.execute( "SELECT txoid FROM txi WHERE txhash = ? AND address = ?", @@ -195,8 +207,23 @@ class BaseDatabase(SQLiteMixin): 'txoid': txoid[0], })) + t.execute( + "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", + (sqlite3.Binary(history), history.count(b':')//2, sqlite3.Binary(address)) + ) + return self.db.runInteraction(_steps) + @defer.inlineCallbacks + def get_transaction(self, txhash): + result = yield self.db.runQuery( + "SELECT raw, height, is_verified FROM tx WHERE txhash = ?", (sqlite3.Binary(txhash),) + ) + if result: + defer.returnValue(*result[0]) + else: + defer.returnValue((None, None, False)) + @defer.inlineCallbacks def get_balance_for_account(self, account): result = yield self.db.runQuery( @@ -296,9 +323,3 @@ class BaseDatabase(SQLiteMixin): ('address', 'account', 'chain', 'position', 'pubkey', 'history', 'used_times'), {'address': sqlite3.Binary(address)} ) - - def set_address_history(self, address, history): - return self.db.runOperation( - "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", - (sqlite3.Binary(history), history.count(b':')//2, sqlite3.Binary(address)) - ) diff --git a/torba/baseledger.py b/torba/baseledger.py index 2e9e53463..36d7f6a6e 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -68,6 +68,8 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): self._on_transaction_controller = StreamController() self.on_transaction = self._on_transaction_controller.stream + self._transaction_processing_locks = {} + @classmethod def get_id(cls): return '{}_{}'.format(cls.symbol.lower(), cls.network_name.lower()) @@ -101,14 +103,6 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): """ Fee for the transaction header and all outputs; without inputs. """ return self.fee_per_byte * tx.base_size - @defer.inlineCallbacks - def add_transaction(self, address, transaction, height): - # type: (bytes, basetransaction.BaseTransaction, int) -> None - yield self.db.add_transaction( - address, self.address_to_hash160(address), transaction, height, False - ) - self._on_transaction_controller.add(transaction) - @defer.inlineCallbacks def add_account(self, account): # type: (baseaccount.BaseAccount) -> None self.accounts.add(account) @@ -139,7 +133,10 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): @defer.inlineCallbacks def get_local_status(self, address): address_details = yield self.db.get_address(address) - hash = hashlib.sha256(address_details['history']).digest() + history = address_details['history'] or b'' + if six.PY2: + history = str(history) + hash = hashlib.sha256(history).digest() defer.returnValue(hexlify(hash)) @defer.inlineCallbacks @@ -151,6 +148,26 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): parts = history.split(b':')[:-1] defer.returnValue(list(zip(parts[0::2], map(int, parts[1::2])))) + @staticmethod + def get_root_of_merkle_tree(branches, branch_positions, working_branch): + for i, branch in enumerate(branches): + other_branch = unhexlify(branch)[::-1] + other_branch_on_left = bool((branch_positions >> i) & 1) + if other_branch_on_left: + combined = other_branch + working_branch + else: + combined = working_branch + other_branch + working_branch = double_sha256(combined) + return hexlify(working_branch[::-1]) + + @defer.inlineCallbacks + def is_valid_transaction(self, tx, height): + len(self.headers) < height or defer.returnValue(False) + merkle = yield self.network.get_merkle(tx.hex_id.decode(), height) + merkle_root = self.get_root_of_merkle_tree(merkle['merkle'], merkle['pos'], tx.hash) + header = self.headers[height] + defer.returnValue(merkle_root == header['merkle_root']) + @defer.inlineCallbacks def start(self): if not os.path.exists(self.path): @@ -173,8 +190,6 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): while True: height_sought = len(self.headers) headers = yield self.network.get_headers(height_sought) - print("received {} headers starting at {} height".format(headers['count'], height_sought)) - #log.info("received {} headers starting at {} height".format(headers['count'], height_sought)) if headers['count'] <= 0: break yield self.headers.connect(height_sought, unhexlify(headers['hex'])) @@ -221,20 +236,48 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): @defer.inlineCallbacks def update_history(self, address): remote_history = yield self.network.get_history(address) - local = yield self.get_local_history(address) + local_history = yield self.get_local_history(address) - history_parts = [] - for i, (hash, height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): - history_parts.append('{}:{}:'.format(hash.decode(), height)) - if i < len(local) and local[i] == (hash, height): + synced_history = [] + for i, (hash, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): + + synced_history.append((hash, remote_height)) + + if i < len(local_history) and local_history[i] == (hash, remote_height): continue - raw = yield self.network.get_transaction(hash) - transaction = self.transaction_class(unhexlify(raw)) - yield self.add_transaction(address, transaction, height) - yield self.db.set_address_history( - address, ''.join(history_parts).encode() - ) + lock = self._transaction_processing_locks.setdefault(hash, defer.DeferredLock()) + + yield lock.acquire() + + try: + # see if we have a local copy of transaction, otherwise fetch it from server + raw, local_height, is_verified = yield self.db.get_transaction(unhexlify(hash)) + save_tx = None + if raw is None: + _raw = yield self.network.get_transaction(hash) + tx = self.transaction_class(unhexlify(_raw)) + save_tx = 'insert' + else: + tx = self.transaction_class(unhexlify(raw)) + + if remote_height > 0 and not is_verified: + is_verified = yield self.is_valid_transaction(tx, remote_height) + if save_tx is None: + save_tx = 'update' + + yield self.db.save_transaction_io( + save_tx, tx, remote_height, is_verified, address, self.address_to_hash160(address), + ''.join('{}:{}:'.format(hash.decode(), height) for hash, height in synced_history).encode() + ) + + if save_tx is not None: + self._on_transaction_controller.add(tx) + + finally: + lock.release() + if not lock.locked: + del self._transaction_processing_locks[hash] @defer.inlineCallbacks def subscribe_history(self, address): From 9a467f88406f1027b02b8302961f715f0e48c192 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 26 Jun 2018 17:22:05 -0400 Subject: [PATCH 029/383] * on_transaction now produces TransactionEvents with useful info and lots of other changes --- tests/integration/test_transactions.py | 19 +++++---- torba/basedatabase.py | 28 +++++++++---- torba/baseheader.py | 10 +++-- torba/baseledger.py | 54 ++++++++++++++++---------- torba/basetransaction.py | 42 +++++++++++++++----- torba/util.py | 8 +++- 6 files changed, 111 insertions(+), 50 deletions(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 883b39d45..939d87a19 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -17,30 +17,35 @@ class BasicTransactionTests(IntegrationTestCase): address = await account1.receiving.get_or_create_usable_address().asFuture(asyncio.get_event_loop()) sendtxid = await self.blockchain.send_to_address(address.decode(), 5.5) - await self.on_transaction(sendtxid) #mempool + await self.on_transaction_id(sendtxid) #mempool await self.blockchain.generate(1) - await self.on_transaction(sendtxid) #confirmed + await self.on_transaction_id(sendtxid) #confirmed self.assertEqual(await self.get_balance(account1), int(5.5*COIN)) self.assertEqual(await self.get_balance(account2), 0) address = await account2.receiving.get_or_create_usable_address().asFuture(asyncio.get_event_loop()) + hash1 = self.ledger.address_to_hash160(address) tx = await self.ledger.transaction_class.pay( - [self.ledger.transaction_class.output_class.pay_pubkey_hash(2*COIN, self.ledger.address_to_hash160(address))], + [self.ledger.transaction_class.output_class.pay_pubkey_hash(2*COIN, hash1)], [account1], account1 ).asFuture(asyncio.get_event_loop()) await self.broadcast(tx) - await self.on_transaction(tx.hex_id.decode()) #mempool + await self.on_transaction(tx) #mempool tx2 = await self.ledger.transaction_class.pay( - [self.ledger.transaction_class.output_class.pay_pubkey_hash(1*COIN, self.ledger.address_to_hash160(address))], + [self.ledger.transaction_class.output_class.pay_pubkey_hash(1*COIN, hash1)], [account1], account1 ).asFuture(asyncio.get_event_loop()) await self.broadcast(tx2) - await self.on_transaction(tx2.hex_id.decode()) #mempool + await self.on_transaction(tx2) #mempool await self.blockchain.generate(1) - await self.on_transaction(tx.hex_id.decode()) #confirmed + await asyncio.wait([ + self.on_header(202), + self.on_transaction(tx), + self.on_transaction(tx2), + ]) #self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 3.5) #self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index b58845d74..6923c6e5e 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -113,7 +113,7 @@ class BaseDatabase(SQLiteMixin): txhash blob primary key, raw blob not null, height integer not null, - is_verified boolean not null default false + is_verified boolean not null default 0 ); """ @@ -136,7 +136,8 @@ class BaseDatabase(SQLiteMixin): address blob references pubkey_address, position integer not null, amount integer not null, - script blob not null + script blob not null, + is_reserved boolean not null default 0 ); """ @@ -168,7 +169,7 @@ class BaseDatabase(SQLiteMixin): elif save_tx == 'update': t.execute(*self._update_sql("tx", { 'height': height, 'is_verified': is_verified - }, 'WHERE txhash = ?', (sqlite3.Binary(tx.hash),) + }, 'txhash = ?', (sqlite3.Binary(tx.hash),) )) existing_txos = list(map(itemgetter(0), t.execute( @@ -209,18 +210,28 @@ class BaseDatabase(SQLiteMixin): t.execute( "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", - (sqlite3.Binary(history), history.count(b':')//2, sqlite3.Binary(address)) + (history, history.count(':')//2, sqlite3.Binary(address)) ) return self.db.runInteraction(_steps) + def reserve_spent_outputs(self, txoids, is_reserved=True): + return self.db.runOperation( + "UPDATE txo SET is_reserved = ? WHERE txoid IN ({})".format( + ', '.join(['?']*len(txoids)) + ), [is_reserved]+txoids + ) + + def release_reserved_outputs(self, txoids): + return self.reserve_spent_outputs(txoids, is_reserved=False) + @defer.inlineCallbacks def get_transaction(self, txhash): result = yield self.db.runQuery( "SELECT raw, height, is_verified FROM tx WHERE txhash = ?", (sqlite3.Binary(txhash),) ) if result: - defer.returnValue(*result[0]) + defer.returnValue(result[0]) else: defer.returnValue((None, None, False)) @@ -244,9 +255,9 @@ class BaseDatabase(SQLiteMixin): def get_utxos(self, account, output_class): utxos = yield self.db.runQuery( """ - SELECT amount, script, txhash, txo.position + SELECT amount, script, txhash, txo.position, txoid FROM txo JOIN pubkey_address ON pubkey_address.address=txo.address - WHERE account=:account AND txoid NOT IN (SELECT txoid FROM txi) + WHERE account=:account AND txo.is_reserved=0 AND txoid NOT IN (SELECT txoid FROM txi) """, {'account': sqlite3.Binary(account.public_key.address)} ) @@ -255,7 +266,8 @@ class BaseDatabase(SQLiteMixin): values[0], output_class.script_class(values[1]), values[2], - index=values[3] + index=values[3], + txoid=values[4] ) for values in utxos ]) diff --git a/torba/baseheader.py b/torba/baseheader.py index 506cab22c..db69b24ec 100644 --- a/torba/baseheader.py +++ b/torba/baseheader.py @@ -1,14 +1,16 @@ import os import struct +import logging from binascii import unhexlify from twisted.internet import threads, defer -import torba from torba.stream import StreamController, execute_serially from torba.util import int_to_hex, rev_hex, hash_encode from torba.hash import double_sha256, pow_hash +log = logging.getLogger(__name__) + class BaseHeaders: @@ -32,7 +34,7 @@ class BaseHeaders: @property def height(self): - return len(self) - 1 + return len(self) def sync_read_length(self): return os.path.getsize(self.path) // self.header_size @@ -76,7 +78,9 @@ class BaseHeaders: _old_size = self._size self._size = self.sync_read_length() change = self._size - _old_size - #log.info('saved {} header blocks'.format(change)) + log.info('{}: added {} header blocks, final height {}'.format( + self.ledger.get_id(), change, self.height) + ) self._on_change_controller.add(change) def _iterate_headers(self, height, headers): diff --git a/torba/baseledger.py b/torba/baseledger.py index 36d7f6a6e..745fa6fcb 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -1,9 +1,11 @@ import os import six import hashlib +import logging from binascii import hexlify, unhexlify from typing import Dict, Type, Iterable, Generator from operator import itemgetter +from collections import namedtuple from twisted.internet import defer @@ -15,6 +17,8 @@ from torba import basetransaction from torba.stream import StreamController, execute_serially from torba.hash import hash160, double_sha256, Base58 +log = logging.getLogger(__name__) + class LedgerRegistry(type): ledgers = {} # type: Dict[str, Type[BaseLedger]] @@ -33,6 +37,10 @@ class LedgerRegistry(type): return mcs.ledgers[ledger_id] +class TransactionEvent(namedtuple('TransactionEvent', ('address', 'tx', 'height', 'is_verified'))): + pass + + class BaseLedger(six.with_metaclass(LedgerRegistry)): name = None @@ -67,6 +75,14 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): self._on_transaction_controller = StreamController() self.on_transaction = self._on_transaction_controller.stream + self.on_transaction.listen( + lambda e: log.info('({}) on_transaction: address={}, height={}, is_verified={}, tx.id={}'.format( + self.get_id(), e.address, e.height, e.is_verified, e.tx.hex_id) + ) + ) + + self._on_header_controller = StreamController() + self.on_header = self._on_header_controller.stream self._transaction_processing_locks = {} @@ -133,19 +149,15 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): @defer.inlineCallbacks def get_local_status(self, address): address_details = yield self.db.get_address(address) - history = address_details['history'] or b'' - if six.PY2: - history = str(history) - hash = hashlib.sha256(history).digest() + history = address_details['history'] or '' + hash = hashlib.sha256(history.encode()).digest() defer.returnValue(hexlify(hash)) @defer.inlineCallbacks def get_local_history(self, address): address_details = yield self.db.get_address(address) - history = address_details['history'] or b'' - if six.PY2: - history = str(history) - parts = history.split(b':')[:-1] + history = address_details['history'] or '' + parts = history.split(':')[:-1] defer.returnValue(list(zip(parts[0::2], map(int, parts[1::2])))) @staticmethod @@ -162,7 +174,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): @defer.inlineCallbacks def is_valid_transaction(self, tx, height): - len(self.headers) < height or defer.returnValue(False) + height <= len(self.headers) or defer.returnValue(False) merkle = yield self.network.get_merkle(tx.hex_id.decode(), height) merkle_root = self.get_root_of_merkle_tree(merkle['merkle'], merkle['pos'], tx.hash) header = self.headers[height] @@ -193,6 +205,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): if headers['count'] <= 0: break yield self.headers.connect(height_sought, unhexlify(headers['hex'])) + self._on_header_controller.add(height_sought) @defer.inlineCallbacks def process_header(self, response): @@ -202,6 +215,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): if header['height'] == len(self.headers): # New header from network directly connects after the last local header. yield self.headers.connect(len(self.headers), unhexlify(header['hex'])) + self._on_header_controller.add(len(self.headers)) elif header['height'] > len(self.headers): # New header is several heights ahead of local, do download instead. yield self.update_headers() @@ -239,45 +253,45 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): local_history = yield self.get_local_history(address) synced_history = [] - for i, (hash, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): + for i, (hex_id, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): - synced_history.append((hash, remote_height)) + synced_history.append((hex_id, remote_height)) - if i < len(local_history) and local_history[i] == (hash, remote_height): + if i < len(local_history) and local_history[i] == (hex_id, remote_height): continue - lock = self._transaction_processing_locks.setdefault(hash, defer.DeferredLock()) + lock = self._transaction_processing_locks.setdefault(hex_id, defer.DeferredLock()) yield lock.acquire() try: # see if we have a local copy of transaction, otherwise fetch it from server - raw, local_height, is_verified = yield self.db.get_transaction(unhexlify(hash)) + raw, local_height, is_verified = yield self.db.get_transaction(unhexlify(hex_id)[::-1]) save_tx = None if raw is None: - _raw = yield self.network.get_transaction(hash) + _raw = yield self.network.get_transaction(hex_id) tx = self.transaction_class(unhexlify(_raw)) save_tx = 'insert' else: - tx = self.transaction_class(unhexlify(raw)) + tx = self.transaction_class(raw) if remote_height > 0 and not is_verified: is_verified = yield self.is_valid_transaction(tx, remote_height) + is_verified = 1 if is_verified else 0 if save_tx is None: save_tx = 'update' yield self.db.save_transaction_io( save_tx, tx, remote_height, is_verified, address, self.address_to_hash160(address), - ''.join('{}:{}:'.format(hash.decode(), height) for hash, height in synced_history).encode() + ''.join('{}:{}:'.format(tx_id.decode(), tx_height) for tx_id, tx_height in synced_history) ) - if save_tx is not None: - self._on_transaction_controller.add(tx) + self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) finally: lock.release() if not lock.locked: - del self._transaction_processing_locks[hash] + del self._transaction_processing_locks[hex_id] @defer.inlineCallbacks def subscribe_history(self, address): diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 8914b9173..004d8f323 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -124,10 +124,11 @@ class BaseOutput(InputOutput): script_class = BaseOutputScript estimator_class = BaseOutputEffectiveAmountEstimator - def __init__(self, amount, script, txhash=None, index=None): + def __init__(self, amount, script, txhash=None, index=None, txoid=None): super(BaseOutput, self).__init__(txhash, index) self.amount = amount # type: int self.script = script # type: BaseOutputScript + self.txoid = txoid def get_estimator(self, ledger): return self.estimator_class(ledger, self) @@ -288,7 +289,7 @@ class BaseTransaction: @classmethod @defer.inlineCallbacks - def pay(cls, outputs, funding_accounts, change_account): + def pay(cls, outputs, funding_accounts, change_account, reserve_outputs=True): # type: (List[BaseOutput], List[torba.baseaccount.BaseAccount], torba.baseaccount.BaseAccount) -> defer.Deferred """ Efficiently spend utxos from funding_accounts to cover the new outputs. """ @@ -307,15 +308,26 @@ class BaseTransaction: if not spendables: raise ValueError('Not enough funds to cover this transaction.') - spent_sum = sum(s.effective_amount for s in spendables) - if spent_sum > amount: - change_address = yield change_account.change.get_or_create_usable_address() - change_hash160 = change_account.ledger.address_to_hash160(change_address) - change_amount = spent_sum - amount - tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) + reserved_outputs = [s.txo.txoid for s in spendables] + if reserve_outputs: + yield ledger.db.reserve_spent_outputs(reserved_outputs) + + try: + spent_sum = sum(s.effective_amount for s in spendables) + if spent_sum > amount: + change_address = yield change_account.change.get_or_create_usable_address() + change_hash160 = change_account.ledger.address_to_hash160(change_address) + change_amount = spent_sum - amount + tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) + + tx.add_inputs([s.txi for s in spendables]) + yield tx.sign(funding_accounts) + + except Exception: + if reserve_outputs: + yield ledger.db.release_reserved_outputs(reserved_outputs) + raise - tx.add_inputs([s.txi for s in spendables]) - yield tx.sign(funding_accounts) defer.returnValue(tx) @classmethod @@ -354,3 +366,13 @@ class BaseTransaction: @property def output_sum(self): return sum(o.amount for o in self.outputs) + + @defer.inlineCallbacks + def get_my_addresses(self, ledger): + addresses = set() + for txo in self.outputs: + address = ledger.hash160_to_address(txo.script.values['pubkey_hash']) + record = yield ledger.db.get_address(address) + if record is not None: + addresses.add(address) + defer.returnValue(list(addresses)) diff --git a/torba/util.py b/torba/util.py index a6d4b8a52..9683a8dfe 100644 --- a/torba/util.py +++ b/torba/util.py @@ -1,13 +1,17 @@ from binascii import unhexlify, hexlify from collections import Sequence +from typing import TypeVar, Generic -class ReadOnlyList(Sequence): +T = TypeVar('T') + + +class ReadOnlyList(Sequence, Generic[T]): def __init__(self, lst): self.lst = lst - def __getitem__(self, key): + def __getitem__(self, key): # type: (int) -> T return self.lst[key] def __len__(self): From 1dfc18683d05f5feca032b769fa0d29accdbd7e4 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 26 Jun 2018 18:31:42 -0400 Subject: [PATCH 030/383] fixing unit tests --- tests/unit/test_account.py | 4 ++-- tests/unit/test_ledger.py | 46 +++++++++++++++++++++++++------------- torba/basedatabase.py | 15 +++++++++---- torba/baseledger.py | 6 ++--- 4 files changed, 47 insertions(+), 24 deletions(-) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index 95d3a68ab..7c492474f 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -41,13 +41,13 @@ class TestKeyChain(unittest.TestCase): # case #2: only one new addressed needed keys = yield account.receiving.get_addresses(None, True) - yield self.ledger.db.set_address_history(keys[19]['address'], b'a:1:') + yield self.ledger.db.set_address_history(keys[19]['address'], 'a:1:') new_keys = yield account.receiving.ensure_address_gap() self.assertEqual(len(new_keys), 1) # case #3: 20 addresses needed keys = yield account.receiving.get_addresses(None, True) - yield self.ledger.db.set_address_history(keys[0]['address'], b'a:1:') + yield self.ledger.db.set_address_history(keys[0]['address'], 'a:1:') new_keys = yield account.receiving.ensure_address_gap() self.assertEqual(len(new_keys), 20) diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index b36dd7eb5..4e26d6c2d 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -5,7 +5,7 @@ from twisted.internet import defer from torba.coin.bitcoinsegwit import MainNetLedger -from .test_transaction import get_transaction +from .test_transaction import get_transaction, get_output if six.PY3: buffer = memoryview @@ -25,15 +25,30 @@ class MockNetwork: self.address = address return defer.succeed(self.history) + def get_merkle(self, txid, height): + return {'merkle': ['abcd01'], 'pos': 1} + def get_transaction(self, tx_hash): self.get_transaction_called.append(tx_hash) - return defer.succeed(self.transaction[tx_hash]) + return defer.succeed(self.transaction[tx_hash.decode()]) + + +class MockHeaders: + def __init__(self, ledger): + self.ledger = ledger + self.height = 1 + + def __len__(self): + return self.height + + def __getitem__(self, height): + return {'merkle_root': 'abcd04'} class TestSynchronization(unittest.TestCase): def setUp(self): - self.ledger = MainNetLedger(db=MainNetLedger.database_class(':memory:')) + self.ledger = MainNetLedger(db=MainNetLedger.database_class(':memory:'), headers_class=MockHeaders) return self.ledger.db.start() @defer.inlineCallbacks @@ -43,21 +58,22 @@ class TestSynchronization(unittest.TestCase): address_details = yield self.ledger.db.get_address(address) self.assertEqual(address_details['history'], None) + self.ledger.headers.height = 3 self.ledger.network = MockNetwork([ - {'tx_hash': b'abc', 'height': 1}, - {'tx_hash': b'def', 'height': 2}, - {'tx_hash': b'ghi', 'height': 3}, + {'tx_hash': b'abcd01', 'height': 1}, + {'tx_hash': b'abcd02', 'height': 2}, + {'tx_hash': b'abcd03', 'height': 3}, ], { - b'abc': hexlify(get_transaction().raw), - b'def': hexlify(get_transaction().raw), - b'ghi': hexlify(get_transaction().raw), + 'abcd01': hexlify(get_transaction(get_output(1)).raw), + 'abcd02': hexlify(get_transaction(get_output(2)).raw), + 'abcd03': hexlify(get_transaction(get_output(3)).raw), }) yield self.ledger.update_history(address) self.assertEqual(self.ledger.network.get_history_called, [address]) - self.assertEqual(self.ledger.network.get_transaction_called, [b'abc', b'def', b'ghi']) + self.assertEqual(self.ledger.network.get_transaction_called, [b'abcd01', b'abcd02', b'abcd03']) address_details = yield self.ledger.db.get_address(address) - self.assertEqual(address_details['history'], buffer(b'abc:1:def:2:ghi:3:')) + self.assertEqual(address_details['history'], 'abcd01:1:abcd02:2:abcd03:3:') self.ledger.network.get_history_called = [] self.ledger.network.get_transaction_called = [] @@ -65,12 +81,12 @@ class TestSynchronization(unittest.TestCase): self.assertEqual(self.ledger.network.get_history_called, [address]) self.assertEqual(self.ledger.network.get_transaction_called, []) - self.ledger.network.history.append({'tx_hash': b'jkl', 'height': 4}) - self.ledger.network.transaction[b'jkl'] = hexlify(get_transaction().raw) + self.ledger.network.history.append({'tx_hash': b'abcd04', 'height': 4}) + self.ledger.network.transaction['abcd04'] = hexlify(get_transaction(get_output(4)).raw) self.ledger.network.get_history_called = [] self.ledger.network.get_transaction_called = [] yield self.ledger.update_history(address) self.assertEqual(self.ledger.network.get_history_called, [address]) - self.assertEqual(self.ledger.network.get_transaction_called, [b'jkl']) + self.assertEqual(self.ledger.network.get_transaction_called, [b'abcd04']) address_details = yield self.ledger.db.get_address(address) - self.assertEqual(address_details['history'], buffer(b'abc:1:def:2:ghi:3:jkl:4:')) + self.assertEqual(address_details['history'], 'abcd01:1:abcd02:2:abcd03:3:abcd04:4:') diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 6923c6e5e..15092d209 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -208,10 +208,7 @@ class BaseDatabase(SQLiteMixin): 'txoid': txoid[0], })) - t.execute( - "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", - (history, history.count(':')//2, sqlite3.Binary(address)) - ) + self._set_address_history(t, address, history) return self.db.runInteraction(_steps) @@ -318,6 +315,16 @@ class BaseDatabase(SQLiteMixin): sql.append('LIMIT {}'.format(limit)) return ' '.join(sql), params + @staticmethod + def _set_address_history(t, address, history): + t.execute( + "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", + (history, history.count(':')//2, sqlite3.Binary(address)) + ) + + def set_address_history(self, address, history): + return self.db.runInteraction(lambda t: self._set_address_history(t, address, history)) + def get_unused_addresses(self, account, chain): # type: (torba.baseaccount.BaseAccount, int) -> defer.Deferred[List[str]] return self.query_one_value_list(*self._used_address_sql( diff --git a/torba/baseledger.py b/torba/baseledger.py index 745fa6fcb..2ff360b9e 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -61,7 +61,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): default_fee_per_byte = 10 - def __init__(self, config=None, db=None, network=None): + def __init__(self, config=None, db=None, network=None, headers_class=None): self.config = config or {} self.db = db or self.database_class( os.path.join(self.path, "blockchain.db") @@ -70,7 +70,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): self.network.on_header.listen(self.process_header) self.network.on_status.listen(self.process_status) self.accounts = set() - self.headers = self.headers_class(self) + self.headers = (headers_class or self.headers_class)(self) self.fee_per_byte = self.config.get('fee_per_byte', self.default_fee_per_byte) self._on_transaction_controller = StreamController() @@ -257,7 +257,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): synced_history.append((hex_id, remote_height)) - if i < len(local_history) and local_history[i] == (hex_id, remote_height): + if i < len(local_history) and local_history[i] == (hex_id.decode(), remote_height): continue lock = self._transaction_processing_locks.setdefault(hex_id, defer.DeferredLock()) From da265198f1bea1c90abbb484a84e8db697248895 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 26 Jun 2018 20:22:35 -0400 Subject: [PATCH 031/383] cleanup integration test --- tests/integration/test_transactions.py | 49 +++++++++----------------- 1 file changed, 17 insertions(+), 32 deletions(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 939d87a19..2e2818dd0 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -1,5 +1,5 @@ import asyncio -from orchstr8.testcase import IntegrationTestCase +from orchstr8.testcase import IntegrationTestCase, d2f from torba.constants import COIN @@ -10,45 +10,30 @@ class BasicTransactionTests(IntegrationTestCase): async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) - await account1.ensure_address_gap().asFuture(asyncio.get_event_loop()) - self.assertEqual(await self.get_balance(account1), 0) self.assertEqual(await self.get_balance(account2), 0) - address = await account1.receiving.get_or_create_usable_address().asFuture(asyncio.get_event_loop()) - sendtxid = await self.blockchain.send_to_address(address.decode(), 5.5) - await self.on_transaction_id(sendtxid) #mempool + address1 = await d2f(account1.receiving.get_or_create_usable_address()) + sendtxid = await self.blockchain.send_to_address(address1.decode(), 5.5) + await self.on_transaction_id(sendtxid) # mempool await self.blockchain.generate(1) - await self.on_transaction_id(sendtxid) #confirmed + await self.on_transaction_id(sendtxid) # confirmed - self.assertEqual(await self.get_balance(account1), int(5.5*COIN)) - self.assertEqual(await self.get_balance(account2), 0) + self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 5.5) + self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 0) - address = await account2.receiving.get_or_create_usable_address().asFuture(asyncio.get_event_loop()) - hash1 = self.ledger.address_to_hash160(address) - tx = await self.ledger.transaction_class.pay( - [self.ledger.transaction_class.output_class.pay_pubkey_hash(2*COIN, hash1)], + address2 = await d2f(account2.receiving.get_or_create_usable_address()) + hash2 = self.ledger.address_to_hash160(address2) + tx = await d2f(self.ledger.transaction_class.pay( + [self.ledger.transaction_class.output_class.pay_pubkey_hash(2*COIN, hash2)], [account1], account1 - ).asFuture(asyncio.get_event_loop()) + )) await self.broadcast(tx) - await self.on_transaction(tx) #mempool - - tx2 = await self.ledger.transaction_class.pay( - [self.ledger.transaction_class.output_class.pay_pubkey_hash(1*COIN, hash1)], - [account1], account1 - ).asFuture(asyncio.get_event_loop()) - await self.broadcast(tx2) - await self.on_transaction(tx2) #mempool - + await self.on_transaction(tx) # mempool await self.blockchain.generate(1) - await asyncio.wait([ - self.on_header(202), - self.on_transaction(tx), - self.on_transaction(tx2), - ]) + await self.on_transaction(tx) # confirmed - #self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 3.5) - #self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) + self.assertTrue(await d2f(self.ledger.is_valid_transaction(tx, 202))) - self.assertTrue(await self.ledger.is_valid_transaction(tx, 202).asFuture(asyncio.get_event_loop())) - self.assertTrue(await self.ledger.is_valid_transaction(tx2, 202).asFuture(asyncio.get_event_loop())) + self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 3.5) + self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) From c58a1c9eadb37200e27819629922c07b01858d3c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 26 Jun 2018 20:41:03 -0400 Subject: [PATCH 032/383] BaseLedger.stop() should also close the db --- tests/integration/test_transactions.py | 1 - torba/baseledger.py | 4 +++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 2e2818dd0..3f7cb73c3 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -1,4 +1,3 @@ -import asyncio from orchstr8.testcase import IntegrationTestCase, d2f from torba.constants import COIN diff --git a/torba/baseledger.py b/torba/baseledger.py index 2ff360b9e..d7ea7d671 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -193,8 +193,10 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): yield self.network.subscribe_headers() yield self.update_accounts() + @defer.inlineCallbacks def stop(self): - return self.network.stop() + yield self.network.stop() + yield self.db.stop() @execute_serially @defer.inlineCallbacks From 6bb81e4d6f530516c2516e794e63fc9c6ae094e7 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 1 Jul 2018 17:20:17 -0400 Subject: [PATCH 033/383] wip4victor --- tests/integration/test_transactions.py | 20 +++++---- torba/baseheader.py | 8 +++- torba/baseledger.py | 57 +++++++++++++++----------- torba/basenetwork.py | 17 ++++++-- torba/manager.py | 9 ++-- torba/wallet.py | 26 +++++++++--- 6 files changed, 88 insertions(+), 49 deletions(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 3f7cb73c3..4789c7a01 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -1,3 +1,4 @@ +import asyncio from orchstr8.testcase import IntegrationTestCase, d2f from torba.constants import COIN @@ -12,13 +13,18 @@ class BasicTransactionTests(IntegrationTestCase): self.assertEqual(await self.get_balance(account1), 0) self.assertEqual(await self.get_balance(account2), 0) - address1 = await d2f(account1.receiving.get_or_create_usable_address()) - sendtxid = await self.blockchain.send_to_address(address1.decode(), 5.5) - await self.on_transaction_id(sendtxid) # mempool + sendtxids = [] + for i in range(9): + address1 = await d2f(account1.receiving.get_or_create_usable_address()) + sendtxid = await self.blockchain.send_to_address(address1.decode(), 1.1) + sendtxids.append(sendtxid) + await self.on_transaction_id(sendtxid) # mempool await self.blockchain.generate(1) - await self.on_transaction_id(sendtxid) # confirmed + await asyncio.wait([ # confirmed + self.on_transaction_id(txid) for txid in sendtxids + ]) - self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 5.5) + self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 9.9) self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 0) address2 = await d2f(account2.receiving.get_or_create_usable_address()) @@ -32,7 +38,5 @@ class BasicTransactionTests(IntegrationTestCase): await self.blockchain.generate(1) await self.on_transaction(tx) # confirmed - self.assertTrue(await d2f(self.ledger.is_valid_transaction(tx, 202))) - - self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 3.5) + self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 7.9) self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) diff --git a/torba/baseheader.py b/torba/baseheader.py index db69b24ec..8815a6437 100644 --- a/torba/baseheader.py +++ b/torba/baseheader.py @@ -34,7 +34,13 @@ class BaseHeaders: @property def height(self): - return len(self) + return len(self)-1 + + def hash(self, height=None): + if height is None: + height = self.height + header = self[height] + return self._hash_header(header) def sync_read_length(self): return os.path.getsize(self.path) // self.header_size diff --git a/torba/baseledger.py b/torba/baseledger.py index d7ea7d671..5e0396bd3 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -203,7 +203,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): def update_headers(self): while True: height_sought = len(self.headers) - headers = yield self.network.get_headers(height_sought) + headers = yield self.network.get_headers(height_sought, 2000) if headers['count'] <= 0: break yield self.headers.connect(height_sought, unhexlify(headers['hex'])) @@ -266,34 +266,41 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): yield lock.acquire() - try: - # see if we have a local copy of transaction, otherwise fetch it from server - raw, local_height, is_verified = yield self.db.get_transaction(unhexlify(hex_id)[::-1]) - save_tx = None - if raw is None: - _raw = yield self.network.get_transaction(hex_id) - tx = self.transaction_class(unhexlify(_raw)) - save_tx = 'insert' - else: - tx = self.transaction_class(raw) + #try: + # see if we have a local copy of transaction, otherwise fetch it from server + raw, local_height, is_verified = yield self.db.get_transaction(unhexlify(hex_id)[::-1]) + save_tx = None + if raw is None: + _raw = yield self.network.get_transaction(hex_id) + tx = self.transaction_class(unhexlify(_raw)) + save_tx = 'insert' + else: + tx = self.transaction_class(raw) - if remote_height > 0 and not is_verified: - is_verified = yield self.is_valid_transaction(tx, remote_height) - is_verified = 1 if is_verified else 0 - if save_tx is None: - save_tx = 'update' + if remote_height > 0 and not is_verified: + is_verified = yield self.is_valid_transaction(tx, remote_height) + is_verified = 1 if is_verified else 0 + if save_tx is None: + save_tx = 'update' - yield self.db.save_transaction_io( - save_tx, tx, remote_height, is_verified, address, self.address_to_hash160(address), - ''.join('{}:{}:'.format(tx_id.decode(), tx_height) for tx_id, tx_height in synced_history) - ) + yield self.db.save_transaction_io( + save_tx, tx, remote_height, is_verified, address, self.address_to_hash160(address), + ''.join('{}:{}:'.format(tx_id.decode(), tx_height) for tx_id, tx_height in synced_history) + ) - self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) + log.debug("{}: sync'ed tx {} for address: {}, height: {}, verified: {}".format( + self.get_id(), hex_id, address, remote_height, is_verified + )) + self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) - finally: - lock.release() - if not lock.locked: - del self._transaction_processing_locks[hex_id] +# except: +# log.exception('Failed to synchronize transaction:') +# raise +# +# finally: + lock.release() + if not lock.locked: + del self._transaction_processing_locks[hex_id] @defer.inlineCallbacks def subscribe_history(self, address): diff --git a/torba/basenetwork.py b/torba/basenetwork.py index 509eea87f..44720a0c6 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -11,7 +11,10 @@ from twisted.protocols.basic import LineOnlyReceiver from torba import __version__ from torba.stream import StreamController -log = logging.getLogger() +log = logging.getLogger(__name__) + +if six.PY3: + buffer = memoryview def unicode2bytes(string): @@ -23,6 +26,8 @@ def unicode2bytes(string): def bytes2unicode(maybe_bytes): + if isinstance(maybe_bytes, buffer): + maybe_bytes = str(maybe_bytes) if isinstance(maybe_bytes, bytes): return maybe_bytes.decode() elif isinstance(maybe_bytes, (list, tuple)): @@ -32,7 +37,7 @@ def bytes2unicode(maybe_bytes): class StratumClientProtocol(LineOnlyReceiver): delimiter = b'\n' - MAX_LENGTH = 100000 + MAX_LENGTH = 2000000 def __init__(self): self.request_id = 0 @@ -78,6 +83,7 @@ class StratumClientProtocol(LineOnlyReceiver): self.on_disconnected_controller.add(True) def lineReceived(self, line): + log.debug('received: {}'.format(line)) try: # `line` comes in as a byte string but `json.loads` automatically converts everything to @@ -114,6 +120,7 @@ class StratumClientProtocol(LineOnlyReceiver): 'method': method, 'params': [bytes2unicode(arg) for arg in args] }) + log.debug('sent: {}'.format(message)) self.sendLine(message.encode('latin-1')) d = self.lookup_table[message_id] = defer.Deferred() return d @@ -161,17 +168,19 @@ class BaseNetwork: def start(self): for server in cycle(self.config['default_servers']): endpoint = clientFromString(reactor, 'tcp:{}:{}'.format(*server)) + log.debug("Attempting connection to SPV wallet server: {}:{}".format(*server)) self.service = ClientService(endpoint, StratumClientFactory(self)) self.service.startService() try: self.client = yield self.service.whenConnected(failAfterFailures=2) yield self.ensure_server_version() + log.info("Successfully connected to SPV wallet server: {}:{}".format(*server)) self._on_connected_controller.add(True) yield self.client.on_disconnected.first except CancelledError: return - except Exception as e: - pass + except Exception: + log.exception("Connecting to {}:{} raised an exception:".format(*server)) finally: self.client = None if not self.running: diff --git a/torba/manager.py b/torba/manager.py index 42f8e58b2..3dee2064e 100644 --- a/torba/manager.py +++ b/torba/manager.py @@ -15,14 +15,13 @@ class WalletManager(object): @classmethod def from_config(cls, config): # type: (Dict) -> WalletManager - wallets = [] - manager = cls(wallets) - for coin_id, ledger_config in config.get('ledgers', {}).items(): - manager.get_or_create_ledger(coin_id, ledger_config) + manager = cls() + for ledger_id, ledger_config in config.get('ledgers', {}).items(): + manager.get_or_create_ledger(ledger_id, ledger_config) for wallet_path in config.get('wallets', []): wallet_storage = WalletStorage(wallet_path) wallet = Wallet.from_storage(wallet_storage, manager) - wallets.append(wallet) + manager.wallets.append(wallet) return manager def get_or_create_ledger(self, ledger_id, ledger_config=None): diff --git a/torba/wallet.py b/torba/wallet.py index 9ac2d9f76..0ff419089 100644 --- a/torba/wallet.py +++ b/torba/wallet.py @@ -59,12 +59,11 @@ class Wallet: class WalletStorage: - LATEST_VERSION = 2 + LATEST_VERSION = 1 DEFAULT = { 'version': LATEST_VERSION, 'name': 'Wallet', - 'coins': {}, 'accounts': [] } @@ -100,10 +99,25 @@ class WalletStorage: version = json_dict.pop('version', -1) - if version == 1: # upgrade from version 1 to version 2 - _rename_property('addr_history', 'history') - _rename_property('use_encryption', 'encrypted') - _rename_property('gap_limit', 'gap_limit_for_receiving') + if version == -1: # upgrading from electrum wallet + json_dict = { + 'accounts': [{ + 'ledger': 'lbc_mainnet', + 'encrypted': json_dict['use_encryption'], + 'seed': json_dict['seed'], + 'seed_version': json_dict['seed_version'], + 'private_key': json_dict['master_private_keys']['x/'], + 'public_key': json_dict['master_public_keys']['x/'], + 'certificates': json_dict['claim_certificates'], + 'receiving_gap': 20, + 'change_gap': 6, + 'receiving_maximum_use_per_address': 2, + 'change_maximum_use_per_address': 2 + }] + } + + elif version == 1: # upgrade from version 1 to version 2 + pass upgraded = cls.DEFAULT upgraded.update(json_dict) From c3cb297205d9b8f2198a144a4013e9021d7b529c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 4 Jul 2018 20:43:25 -0400 Subject: [PATCH 034/383] unit test fixes and reducing support for py2 --- .travis.yml | 1 - setup.py | 1 - tests/unit/test_wallet.py | 7 ++++--- torba/baseaccount.py | 2 +- torba/baseledger.py | 2 +- torba/wallet.py | 1 + tox.ini | 16 ++++++++-------- 7 files changed, 15 insertions(+), 15 deletions(-) diff --git a/.travis.yml b/.travis.yml index bdd37d199..75f962332 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,7 +1,6 @@ language: python python: - - "2.7" - "3.6" install: diff --git a/setup.py b/setup.py index 57a7fe88e..c0c2f9d9b 100644 --- a/setup.py +++ b/setup.py @@ -18,7 +18,6 @@ setup( 'Intended Audience :: Developers', 'Intended Audience :: System Administrators', 'License :: OSI Approved :: MIT License', - 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Operating System :: OS Independent', 'Topic :: Internet', diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index 5ca3bd904..12d591322 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -11,7 +11,7 @@ class TestWalletCreation(unittest.TestCase): def setUp(self): self.manager = WalletManager() - config = {'wallet_path': '/tmp/wallet'} + config = {'data_path': '/tmp/wallet'} self.btc_ledger = self.manager.get_or_create_ledger(BTCLedger.get_id(), config) self.bch_ledger = self.manager.get_or_create_ledger(BCHLedger.get_id(), config) @@ -28,6 +28,7 @@ class TestWalletCreation(unittest.TestCase): def test_load_and_save_wallet(self): wallet_dict = { + 'version': 1, 'name': 'Main Wallet', 'accounts': [ { @@ -61,11 +62,11 @@ class TestWalletCreation(unittest.TestCase): def test_read_write(self): manager = WalletManager() - config = {'wallet_path': '/tmp/wallet'} + config = {'data_path': '/tmp/wallet'} ledger = manager.get_or_create_ledger(BTCLedger.get_id(), config) with tempfile.NamedTemporaryFile(suffix='.json') as wallet_file: - wallet_file.write(b'{}') + wallet_file.write(b'{"version": 1}') wallet_file.seek(0) # create and write wallet to a file diff --git a/torba/baseaccount.py b/torba/baseaccount.py index d2a5b0c82..524133495 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -64,7 +64,7 @@ class KeyChain: defer.returnValue(addresses[0]) -class BaseAccount: +class BaseAccount(object): mnemonic_class = Mnemonic private_key_class = PrivateKey diff --git a/torba/baseledger.py b/torba/baseledger.py index 5e0396bd3..247be00c9 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -109,7 +109,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): @property def path(self): - return os.path.join(self.config['wallet_path'], self.get_id()) + return os.path.join(self.config['data_path'], self.get_id()) def get_input_output_fee(self, io): """ Fee based on size of the input / output. """ diff --git a/torba/wallet.py b/torba/wallet.py index 0ff419089..e41208329 100644 --- a/torba/wallet.py +++ b/torba/wallet.py @@ -44,6 +44,7 @@ class Wallet: def to_dict(self): return { + 'version': WalletStorage.LATEST_VERSION, 'name': self.name, 'accounts': [a.to_dict() for a in self.accounts] } diff --git a/tox.ini b/tox.ini index d006596dc..746107260 100644 --- a/tox.ini +++ b/tox.ini @@ -1,16 +1,16 @@ [tox] -#envlist = py{27,36}-unit,py36-integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} -envlist = py{27,36}-unit,py36-integration-torba.coin.bitcoinsegwit +#envlist = unit,integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} +envlist = unit,integration-torba.coin.bitcoinsegwit [testenv] deps = coverage - py36-integration: ../orchstr8 - py36-integration: ../electrumx + integration: ../orchstr8 + integration: ../electrumx extras = test changedir = {toxinidir}/tests -setenv = py36-integration: LEDGER={envname} +setenv = integration: LEDGER={envname} commands = - py{27,36}-unit: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial unit - py36-integration: orchstr8 download - py36-integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration + unit: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial unit + integration: orchstr8 download + integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration From dd40d2e6ce61dffc6760ecde46c897d6c45343d3 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 4 Jul 2018 20:51:18 -0400 Subject: [PATCH 035/383] explicit env for tox --- tox.ini | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tox.ini b/tox.ini index 746107260..f859459b7 100644 --- a/tox.ini +++ b/tox.ini @@ -1,6 +1,6 @@ [tox] #envlist = unit,integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} -envlist = unit,integration-torba.coin.bitcoinsegwit +envlist = py36-unit,py36-integration-torba.coin.bitcoinsegwit [testenv] deps = From e2296d449106c69da0937efca7b650ff45fb1099 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 4 Jul 2018 21:17:45 -0400 Subject: [PATCH 036/383] improving code coverage --- tests/unit/test_wallet.py | 3 +-- torba/manager.py | 8 +------- 2 files changed, 2 insertions(+), 9 deletions(-) diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index 12d591322..2adce9dde 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -70,8 +70,7 @@ class TestWalletCreation(unittest.TestCase): wallet_file.seek(0) # create and write wallet to a file - wallet_storage = WalletStorage(wallet_file.name) - wallet = Wallet.from_storage(wallet_storage, manager) + wallet = manager.import_wallet(wallet_file.name) account = wallet.generate_account(ledger) wallet.save() diff --git a/torba/manager.py b/torba/manager.py index 3dee2064e..f535be24e 100644 --- a/torba/manager.py +++ b/torba/manager.py @@ -32,7 +32,7 @@ class WalletManager(object): self.ledgers[ledger_class] = ledger return ledger - def create_wallet(self, path): + def import_wallet(self, path): storage = WalletStorage(path) wallet = Wallet.from_storage(storage, self) self.wallets.append(wallet) @@ -57,12 +57,6 @@ class WalletManager(object): for wallet in self.wallets: return wallet.default_account - def get_accounts(self, coin_class): - for wallet in self.wallets: - for account in wallet.accounts: - if account.coin.__class__ is coin_class: - yield account - @defer.inlineCallbacks def start(self): self.running = True From ae56b81a0889e7badb01d8ee83e12b60d0547d96 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 4 Jul 2018 21:30:38 -0400 Subject: [PATCH 037/383] test manager.get_balance() --- tests/integration/test_transactions.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 4789c7a01..8220de3ac 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -40,3 +40,7 @@ class BasicTransactionTests(IntegrationTestCase): self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 7.9) self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) + + all_balances = await d2f(self.manager.get_balance()) + self.assertIn(self.ledger.get_id(), all_balances) + self.assertEqual(round(all_balances[self.ledger.get_id()]/COIN, 1), 9.9) From 2006ad68ee5a576b27a7490383716492ebae3b32 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 9 Jul 2018 09:55:59 -0400 Subject: [PATCH 038/383] get_balance supports custom constraints --- torba/baseaccount.py | 4 ++-- torba/basedatabase.py | 29 +++++++++++++++++++---------- 2 files changed, 21 insertions(+), 12 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 524133495..6c51611c1 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -173,5 +173,5 @@ class BaseAccount(object): assert not self.encrypted, "Cannot get private key on encrypted wallet account." return self.private_key.child(chain).child(index) - def get_balance(self): - return self.ledger.db.get_balance_for_account(self) + def get_balance(self, **constraints): + return self.ledger.db.get_balance_for_account(self, **constraints) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 15092d209..3b9afa215 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -156,6 +156,15 @@ class BaseDatabase(SQLiteMixin): CREATE_TXI_TABLE ) + def txo_to_row(self, tx, address, txo): + return { + 'txhash': sqlite3.Binary(tx.hash), + 'address': sqlite3.Binary(address), + 'position': txo.index, + 'amount': txo.amount, + 'script': sqlite3.Binary(txo.script.source) + } + def save_transaction_io(self, save_tx, tx, height, is_verified, address, hash, history): def _steps(t): @@ -181,13 +190,7 @@ class BaseDatabase(SQLiteMixin): if txo.index in existing_txos: continue if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == hash: - t.execute(*self._insert_sql("txo", { - 'txhash': sqlite3.Binary(tx.hash), - 'address': sqlite3.Binary(address), - 'position': txo.index, - 'amount': txo.amount, - 'script': sqlite3.Binary(txo.script.source) - })) + t.execute(*self._insert_sql("txo", self.txo_to_row(tx, address, txo))) elif txo.script.is_pay_script_hash: # TODO: implement script hash payments print('Database.save_transaction_io: pay script hash is not implemented!') @@ -233,15 +236,21 @@ class BaseDatabase(SQLiteMixin): defer.returnValue((None, None, False)) @defer.inlineCallbacks - def get_balance_for_account(self, account): + def get_balance_for_account(self, account, **constraints): + extra_sql = "" + if constraints: + extra_sql = ' AND ' + ' AND '.join( + '{} = :{}'.format(c, c) for c in constraints.keys() + ) + values = {'account': sqlite3.Binary(account.public_key.address)} + values.update(constraints) result = yield self.db.runQuery( """ SELECT SUM(amount) FROM txo JOIN pubkey_address ON pubkey_address.address=txo.address WHERE account=:account AND txoid NOT IN (SELECT txoid FROM txi) - """, - {'account': sqlite3.Binary(account.public_key.address)} + """+extra_sql, values ) if result: defer.returnValue(result[0][0] or 0) From 5eb276655dba4a217889a420a2b2d27dead7d815 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 9 Jul 2018 20:22:04 -0400 Subject: [PATCH 039/383] + Transaction.liquidate, balance/get_utxos support constraints --- torba/baseaccount.py | 3 ++ torba/basedatabase.py | 21 ++++++++++--- torba/baseledger.py | 67 +++++++++++++++++++--------------------- torba/basetransaction.py | 33 +++++++++++++++++++- torba/bip32.py | 4 +-- 5 files changed, 86 insertions(+), 42 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 6c51611c1..f8d46dd03 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -175,3 +175,6 @@ class BaseAccount(object): def get_balance(self, **constraints): return self.ledger.db.get_balance_for_account(self, **constraints) + + def get_unspent_outputs(self, **constraints): + return self.ledger.db.get_utxos_for_account(self, **constraints) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 3b9afa215..92efd97b9 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -225,6 +225,12 @@ class BaseDatabase(SQLiteMixin): def release_reserved_outputs(self, txoids): return self.reserve_spent_outputs(txoids, is_reserved=False) + def get_txoid_for_txo(self, txo): + return self.query_one_value( + "SELECT txoid FROM txo WHERE txhash = ? AND position = ?", + (sqlite3.Binary(txo.transaction.hash), txo.index) + ) + @defer.inlineCallbacks def get_transaction(self, txhash): result = yield self.db.runQuery( @@ -258,15 +264,22 @@ class BaseDatabase(SQLiteMixin): defer.returnValue(0) @defer.inlineCallbacks - def get_utxos(self, account, output_class): + def get_utxos_for_account(self, account, **constraints): + extra_sql = "" + if constraints: + extra_sql = ' AND ' + ' AND '.join( + '{} = :{}'.format(c, c) for c in constraints.keys() + ) + values = {'account': sqlite3.Binary(account.public_key.address)} + values.update(constraints) utxos = yield self.db.runQuery( """ SELECT amount, script, txhash, txo.position, txoid FROM txo JOIN pubkey_address ON pubkey_address.address=txo.address WHERE account=:account AND txo.is_reserved=0 AND txoid NOT IN (SELECT txoid FROM txi) - """, - {'account': sqlite3.Binary(account.public_key.address)} + """+extra_sql, values ) + output_class = account.ledger.transaction_class.output_class defer.returnValue([ output_class( values[0], @@ -335,7 +348,7 @@ class BaseDatabase(SQLiteMixin): return self.db.runInteraction(lambda t: self._set_address_history(t, address, history)) def get_unused_addresses(self, account, chain): - # type: (torba.baseaccount.BaseAccount, int) -> defer.Deferred[List[str]] + # type: (torba.baseaccount.BaseAccount, Union[int,None]) -> defer.Deferred[List[str]] return self.query_one_value_list(*self._used_address_sql( account, chain, '=', 0 )) diff --git a/torba/baseledger.py b/torba/baseledger.py index 247be00c9..57170279c 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -133,15 +133,12 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): if bytes(match['account']) == account.public_key.address: defer.returnValue(account.get_private_key(match['chain'], match['position'])) - def get_unspent_outputs(self, account): - return self.db.get_utxos(account, self.transaction_class.output_class) - @defer.inlineCallbacks def get_effective_amount_estimators(self, funding_accounts): # type: (Iterable[baseaccount.BaseAccount]) -> defer.Deferred estimators = [] for account in funding_accounts: - utxos = yield self.get_unspent_outputs(account) + utxos = yield account.get_unspent_outputs() for utxo in utxos: estimators.append(utxo.get_estimator(self)) defer.returnValue(estimators) @@ -266,41 +263,41 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): yield lock.acquire() - #try: - # see if we have a local copy of transaction, otherwise fetch it from server - raw, local_height, is_verified = yield self.db.get_transaction(unhexlify(hex_id)[::-1]) - save_tx = None - if raw is None: - _raw = yield self.network.get_transaction(hex_id) - tx = self.transaction_class(unhexlify(_raw)) - save_tx = 'insert' - else: - tx = self.transaction_class(raw) + try: + # see if we have a local copy of transaction, otherwise fetch it from server + raw, local_height, is_verified = yield self.db.get_transaction(unhexlify(hex_id)[::-1]) + save_tx = None + if raw is None: + _raw = yield self.network.get_transaction(hex_id) + tx = self.transaction_class(unhexlify(_raw)) + save_tx = 'insert' + else: + tx = self.transaction_class(raw) - if remote_height > 0 and not is_verified: - is_verified = yield self.is_valid_transaction(tx, remote_height) - is_verified = 1 if is_verified else 0 - if save_tx is None: - save_tx = 'update' + if remote_height > 0 and not is_verified: + is_verified = yield self.is_valid_transaction(tx, remote_height) + is_verified = 1 if is_verified else 0 + if save_tx is None: + save_tx = 'update' - yield self.db.save_transaction_io( - save_tx, tx, remote_height, is_verified, address, self.address_to_hash160(address), - ''.join('{}:{}:'.format(tx_id.decode(), tx_height) for tx_id, tx_height in synced_history) - ) + yield self.db.save_transaction_io( + save_tx, tx, remote_height, is_verified, address, self.address_to_hash160(address), + ''.join('{}:{}:'.format(tx_id.decode(), tx_height) for tx_id, tx_height in synced_history) + ) - log.debug("{}: sync'ed tx {} for address: {}, height: {}, verified: {}".format( - self.get_id(), hex_id, address, remote_height, is_verified - )) - self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) + log.debug("{}: sync'ed tx {} for address: {}, height: {}, verified: {}".format( + self.get_id(), hex_id, address, remote_height, is_verified + )) + self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) -# except: -# log.exception('Failed to synchronize transaction:') -# raise -# -# finally: - lock.release() - if not lock.locked: - del self._transaction_processing_locks[hex_id] + except: + log.exception('Failed to synchronize transaction:') + raise + + finally: + lock.release() + if not lock.locked: + del self._transaction_processing_locks[hex_id] @defer.inlineCallbacks def subscribe_history(self, address): diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 004d8f323..6eaf14ac3 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -331,9 +331,40 @@ class BaseTransaction: defer.returnValue(tx) @classmethod - def liquidate(cls, assets, funding_accounts, change_account): + @defer.inlineCallbacks + def liquidate(cls, assets, funding_accounts, change_account, reserve_outputs=True): """ Spend assets (utxos) supplementing with funding_accounts if fee is higher than asset value. """ + tx = cls().add_inputs([ + cls.input_class.spend(utxo) for utxo in assets + ]) + ledger = cls.ensure_all_have_same_ledger(funding_accounts, change_account) + + reserved_outputs = [utxo.txoid for utxo in assets] + if reserve_outputs: + yield ledger.db.reserve_spent_outputs(reserved_outputs) + + try: + cost_of_change = ( + ledger.get_transaction_base_fee(tx) + + ledger.get_input_output_fee(cls.output_class.pay_pubkey_hash(COIN, NULL_HASH)) + ) + liquidated_total = sum(utxo.amount for utxo in assets) + if liquidated_total > cost_of_change: + change_address = yield change_account.change.get_or_create_usable_address() + change_hash160 = change_account.ledger.address_to_hash160(change_address) + change_amount = liquidated_total - cost_of_change + tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) + + yield tx.sign(funding_accounts) + + except Exception: + if reserve_outputs: + yield ledger.db.release_reserved_outputs(reserved_outputs) + raise + + defer.returnValue(tx) + def signature_hash_type(self, hash_type): return hash_type diff --git a/torba/bip32.py b/torba/bip32.py index 2f605f98a..5bb06cd1e 100644 --- a/torba/bip32.py +++ b/torba/bip32.py @@ -97,11 +97,11 @@ class PubKey(_KeyBase): raise TypeError('pubkey must be raw bytes') if len(pubkey) != 33: raise ValueError('pubkey must be 33 bytes') - if byte2int(pubkey[0]) not in (2, 3): + if indexbytes(pubkey, 0) not in (2, 3): raise ValueError('invalid pubkey prefix byte') curve = cls.CURVE.curve - is_odd = byte2int(pubkey[0]) == 3 + is_odd = indexbytes(pubkey, 0) == 3 x = bytes_to_int(pubkey[1:]) # p is the finite field order From 630a805c49e411131253258a3d2d88e1aa9ac77d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 9 Jul 2018 20:22:18 -0400 Subject: [PATCH 040/383] improved test coverage for bip32 --- tests/unit/test_bip32.py | 74 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 tests/unit/test_bip32.py diff --git a/tests/unit/test_bip32.py b/tests/unit/test_bip32.py new file mode 100644 index 000000000..a10572bd7 --- /dev/null +++ b/tests/unit/test_bip32.py @@ -0,0 +1,74 @@ +from binascii import unhexlify +from twisted.trial import unittest +from torba.bip32 import PubKey, PrivateKey, from_extended_key_string +from torba.coin.bitcoinsegwit import MainNetLedger + + +class BIP32Tests(unittest.TestCase): + + def test_pubkey_validation(self): + with self.assertRaisesRegex(TypeError, 'chain code must be raw bytes'): + PubKey(None, None, 1, None, None, None) + with self.assertRaisesRegex(ValueError, 'invalid chain code'): + PubKey(None, None, b'abcd', None, None, None) + with self.assertRaisesRegex(ValueError, 'invalid child number'): + PubKey(None, None, b'abcd'*8, -1, None, None) + with self.assertRaisesRegex(ValueError, 'invalid depth'): + PubKey(None, None, b'abcd'*8, 0, 256, None) + with self.assertRaisesRegex(TypeError, 'pubkey must be raw bytes'): + PubKey(None, None, b'abcd'*8, 0, 255, None) + with self.assertRaisesRegex(ValueError, 'pubkey must be 33 bytes'): + PubKey(None, b'abcd', b'abcd'*8, 0, 255, None) + with self.assertRaisesRegex(ValueError, 'invalid pubkey prefix byte'): + PubKey( + None, + unhexlify('33d1a3dc8155673bc1e2214fa493ccc82d57961b66054af9b6b653ac28eeef3ffe'), + b'abcd'*8, 0, 255, None + ) + pubkey = PubKey( # success + None, + unhexlify('03d1a3dc8155673bc1e2214fa493ccc82d57961b66054af9b6b653ac28eeef3ffe'), + b'abcd'*8, 0, 1, None + ) + with self.assertRaisesRegex(ValueError, 'invalid BIP32 public key child number'): + pubkey.child(-1) + self.assertIsInstance(pubkey.child(1), PubKey) + + def test_private_key_validation(self): + with self.assertRaisesRegex(TypeError, 'private key must be raw bytes'): + PrivateKey(None, None, b'abcd'*8, 0, 255) + with self.assertRaisesRegex(ValueError, 'private key must be 32 bytes'): + PrivateKey(None, b'abcd', b'abcd'*8, 0, 255) + private_key = PrivateKey( + MainNetLedger(db=True), + unhexlify('2423f3dc6087d9683f73a684935abc0ccd8bc26370588f56653128c6a6f0bf7c'), + b'abcd'*8, 0, 1 + ) + ec_point = private_key.ec_point() + self.assertEqual( + ec_point.x(), 30487144161998778625547553412379759661411261804838752332906558028921886299019 + ) + self.assertEqual( + ec_point.y(), 86198965946979720220333266272536217633917099472454294641561154971209433250106 + ) + self.assertEqual(private_key.address(), b'1GVM5dEhThbiyCZ9gqBZBv6p9whga7MTXo' ) + with self.assertRaisesRegex(ValueError, 'invalid BIP32 private key child number'): + private_key.child(-1) + self.assertIsInstance(private_key.child(PrivateKey.HARDENED), PrivateKey) + + def test_from_extended_keys(self): + ledger = MainNetLedger(db=True) + self.assertIsInstance( + from_extended_key_string( + ledger, + 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + '6yz3jMbycrLrRMpeAJxR8qDg8', + ), PrivateKey + ) + self.assertIsInstance( + from_extended_key_string( + ledger, + 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' + 'iW44g14WF52fYC5J483wqQ5ZP', + ), PubKey + ) From 4a0d461446d56c6d9889f1bd0cb392a716ee8ed6 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 9 Jul 2018 20:57:09 -0400 Subject: [PATCH 041/383] use extensible branch of electrumx --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 75f962332..6097e8300 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,7 +5,7 @@ python: install: - pip install tox-travis coverage - - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch packages && popd + - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch extensible && popd - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd script: tox From c9c3585e1eef954bc91f260ce7fc8113b8bdb83a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 9 Jul 2018 22:02:18 -0400 Subject: [PATCH 042/383] test for Transaction.liquidate --- tests/integration/test_transactions.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 8220de3ac..0f62e12b2 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -44,3 +44,12 @@ class BasicTransactionTests(IntegrationTestCase): all_balances = await d2f(self.manager.get_balance()) self.assertIn(self.ledger.get_id(), all_balances) self.assertEqual(round(all_balances[self.ledger.get_id()]/COIN, 1), 9.9) + + utxos = await d2f(self.account.get_unspent_outputs()) + tx = await d2f(self.ledger.transaction_class.liquidate( + [utxos[0]], [account1], account1 + )) + await self.broadcast(tx) + await self.on_transaction(tx) # mempool + await self.blockchain.generate(1) + await self.on_transaction(tx) # confirmed From 5db792e99c7ab90f4fd51ef6bb3f848d81a3db75 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 10 Jul 2018 21:09:49 -0400 Subject: [PATCH 043/383] .travis.yml: electrumx master now contains the extensibility feature --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 6097e8300..9e8cbd914 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,7 +5,7 @@ python: install: - pip install tox-travis coverage - - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch extensible && popd + - pushd .. && git clone https://github.com/lbryio/electrumx.git && popd - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd script: tox From 565b095a8dc3434faa0a95fadda069ac8fe30e15 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 10 Jul 2018 21:17:07 -0400 Subject: [PATCH 044/383] have to keep using old electrumx until we upgrade everywhere --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 9e8cbd914..cc452243a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,7 +5,7 @@ python: install: - pip install tox-travis coverage - - pushd .. && git clone https://github.com/lbryio/electrumx.git && popd + - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch lbryumx && popd - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd script: tox From feac754925aff2c0cc08233228d5785f42f4d1aa Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 10 Jul 2018 21:23:13 -0400 Subject: [PATCH 045/383] reduce verbosity for integration test --- tests/integration/test_transactions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 0f62e12b2..d19cb778a 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -5,7 +5,7 @@ from torba.constants import COIN class BasicTransactionTests(IntegrationTestCase): - VERBOSE = True + VERBOSE = False async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) From 32ba594e557031068c63615d06bace2f42b285d0 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 11 Jul 2018 22:37:15 -0400 Subject: [PATCH 046/383] ledger API cleanup --- tests/unit/test_ledger.py | 12 ++++++- torba/baseledger.py | 68 +++++++++++++++++++-------------------- torba/wallet.py | 52 ++++++------------------------ 3 files changed, 55 insertions(+), 77 deletions(-) diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index 4e26d6c2d..af8b51bb4 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -45,10 +45,20 @@ class MockHeaders: return {'merkle_root': 'abcd04'} +class MainNetTestLedger(MainNetLedger): + headers_class = MockHeaders + network_name = 'unittest' + + def __init__(self): + super(MainNetLedger, self).__init__({ + 'db': MainNetLedger.database_class(':memory:') + }) + + class TestSynchronization(unittest.TestCase): def setUp(self): - self.ledger = MainNetLedger(db=MainNetLedger.database_class(':memory:'), headers_class=MockHeaders) + self.ledger = MainNetTestLedger() return self.ledger.db.start() @defer.inlineCallbacks diff --git a/torba/baseledger.py b/torba/baseledger.py index 57170279c..26adbc86f 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -61,16 +61,16 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): default_fee_per_byte = 10 - def __init__(self, config=None, db=None, network=None, headers_class=None): + def __init__(self, config=None): self.config = config or {} - self.db = db or self.database_class( + self.db = self.config.get('db') or self.database_class( os.path.join(self.path, "blockchain.db") ) # type: basedatabase.BaseDatabase - self.network = network or self.network_class(self) + self.network = self.config.get('network') or self.network_class(self) self.network.on_header.listen(self.process_header) self.network.on_status.listen(self.process_status) self.accounts = set() - self.headers = (headers_class or self.headers_class)(self) + self.headers = self.config.get('headers') or self.headers_class(self) self.fee_per_byte = self.config.get('fee_per_byte', self.default_fee_per_byte) self._on_transaction_controller = StreamController() @@ -263,41 +263,41 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): yield lock.acquire() - try: - # see if we have a local copy of transaction, otherwise fetch it from server - raw, local_height, is_verified = yield self.db.get_transaction(unhexlify(hex_id)[::-1]) - save_tx = None - if raw is None: - _raw = yield self.network.get_transaction(hex_id) - tx = self.transaction_class(unhexlify(_raw)) - save_tx = 'insert' - else: - tx = self.transaction_class(raw) + #try: + # see if we have a local copy of transaction, otherwise fetch it from server + raw, local_height, is_verified = yield self.db.get_transaction(unhexlify(hex_id)[::-1]) + save_tx = None + if raw is None: + _raw = yield self.network.get_transaction(hex_id) + tx = self.transaction_class(unhexlify(_raw)) + save_tx = 'insert' + else: + tx = self.transaction_class(raw) - if remote_height > 0 and not is_verified: - is_verified = yield self.is_valid_transaction(tx, remote_height) - is_verified = 1 if is_verified else 0 - if save_tx is None: - save_tx = 'update' + if remote_height > 0 and not is_verified: + is_verified = yield self.is_valid_transaction(tx, remote_height) + is_verified = 1 if is_verified else 0 + if save_tx is None: + save_tx = 'update' - yield self.db.save_transaction_io( - save_tx, tx, remote_height, is_verified, address, self.address_to_hash160(address), - ''.join('{}:{}:'.format(tx_id.decode(), tx_height) for tx_id, tx_height in synced_history) - ) + yield self.db.save_transaction_io( + save_tx, tx, remote_height, is_verified, address, self.address_to_hash160(address), + ''.join('{}:{}:'.format(tx_id.decode(), tx_height) for tx_id, tx_height in synced_history) + ) - log.debug("{}: sync'ed tx {} for address: {}, height: {}, verified: {}".format( - self.get_id(), hex_id, address, remote_height, is_verified - )) - self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) + log.debug("{}: sync'ed tx {} for address: {}, height: {}, verified: {}".format( + self.get_id(), hex_id, address, remote_height, is_verified + )) + self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) - except: - log.exception('Failed to synchronize transaction:') - raise + #except: + # log.exception('Failed to synchronize transaction:') + # raise - finally: - lock.release() - if not lock.locked: - del self._transaction_processing_locks[hex_id] + #finally: + lock.release() + if not lock.locked: + del self._transaction_processing_locks[hex_id] @defer.inlineCallbacks def subscribe_history(self, address): diff --git a/torba/wallet.py b/torba/wallet.py index e41208329..1fe486396 100644 --- a/torba/wallet.py +++ b/torba/wallet.py @@ -62,23 +62,17 @@ class WalletStorage: LATEST_VERSION = 1 - DEFAULT = { - 'version': LATEST_VERSION, - 'name': 'Wallet', - 'accounts': [] - } - def __init__(self, path=None, default=None): self.path = path - self._default = default or self.DEFAULT.copy() - - @property - def default(self): - return self._default.copy() + self._default = default or { + 'version': self.LATEST_VERSION, + 'name': 'My Wallet', + 'accounts': [] + } def read(self): if self.path and os.path.exists(self.path): - with open(self.path, "r") as f: + with open(self.path, 'r') as f: json_data = f.read() json_dict = json.loads(json_data) if json_dict.get('version') == self.LATEST_VERSION and \ @@ -87,40 +81,14 @@ class WalletStorage: else: return self.upgrade(json_dict) else: - return self.default + return self._default.copy() - @classmethod - def upgrade(cls, json_dict): + def upgrade(self, json_dict): json_dict = json_dict.copy() - - def _rename_property(old, new): - if old in json_dict: - json_dict[new] = json_dict[old] - del json_dict[old] - version = json_dict.pop('version', -1) - - if version == -1: # upgrading from electrum wallet - json_dict = { - 'accounts': [{ - 'ledger': 'lbc_mainnet', - 'encrypted': json_dict['use_encryption'], - 'seed': json_dict['seed'], - 'seed_version': json_dict['seed_version'], - 'private_key': json_dict['master_private_keys']['x/'], - 'public_key': json_dict['master_public_keys']['x/'], - 'certificates': json_dict['claim_certificates'], - 'receiving_gap': 20, - 'change_gap': 6, - 'receiving_maximum_use_per_address': 2, - 'change_maximum_use_per_address': 2 - }] - } - - elif version == 1: # upgrade from version 1 to version 2 + if version == -1: pass - - upgraded = cls.DEFAULT + upgraded = self._default.copy() upgraded.update(json_dict) return json_dict From 0ffec82e3505c5bb170c73af69df64c18c24d67d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 11 Jul 2018 22:47:44 -0400 Subject: [PATCH 047/383] unit test fixes --- tests/unit/test_account.py | 4 ++-- tests/unit/test_bip32.py | 4 ++-- tests/unit/test_transaction.py | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index 7c492474f..4e26c68e5 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -8,7 +8,7 @@ from torba.coin.bitcoinsegwit import MainNetLedger class TestKeyChain(unittest.TestCase): def setUp(self): - self.ledger = MainNetLedger(db=MainNetLedger.database_class(':memory:')) + self.ledger = MainNetLedger({'db': MainNetLedger.database_class(':memory:')}) return self.ledger.db.start() @defer.inlineCallbacks @@ -68,7 +68,7 @@ class TestKeyChain(unittest.TestCase): class TestAccount(unittest.TestCase): def setUp(self): - self.ledger = MainNetLedger(db=MainNetLedger.database_class(':memory:')) + self.ledger = MainNetLedger({'db': MainNetLedger.database_class(':memory:')}) return self.ledger.db.start() @defer.inlineCallbacks diff --git a/tests/unit/test_bip32.py b/tests/unit/test_bip32.py index a10572bd7..90fcac263 100644 --- a/tests/unit/test_bip32.py +++ b/tests/unit/test_bip32.py @@ -40,7 +40,7 @@ class BIP32Tests(unittest.TestCase): with self.assertRaisesRegex(ValueError, 'private key must be 32 bytes'): PrivateKey(None, b'abcd', b'abcd'*8, 0, 255) private_key = PrivateKey( - MainNetLedger(db=True), + MainNetLedger({'db': True}), unhexlify('2423f3dc6087d9683f73a684935abc0ccd8bc26370588f56653128c6a6f0bf7c'), b'abcd'*8, 0, 1 ) @@ -57,7 +57,7 @@ class BIP32Tests(unittest.TestCase): self.assertIsInstance(private_key.child(PrivateKey.HARDENED), PrivateKey) def test_from_extended_keys(self): - ledger = MainNetLedger(db=True) + ledger = MainNetLedger({'db': True}) self.assertIsInstance( from_extended_key_string( ledger, diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index 56b25caa0..65b4334e8 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -30,7 +30,7 @@ def get_transaction(txo=None): class TestSizeAndFeeEstimation(unittest.TestCase): def setUp(self): - self.ledger = ledger_class(db=ledger_class.database_class(':memory:')) + self.ledger = ledger_class({'db': ledger_class.database_class(':memory:')}) return self.ledger.db.start() def io_fee(self, io): @@ -143,7 +143,7 @@ class TestTransactionSerialization(unittest.TestCase): class TestTransactionSigning(unittest.TestCase): def setUp(self): - self.ledger = ledger_class(db=ledger_class.database_class(':memory:')) + self.ledger = ledger_class({'db': ledger_class.database_class(':memory:')}) return self.ledger.db.start() @defer.inlineCallbacks From 1ce5da80d688ff3ef12d43206e90f85224429a80 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 11 Jul 2018 22:49:54 -0400 Subject: [PATCH 048/383] unit test fixes take 2 --- tests/unit/test_coinselection.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_coinselection.py b/tests/unit/test_coinselection.py index b304fdefb..b2adbbd92 100644 --- a/tests/unit/test_coinselection.py +++ b/tests/unit/test_coinselection.py @@ -19,7 +19,7 @@ def search(*args, **kwargs): class BaseSelectionTestCase(unittest.TestCase): def setUp(self): - self.ledger = MainNetLedger(db=MainNetLedger.database_class(':memory:')) + self.ledger = MainNetLedger({'db': MainNetLedger.database_class(':memory:')}) return self.ledger.db.start() def estimates(self, *args): From adec71501066f58928e05e5991aaaaeb66da1fca Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 12 Jul 2018 12:14:04 -0400 Subject: [PATCH 049/383] + ledger.get_transaction() --- torba/baseledger.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/torba/baseledger.py b/torba/baseledger.py index 26adbc86f..339b111ef 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -125,6 +125,12 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): if self.network.is_connected: yield self.update_account(account) + @defer.inlineCallbacks + def get_transaction(self, txhash): + raw, height, is_verified = yield self.db.get_transaction(txhash) + if raw is not None: + defer.returnValue(self.transaction_class(raw)) + @defer.inlineCallbacks def get_private_key_for_address(self, address): match = yield self.db.get_address(address) From f46550262f3f6f1f81088611116f91e697aa247d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 14 Jul 2018 17:47:18 -0400 Subject: [PATCH 050/383] added SingleKey account support --- tests/unit/test_account.py | 290 ++++++++++++++++++++++++++++--------- torba/baseaccount.py | 197 ++++++++++++++++++------- torba/baseledger.py | 2 +- 3 files changed, 366 insertions(+), 123 deletions(-) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index 4e26c68e5..f937a12d5 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -3,77 +3,21 @@ from twisted.trial import unittest from twisted.internet import defer from torba.coin.bitcoinsegwit import MainNetLedger +from torba.baseaccount import KeyChain, SingleKey -class TestKeyChain(unittest.TestCase): - - def setUp(self): - self.ledger = MainNetLedger({'db': MainNetLedger.database_class(':memory:')}) - return self.ledger.db.start() +class TestKeyChainAccount(unittest.TestCase): @defer.inlineCallbacks - def test_address_gap_algorithm(self): - account = self.ledger.account_class.generate(self.ledger, u"torba") - - # save records out of order to make sure we're really testing ORDER BY - # and not coincidentally getting records in the correct order - yield account.receiving.generate_keys(4, 7) - yield account.receiving.generate_keys(0, 3) - yield account.receiving.generate_keys(8, 11) - keys = yield account.receiving.get_addresses(None, True) - self.assertEqual( - [key['position'] for key in keys], - [11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0] - ) - - # we have 12, but default gap is 20 - new_keys = yield account.receiving.ensure_address_gap() - self.assertEqual(len(new_keys), 8) - keys = yield account.receiving.get_addresses(None, True) - self.assertEqual( - [key['position'] for key in keys], - [19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0] - ) - - # case #1: no new addresses needed - empty = yield account.receiving.ensure_address_gap() - self.assertEqual(len(empty), 0) - - # case #2: only one new addressed needed - keys = yield account.receiving.get_addresses(None, True) - yield self.ledger.db.set_address_history(keys[19]['address'], 'a:1:') - new_keys = yield account.receiving.ensure_address_gap() - self.assertEqual(len(new_keys), 1) - - # case #3: 20 addresses needed - keys = yield account.receiving.get_addresses(None, True) - yield self.ledger.db.set_address_history(keys[0]['address'], 'a:1:') - new_keys = yield account.receiving.ensure_address_gap() - self.assertEqual(len(new_keys), 20) - - @defer.inlineCallbacks - def test_create_usable_address(self): - account = self.ledger.account_class.generate(self.ledger, u"torba") - - keys = yield account.receiving.get_addresses(None, True) - self.assertEqual(len(keys), 0) - - address = yield account.receiving.get_or_create_usable_address() - self.assertIsNotNone(address) - - keys = yield account.receiving.get_addresses(None, True) - self.assertEqual(len(keys), 20) - - -class TestAccount(unittest.TestCase): - def setUp(self): self.ledger = MainNetLedger({'db': MainNetLedger.database_class(':memory:')}) - return self.ledger.db.start() + yield self.ledger.db.start() + self.account = self.ledger.account_class.generate(self.ledger, u"torba") @defer.inlineCallbacks def test_generate_account(self): - account = self.ledger.account_class.generate(self.ledger, u"torba") + account = self.account + self.assertEqual(account.ledger, self.ledger) self.assertIsNotNone(account.seed) self.assertEqual(account.public_key.ledger, self.ledger) @@ -91,13 +35,68 @@ class TestAccount(unittest.TestCase): addresses = yield account.change.get_addresses() self.assertEqual(len(addresses), 6) + addresses = yield account.get_addresses() + self.assertEqual(len(addresses), 26) + + @defer.inlineCallbacks + def test_ensure_address_gap(self): + account = self.account + + self.assertIsInstance(account.receiving, KeyChain) + + yield account.receiving.generate_keys(4, 7) + yield account.receiving.generate_keys(0, 3) + yield account.receiving.generate_keys(8, 11) + records = yield account.receiving.get_address_records() + self.assertEqual( + [r['position'] for r in records], + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] + ) + + # we have 12, but default gap is 20 + new_keys = yield account.receiving.ensure_address_gap() + self.assertEqual(len(new_keys), 8) + records = yield account.receiving.get_address_records() + self.assertEqual( + [r['position'] for r in records], + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] + ) + + # case #1: no new addresses needed + empty = yield account.receiving.ensure_address_gap() + self.assertEqual(len(empty), 0) + + # case #2: only one new addressed needed + records = yield account.receiving.get_address_records() + yield self.ledger.db.set_address_history(records[0]['address'], 'a:1:') + new_keys = yield account.receiving.ensure_address_gap() + self.assertEqual(len(new_keys), 1) + + # case #3: 20 addresses needed + yield self.ledger.db.set_address_history(new_keys[0], 'a:1:') + new_keys = yield account.receiving.ensure_address_gap() + self.assertEqual(len(new_keys), 20) + + @defer.inlineCallbacks + def test_get_or_create_usable_address(self): + account = self.account + + keys = yield account.receiving.get_addresses() + self.assertEqual(len(keys), 0) + + address = yield account.receiving.get_or_create_usable_address() + self.assertIsNotNone(address) + + keys = yield account.receiving.get_addresses() + self.assertEqual(len(keys), 20) + @defer.inlineCallbacks def test_generate_account_from_seed(self): account = self.ledger.account_class.from_seed( self.ledger, u"carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" u"sent", - u"torba" + u"torba", receiving_gap=3, change_gap=2 ) self.assertEqual( account.private_key.extended_key_string(), @@ -112,7 +111,6 @@ class TestAccount(unittest.TestCase): address = yield account.receiving.ensure_address_gap() self.assertEqual(address[0], b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') - self.maxDiff = None private_key = yield self.ledger.get_private_key_for_address(b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') self.assertEqual( private_key.extended_key_string(), @@ -131,6 +129,7 @@ class TestAccount(unittest.TestCase): @defer.inlineCallbacks def test_load_and_save_account(self): account_data = { + 'name': 'My Account', 'seed': "carbon smart garage balance margin twelve chest sword toast envelope bottom stomac" "h absent", @@ -141,10 +140,11 @@ class TestAccount(unittest.TestCase): 'public_key': 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' 'iW44g14WF52fYC5J483wqQ5ZP', - 'receiving_gap': 10, - 'receiving_maximum_use_per_address': 2, - 'change_gap': 10, - 'change_maximum_use_per_address': 2 + 'is_hd': True, + 'receiving_gap': 5, + 'receiving_maximum_uses_per_address': 2, + 'change_gap': 5, + 'change_maximum_uses_per_address': 2 } account = self.ledger.account_class.from_dict(self.ledger, account_data) @@ -152,9 +152,159 @@ class TestAccount(unittest.TestCase): yield account.ensure_address_gap() addresses = yield account.receiving.get_addresses() - self.assertEqual(len(addresses), 10) + self.assertEqual(len(addresses), 5) addresses = yield account.change.get_addresses() - self.assertEqual(len(addresses), 10) + self.assertEqual(len(addresses), 5) + + self.maxDiff = None + account_data['ledger'] = 'btc_mainnet' + self.assertDictEqual(account_data, account.to_dict()) + + +class TestSingleKeyAccount(unittest.TestCase): + + @defer.inlineCallbacks + def setUp(self): + self.ledger = MainNetLedger({'db': MainNetLedger.database_class(':memory:')}) + yield self.ledger.db.start() + self.account = self.ledger.account_class.generate(self.ledger, u"torba", is_hd=False) + + @defer.inlineCallbacks + def test_generate_account(self): + account = self.account + + self.assertEqual(account.ledger, self.ledger) + self.assertIsNotNone(account.seed) + self.assertEqual(account.public_key.ledger, self.ledger) + self.assertEqual(account.private_key.public_key, account.public_key) + + addresses = yield account.receiving.get_addresses() + self.assertEqual(len(addresses), 0) + addresses = yield account.change.get_addresses() + self.assertEqual(len(addresses), 0) + + yield account.ensure_address_gap() + + addresses = yield account.receiving.get_addresses() + self.assertEqual(len(addresses), 1) + self.assertEqual(addresses[0], account.public_key.address) + addresses = yield account.change.get_addresses() + self.assertEqual(len(addresses), 1) + self.assertEqual(addresses[0], account.public_key.address) + + addresses = yield account.get_addresses() + self.assertEqual(len(addresses), 1) + self.assertEqual(addresses[0], account.public_key.address) + + @defer.inlineCallbacks + def test_ensure_address_gap(self): + account = self.account + + self.assertIsInstance(account.receiving, SingleKey) + addresses = yield account.receiving.get_addresses() + self.assertEqual(addresses, []) + + # we have 12, but default gap is 20 + new_keys = yield account.receiving.ensure_address_gap() + self.assertEqual(len(new_keys), 1) + self.assertEqual(new_keys[0], account.public_key.address) + records = yield account.receiving.get_address_records() + self.assertEqual(records, [{ + 'position': 0, 'address': account.public_key.address, 'used_times': 0 + }]) + + # case #1: no new addresses needed + empty = yield account.receiving.ensure_address_gap() + self.assertEqual(len(empty), 0) + + # case #2: after use, still no new address needed + records = yield account.receiving.get_address_records() + yield self.ledger.db.set_address_history(records[0]['address'], 'a:1:') + empty = yield account.receiving.ensure_address_gap() + self.assertEqual(len(empty), 0) + + @defer.inlineCallbacks + def test_get_or_create_usable_address(self): + account = self.account + + addresses = yield account.receiving.get_addresses() + self.assertEqual(len(addresses), 0) + + address1 = yield account.receiving.get_or_create_usable_address() + self.assertIsNotNone(address1) + + yield self.ledger.db.set_address_history(address1, 'a:1:b:2:c:3:') + records = yield account.receiving.get_address_records() + self.assertEqual(records[0]['used_times'], 3) + + address2 = yield account.receiving.get_or_create_usable_address() + self.assertEqual(address1, address2) + + keys = yield account.receiving.get_addresses() + self.assertEqual(len(keys), 1) + + @defer.inlineCallbacks + def test_generate_account_from_seed(self): + account = self.ledger.account_class.from_seed( + self.ledger, + u"carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" + u"sent", + u"torba", + is_hd=False + ) + self.assertEqual( + account.private_key.extended_key_string(), + b'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + b'6yz3jMbycrLrRMpeAJxR8qDg8' + ) + self.assertEqual( + account.public_key.extended_key_string(), + b'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' + b'iW44g14WF52fYC5J483wqQ5ZP' + ) + address = yield account.receiving.ensure_address_gap() + self.assertEqual(address[0], account.public_key.address) + + private_key = yield self.ledger.get_private_key_for_address(address[0]) + self.assertEqual( + private_key.extended_key_string(), + b'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + b'6yz3jMbycrLrRMpeAJxR8qDg8' + ) + + invalid_key = yield self.ledger.get_private_key_for_address(b'BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX') + self.assertIsNone(invalid_key) + + self.assertEqual( + hexlify(private_key.wif()), + b'1c2423f3dc6087d9683f73a684935abc0ccd8bc26370588f56653128c6a6f0bf7c01' + ) + + @defer.inlineCallbacks + def test_load_and_save_account(self): + account_data = { + 'name': 'My Account', + 'seed': + "carbon smart garage balance margin twelve chest sword toast envelope bottom stomac" + "h absent", + 'encrypted': False, + 'private_key': + 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + '6yz3jMbycrLrRMpeAJxR8qDg8', + 'public_key': + 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' + 'iW44g14WF52fYC5J483wqQ5ZP', + 'is_hd': False + } + + account = self.ledger.account_class.from_dict(self.ledger, account_data) + + yield account.ensure_address_gap() + + addresses = yield account.receiving.get_addresses() + self.assertEqual(len(addresses), 1) + addresses = yield account.change.get_addresses() + self.assertEqual(len(addresses), 1) self.maxDiff = None account_data['ledger'] = 'btc_mainnet' diff --git a/torba/baseaccount.py b/torba/baseaccount.py index f8d46dd03..ec29a184a 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -7,30 +7,60 @@ from torba.bip32 import PrivateKey, PubKey, from_extended_key_string from torba.hash import double_sha256, aes_encrypt, aes_decrypt -class KeyChain: +class KeyManager(object): - def __init__(self, account, parent_key, chain_number, gap, maximum_use_per_address): - # type: ('BaseAccount', PubKey, int, int, int) -> None + __slots__ = 'account', 'public_key', 'chain_number' + + def __init__(self, account, public_key, chain_number): self.account = account - self.db = account.ledger.db - self.main_key = parent_key.child(chain_number) + self.public_key = public_key self.chain_number = chain_number - self.gap = gap - self.maximum_use_per_address = maximum_use_per_address - def get_addresses(self, limit=None, details=False): - return self.db.get_addresses(self.account, self.chain_number, limit, details) + @property + def db(self): + return self.account.ledger.db - def get_usable_addresses(self, limit=None): - return self.db.get_usable_addresses( - self.account, self.chain_number, self.maximum_use_per_address, limit + def _query_addresses(self, limit=None, max_used_times=None, order_by=None): + return self.db.get_addresses( + self.account, self.chain_number, limit, max_used_times, order_by ) + def ensure_address_gap(self): # type: () -> defer.Deferred + raise NotImplementedError + + def get_address_records(self, limit=None, only_usable=False): # type: (int, bool) -> defer.Deferred + raise NotImplementedError + + @defer.inlineCallbacks + def get_addresses(self, limit=None, only_usable=False): # type: (int, bool) -> defer.Deferred + records = yield self.get_address_records(limit=limit, only_usable=only_usable) + defer.returnValue([r['address'] for r in records]) + + @defer.inlineCallbacks + def get_or_create_usable_address(self): # type: () -> defer.Deferred + addresses = yield self.get_addresses(limit=1, only_usable=True) + if addresses: + defer.returnValue(addresses[0]) + addresses = yield self.ensure_address_gap() + defer.returnValue(addresses[0]) + + +class KeyChain(KeyManager): + """ Implements simple version of Bitcoin Hierarchical Deterministic key management. """ + + __slots__ = 'gap', 'maximum_uses_per_address' + + def __init__(self, account, root_public_key, chain_number, gap, maximum_uses_per_address): + # type: ('BaseAccount', PubKey, int, int, int) -> None + super(KeyChain, self).__init__(account, root_public_key.child(chain_number), chain_number) + self.gap = gap + self.maximum_uses_per_address = maximum_uses_per_address + @defer.inlineCallbacks def generate_keys(self, start, end): new_keys = [] for index in range(start, end+1): - new_keys.append((index, self.main_key.child(index))) + new_keys.append((index, self.public_key.child(index))) yield self.db.add_keys( self.account, self.chain_number, new_keys ) @@ -38,7 +68,7 @@ class KeyChain: @defer.inlineCallbacks def ensure_address_gap(self): - addresses = yield self.get_addresses(self.gap, True) + addresses = yield self._query_addresses(self.gap, None, "position DESC") existing_gap = 0 for address in addresses: @@ -55,13 +85,34 @@ class KeyChain: new_keys = yield self.generate_keys(start, end-1) defer.returnValue(new_keys) + def get_address_records(self, limit=None, only_usable=False): + return self._query_addresses( + limit, self.maximum_uses_per_address if only_usable else None, + "used_times ASC, position ASC" + ) + + +class SingleKey(KeyManager): + """ Single Key manager always returns the same address for all operations. """ + + __slots__ = () + + def __init__(self, account, root_public_key, chain_number): + # type: ('BaseAccount', PubKey) -> None + super(SingleKey, self).__init__(account, root_public_key, chain_number) + @defer.inlineCallbacks - def get_or_create_usable_address(self): - addresses = yield self.get_usable_addresses(1) - if addresses: - defer.returnValue(addresses[0]) - addresses = yield self.ensure_address_gap() - defer.returnValue(addresses[0]) + def ensure_address_gap(self): + exists = yield self.get_address_records() + if not exists: + yield self.db.add_keys( + self.account, self.chain_number, [(0, self.public_key)] + ) + defer.returnValue([self.public_key.address]) + defer.returnValue([]) + + def get_address_records(self, **kwargs): + return self._query_addresses() class BaseAccount(object): @@ -70,34 +121,43 @@ class BaseAccount(object): private_key_class = PrivateKey public_key_class = PubKey - def __init__(self, ledger, seed, encrypted, private_key, + def __init__(self, ledger, name, seed, encrypted, is_hd, private_key, public_key, receiving_gap=20, change_gap=6, - receiving_maximum_use_per_address=2, change_maximum_use_per_address=2): - # type: (torba.baseledger.BaseLedger, str, bool, PrivateKey, PubKey, int, int, int, int) -> None + receiving_maximum_uses_per_address=2, change_maximum_uses_per_address=2): + # type: (torba.baseledger.BaseLedger, str, str, bool, bool, PrivateKey, PubKey, int, int, int, int) -> None self.ledger = ledger + self.name = name self.seed = seed self.encrypted = encrypted self.private_key = private_key self.public_key = public_key - self.receiving, self.change = self.keychains = ( - KeyChain(self, public_key, 0, receiving_gap, receiving_maximum_use_per_address), - KeyChain(self, public_key, 1, change_gap, change_maximum_use_per_address) - ) + if is_hd: + receiving, change = self.keychains = ( + KeyChain(self, public_key, 0, receiving_gap, receiving_maximum_uses_per_address), + KeyChain(self, public_key, 1, change_gap, change_maximum_uses_per_address) + ) + else: + self.keychains = SingleKey(self, public_key, 0), + receiving = change = self.keychains[0] + self.receiving = receiving # type: KeyManager + self.change = change # type: KeyManager ledger.add_account(self) @classmethod - def generate(cls, ledger, password): # type: (torba.baseledger.BaseLedger, str) -> BaseAccount + def generate(cls, ledger, password, **kwargs): # type: (torba.baseledger.BaseLedger, str) -> BaseAccount seed = cls.mnemonic_class().make_seed() - return cls.from_seed(ledger, seed, password) + return cls.from_seed(ledger, seed, password, **kwargs) @classmethod - def from_seed(cls, ledger, seed, password): + def from_seed(cls, ledger, seed, password, is_hd=True, **kwargs): # type: (torba.baseledger.BaseLedger, str, str) -> BaseAccount private_key = cls.get_private_key_from_seed(ledger, seed, password) return cls( - ledger=ledger, seed=seed, encrypted=False, + ledger=ledger, name='Account #{}'.format(private_key.public_key.address), + seed=seed, encrypted=False, is_hd=is_hd, private_key=private_key, - public_key=private_key.public_key + public_key=private_key.public_key, + **kwargs ) @classmethod @@ -109,38 +169,60 @@ class BaseAccount(object): @classmethod def from_dict(cls, ledger, d): # type: (torba.baseledger.BaseLedger, Dict) -> BaseAccount - if not d['encrypted']: + if not d['encrypted'] and d['private_key']: private_key = from_extended_key_string(ledger, d['private_key']) public_key = private_key.public_key else: private_key = d['private_key'] public_key = from_extended_key_string(ledger, d['public_key']) - return cls( + + kwargs = dict( ledger=ledger, + name=d['name'], seed=d['seed'], encrypted=d['encrypted'], private_key=private_key, public_key=public_key, - receiving_gap=d['receiving_gap'], - change_gap=d['change_gap'], - receiving_maximum_use_per_address=d['receiving_maximum_use_per_address'], - change_maximum_use_per_address=d['change_maximum_use_per_address'] + is_hd=False ) + if d['is_hd']: + kwargs.update(dict( + receiving_gap=d['receiving_gap'], + change_gap=d['change_gap'], + receiving_maximum_uses_per_address=d['receiving_maximum_uses_per_address'], + change_maximum_uses_per_address=d['change_maximum_uses_per_address'], + is_hd=True + )) + + return cls(**kwargs) + def to_dict(self): - return { + private_key = self.private_key + if not self.encrypted and self.private_key: + private_key = self.private_key.extended_key_string().decode() + + d = { 'ledger': self.ledger.get_id(), + 'name': self.name, 'seed': self.seed, 'encrypted': self.encrypted, - 'private_key': self.private_key if self.encrypted else - self.private_key.extended_key_string().decode(), + 'private_key': private_key, 'public_key': self.public_key.extended_key_string().decode(), - 'receiving_gap': self.receiving.gap, - 'change_gap': self.change.gap, - 'receiving_maximum_use_per_address': self.receiving.maximum_use_per_address, - 'change_maximum_use_per_address': self.change.maximum_use_per_address + 'is_hd': False } + if isinstance(self.receiving, KeyChain) and isinstance(self.change, KeyChain): + d.update({ + 'receiving_gap': self.receiving.gap, + 'change_gap': self.change.gap, + 'receiving_maximum_uses_per_address': self.receiving.maximum_uses_per_address, + 'change_maximum_uses_per_address': self.change.maximum_uses_per_address, + 'is_hd': True + }) + + return d + def decrypt(self, password): assert self.encrypted, "Key is not encrypted." secret = double_sha256(password) @@ -163,18 +245,29 @@ class BaseAccount(object): addresses.extend(new_addresses) defer.returnValue(addresses) - def get_addresses(self, limit=None, details=False): - return self.ledger.db.get_addresses(self, None, limit, details) + @defer.inlineCallbacks + def get_addresses(self, limit=None, max_used_times=None): # type: (int, int) -> defer.Deferred + records = yield self.get_address_records(limit, max_used_times) + defer.returnValue([r['address'] for r in records]) - def get_unused_addresses(self): - return self.ledger.db.get_unused_addresses(self, None) + def get_address_records(self, limit=None, max_used_times=None): # type: (int, int) -> defer.Deferred + return self.ledger.db.get_addresses(self, None, limit, max_used_times) def get_private_key(self, chain, index): assert not self.encrypted, "Cannot get private key on encrypted wallet account." - return self.private_key.child(chain).child(index) + if isinstance(self.receiving, SingleKey): + return self.private_key + else: + return self.private_key.child(chain).child(index) - def get_balance(self, **constraints): - return self.ledger.db.get_balance_for_account(self, **constraints) + def get_balance(self, confirmations, **constraints): + if confirmations == 0: + return self.ledger.db.get_balance_for_account(self, **constraints) + else: + height = self.ledger.headers.height - (confirmations-1) + return self.ledger.db.get_balance_for_account( + self, height__lte=height, height__not=-1, **constraints + ) def get_unspent_outputs(self, **constraints): return self.ledger.db.get_utxos_for_account(self, **constraints) diff --git a/torba/baseledger.py b/torba/baseledger.py index 339b111ef..fba46c48b 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -238,7 +238,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): # need to update anyways. Continue to get history and create more addresses until # all missing addresses are created and history for them is fully restored. yield account.ensure_address_gap() - addresses = yield account.get_unused_addresses() + addresses = yield account.get_addresses(max_used_times=0) while addresses: yield defer.DeferredList([ self.update_history(a) for a in addresses From 9370b1d2fa46ef2b7a2a6ab265102d3c1f69099d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 14 Jul 2018 17:47:51 -0400 Subject: [PATCH 051/383] switching most columns from blob to text --- torba/basedatabase.py | 138 ++++++++++++++++++++---------------------- 1 file changed, 67 insertions(+), 71 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 92efd97b9..d8c4b12c0 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -108,32 +108,32 @@ class SQLiteMixin(object): class BaseDatabase(SQLiteMixin): + CREATE_PUBKEY_ADDRESS_TABLE = """ + create table if not exists pubkey_address ( + address text primary key, + account text not null, + chain integer not null, + position integer not null, + pubkey text not null, + history text, + used_times integer not null default 0 + ); + """ + CREATE_TX_TABLE = """ create table if not exists tx ( - txhash blob primary key, + txid text primary key, raw blob not null, height integer not null, is_verified boolean not null default 0 ); """ - CREATE_PUBKEY_ADDRESS_TABLE = """ - create table if not exists pubkey_address ( - address blob primary key, - account blob not null, - chain integer not null, - position integer not null, - pubkey blob not null, - history text, - used_times integer not null default 0 - ); - """ - CREATE_TXO_TABLE = """ create table if not exists txo ( - txoid integer primary key, - txhash blob references tx, - address blob references pubkey_address, + txoid text primary key, + txid text references tx, + address text references pubkey_address, position integer not null, amount integer not null, script blob not null, @@ -143,9 +143,9 @@ class BaseDatabase(SQLiteMixin): CREATE_TXI_TABLE = """ create table if not exists txi ( - txhash blob references tx, - address blob references pubkey_address, - txoid integer references txo + txid text references tx, + txoid text references txo, + address text references pubkey_address ); """ @@ -158,9 +158,9 @@ class BaseDatabase(SQLiteMixin): def txo_to_row(self, tx, address, txo): return { - 'txhash': sqlite3.Binary(tx.hash), + 'txid': sqlite3.Binary(tx.hash), 'address': sqlite3.Binary(address), - 'position': txo.index, + 'position': txo.position, 'amount': txo.amount, 'script': sqlite3.Binary(txo.script.source) } @@ -245,17 +245,26 @@ class BaseDatabase(SQLiteMixin): def get_balance_for_account(self, account, **constraints): extra_sql = "" if constraints: - extra_sql = ' AND ' + ' AND '.join( - '{} = :{}'.format(c, c) for c in constraints.keys() - ) + extras = [] + for key in constraints.keys(): + col, op = key, '=' + if key.endswith('__not'): + col, op = key[:-len('__not')], '!=' + elif key.endswith('__lte'): + col, op = key[:-len('__lte')], '<=' + extras.append('{} {} :{}'.format(col, op, key)) + extra_sql = ' AND ' + ' AND '.join(extras) values = {'account': sqlite3.Binary(account.public_key.address)} values.update(constraints) result = yield self.db.runQuery( """ - SELECT SUM(amount) FROM txo - JOIN pubkey_address ON pubkey_address.address=txo.address - WHERE account=:account AND - txoid NOT IN (SELECT txoid FROM txi) + SELECT SUM(amount) + FROM txo + JOIN tx ON tx.txhash=txo.txhash + JOIN pubkey_address ON pubkey_address.address=txo.address + WHERE + pubkey_address.account=:account AND + txoid NOT IN (SELECT txoid FROM txi) """+extra_sql, values ) if result: @@ -305,38 +314,6 @@ class BaseDatabase(SQLiteMixin): values.append(sqlite3.Binary(pubkey.pubkey_bytes)) return self.db.runOperation(sql, values) - def get_addresses(self, account, chain, limit=None, details=False): - sql = ["SELECT {} FROM pubkey_address WHERE account = :account"] - params = {'account': sqlite3.Binary(account.public_key.address)} - if chain is not None: - sql.append("AND chain = :chain") - params['chain'] = chain - sql.append("ORDER BY position DESC") - if limit is not None: - sql.append("LIMIT {}".format(limit)) - if details: - return self.query_dict_value_list(' '.join(sql), ('address', 'position', 'used_times'), params) - else: - return self.query_one_value_list(' '.join(sql).format('address'), params) - - def _used_address_sql(self, account, chain, comparison_op, used_times, limit=None): - sql = [ - "SELECT address FROM pubkey_address", - "WHERE account = :account AND" - ] - params = { - 'account': sqlite3.Binary(account.public_key.address), - 'used_times': used_times - } - if chain is not None: - sql.append("chain = :chain AND") - params['chain'] = chain - sql.append("used_times {} :used_times".format(comparison_op)) - sql.append("ORDER BY used_times ASC") - if limit is not None: - sql.append('LIMIT {}'.format(limit)) - return ' '.join(sql), params - @staticmethod def _set_address_history(t, address, history): t.execute( @@ -347,20 +324,39 @@ class BaseDatabase(SQLiteMixin): def set_address_history(self, address, history): return self.db.runInteraction(lambda t: self._set_address_history(t, address, history)) - def get_unused_addresses(self, account, chain): - # type: (torba.baseaccount.BaseAccount, Union[int,None]) -> defer.Deferred[List[str]] - return self.query_one_value_list(*self._used_address_sql( - account, chain, '=', 0 - )) + def get_addresses(self, account, chain, limit=None, max_used_times=None, order_by=None): + columns = ['account', 'chain', 'position', 'address', 'used_times'] + sql = ["SELECT {} FROM pubkey_address"] - def get_usable_addresses(self, account, chain, max_used_times, limit): - return self.query_one_value_list(*self._used_address_sql( - account, chain, '<=', max_used_times, limit - )) + where = [] + params = {} + if account is not None: + params["account"] = account.public_key.address + where.append("account = :account") + columns.remove("account") + if chain is not None: + params["chain"] = chain + where.append("chain = :chain") + columns.remove("chain") + if max_used_times is not None: + params["used_times"] = max_used_times + where.append("used_times <= :used_times") + + if where: + sql.append("WHERE") + sql.append(" AND ".join(where)) + + if order_by: + sql.append("ORDER BY {}".format(order_by)) + + if limit is not None: + sql.append("LIMIT {}".format(limit)) + + return self.query_dict_value_list(" ".join(sql), columns, params) def get_address(self, address): return self.query_dict_value( - "SELECT {} FROM pubkey_address WHERE address= :address", + "SELECT {} FROM pubkey_address WHERE address = :address", ('address', 'account', 'chain', 'position', 'pubkey', 'history', 'used_times'), - {'address': sqlite3.Binary(address)} + {'address': address} ) From 184d3a5910ff6d4cb4c9a9a23d75910e6d8a5430 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 14 Jul 2018 21:34:07 -0400 Subject: [PATCH 052/383] switched from blob to text for most columns, added a new TXRef/TXORef referencing scheme --- tests/integration/test_transactions.py | 12 +- tests/unit/test_account.py | 43 +++--- tests/unit/test_bip32.py | 2 +- tests/unit/test_ledger.py | 14 +- tests/unit/test_transaction.py | 42 +++--- tests/unit/test_wallet.py | 6 +- torba/baseaccount.py | 6 +- torba/basedatabase.py | 68 +++++----- torba/baseledger.py | 14 +- torba/basenetwork.py | 37 +----- torba/basetransaction.py | 173 +++++++++++++++---------- torba/coinselection.py | 6 +- torba/constants.py | 1 + torba/hash.py | 64 ++++++++- torba/manager.py | 18 ++- 15 files changed, 281 insertions(+), 225 deletions(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index d19cb778a..6b44a90d1 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -14,9 +14,9 @@ class BasicTransactionTests(IntegrationTestCase): self.assertEqual(await self.get_balance(account2), 0) sendtxids = [] - for i in range(9): + for i in range(5): address1 = await d2f(account1.receiving.get_or_create_usable_address()) - sendtxid = await self.blockchain.send_to_address(address1.decode(), 1.1) + sendtxid = await self.blockchain.send_to_address(address1, 1.1) sendtxids.append(sendtxid) await self.on_transaction_id(sendtxid) # mempool await self.blockchain.generate(1) @@ -24,7 +24,7 @@ class BasicTransactionTests(IntegrationTestCase): self.on_transaction_id(txid) for txid in sendtxids ]) - self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 9.9) + self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 5.5) self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 0) address2 = await d2f(account2.receiving.get_or_create_usable_address()) @@ -38,13 +38,9 @@ class BasicTransactionTests(IntegrationTestCase): await self.blockchain.generate(1) await self.on_transaction(tx) # confirmed - self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 7.9) + self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 3.5) self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) - all_balances = await d2f(self.manager.get_balance()) - self.assertIn(self.ledger.get_id(), all_balances) - self.assertEqual(round(all_balances[self.ledger.get_id()]/COIN, 1), 9.9) - utxos = await d2f(self.account.get_unspent_outputs()) tx = await d2f(self.ledger.transaction_class.liquidate( [utxos[0]], [account1], account1 diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index f937a12d5..bc6726449 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -94,31 +94,30 @@ class TestKeyChainAccount(unittest.TestCase): def test_generate_account_from_seed(self): account = self.ledger.account_class.from_seed( self.ledger, - u"carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" - u"sent", - u"torba", receiving_gap=3, change_gap=2 + "carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" + "sent", "torba", receiving_gap=3, change_gap=2 ) self.assertEqual( account.private_key.extended_key_string(), - b'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - b'6yz3jMbycrLrRMpeAJxR8qDg8' + 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + '6yz3jMbycrLrRMpeAJxR8qDg8' ) self.assertEqual( account.public_key.extended_key_string(), - b'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' - b'iW44g14WF52fYC5J483wqQ5ZP' + 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' + 'iW44g14WF52fYC5J483wqQ5ZP' ) address = yield account.receiving.ensure_address_gap() - self.assertEqual(address[0], b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') + self.assertEqual(address[0], '1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') - private_key = yield self.ledger.get_private_key_for_address(b'1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') + private_key = yield self.ledger.get_private_key_for_address('1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') self.assertEqual( private_key.extended_key_string(), - b'xprv9xNEfQ296VTRaEUDZ8oKq74xw2U6kpj486vFUB4K1wT9U25GX4UwuzFgJN1YuRrqkQ5TTwCpkYnjNpSoH' - b'SBaEigNHPkoeYbuPMRo6mRUjxg' + 'xprv9xNEfQ296VTRaEUDZ8oKq74xw2U6kpj486vFUB4K1wT9U25GX4UwuzFgJN1YuRrqkQ5TTwCpkYnjNpSoH' + 'SBaEigNHPkoeYbuPMRo6mRUjxg' ) - invalid_key = yield self.ledger.get_private_key_for_address(b'BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX') + invalid_key = yield self.ledger.get_private_key_for_address('BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX') self.assertIsNone(invalid_key) self.assertEqual( @@ -247,20 +246,18 @@ class TestSingleKeyAccount(unittest.TestCase): def test_generate_account_from_seed(self): account = self.ledger.account_class.from_seed( self.ledger, - u"carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" - u"sent", - u"torba", - is_hd=False + "carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" + "sent", "torba", is_hd=False ) self.assertEqual( account.private_key.extended_key_string(), - b'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - b'6yz3jMbycrLrRMpeAJxR8qDg8' + 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + '6yz3jMbycrLrRMpeAJxR8qDg8' ) self.assertEqual( account.public_key.extended_key_string(), - b'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' - b'iW44g14WF52fYC5J483wqQ5ZP' + 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' + 'iW44g14WF52fYC5J483wqQ5ZP' ) address = yield account.receiving.ensure_address_gap() self.assertEqual(address[0], account.public_key.address) @@ -268,11 +265,11 @@ class TestSingleKeyAccount(unittest.TestCase): private_key = yield self.ledger.get_private_key_for_address(address[0]) self.assertEqual( private_key.extended_key_string(), - b'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - b'6yz3jMbycrLrRMpeAJxR8qDg8' + 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' + '6yz3jMbycrLrRMpeAJxR8qDg8' ) - invalid_key = yield self.ledger.get_private_key_for_address(b'BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX') + invalid_key = yield self.ledger.get_private_key_for_address('BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX') self.assertIsNone(invalid_key) self.assertEqual( diff --git a/tests/unit/test_bip32.py b/tests/unit/test_bip32.py index 90fcac263..2854da74b 100644 --- a/tests/unit/test_bip32.py +++ b/tests/unit/test_bip32.py @@ -51,7 +51,7 @@ class BIP32Tests(unittest.TestCase): self.assertEqual( ec_point.y(), 86198965946979720220333266272536217633917099472454294641561154971209433250106 ) - self.assertEqual(private_key.address(), b'1GVM5dEhThbiyCZ9gqBZBv6p9whga7MTXo' ) + self.assertEqual(private_key.address(), '1GVM5dEhThbiyCZ9gqBZBv6p9whga7MTXo' ) with self.assertRaisesRegex(ValueError, 'invalid BIP32 private key child number'): private_key.child(-1) self.assertIsInstance(private_key.child(PrivateKey.HARDENED), PrivateKey) diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index af8b51bb4..708d2fc4d 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -30,7 +30,7 @@ class MockNetwork: def get_transaction(self, tx_hash): self.get_transaction_called.append(tx_hash) - return defer.succeed(self.transaction[tx_hash.decode()]) + return defer.succeed(self.transaction[tx_hash]) class MockHeaders: @@ -70,9 +70,9 @@ class TestSynchronization(unittest.TestCase): self.ledger.headers.height = 3 self.ledger.network = MockNetwork([ - {'tx_hash': b'abcd01', 'height': 1}, - {'tx_hash': b'abcd02', 'height': 2}, - {'tx_hash': b'abcd03', 'height': 3}, + {'tx_hash': 'abcd01', 'height': 1}, + {'tx_hash': 'abcd02', 'height': 2}, + {'tx_hash': 'abcd03', 'height': 3}, ], { 'abcd01': hexlify(get_transaction(get_output(1)).raw), 'abcd02': hexlify(get_transaction(get_output(2)).raw), @@ -80,7 +80,7 @@ class TestSynchronization(unittest.TestCase): }) yield self.ledger.update_history(address) self.assertEqual(self.ledger.network.get_history_called, [address]) - self.assertEqual(self.ledger.network.get_transaction_called, [b'abcd01', b'abcd02', b'abcd03']) + self.assertEqual(self.ledger.network.get_transaction_called, ['abcd01', 'abcd02', 'abcd03']) address_details = yield self.ledger.db.get_address(address) self.assertEqual(address_details['history'], 'abcd01:1:abcd02:2:abcd03:3:') @@ -91,12 +91,12 @@ class TestSynchronization(unittest.TestCase): self.assertEqual(self.ledger.network.get_history_called, [address]) self.assertEqual(self.ledger.network.get_transaction_called, []) - self.ledger.network.history.append({'tx_hash': b'abcd04', 'height': 4}) + self.ledger.network.history.append({'tx_hash': 'abcd04', 'height': 4}) self.ledger.network.transaction['abcd04'] = hexlify(get_transaction(get_output(4)).raw) self.ledger.network.get_history_called = [] self.ledger.network.get_transaction_called = [] yield self.ledger.update_history(address) self.assertEqual(self.ledger.network.get_history_called, [address]) - self.assertEqual(self.ledger.network.get_transaction_called, [b'abcd04']) + self.assertEqual(self.ledger.network.get_transaction_called, ['abcd04']) address_details = yield self.ledger.db.get_address(address) self.assertEqual(address_details['history'], 'abcd01:1:abcd02:2:abcd03:3:abcd04:4:') diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index 65b4334e8..5966cf374 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -71,11 +71,11 @@ class TestTransactionSerialization(unittest.TestCase): self.assertEqual(len(tx.outputs), 1) coinbase = tx.inputs[0] - self.assertEqual(coinbase.output_txhash, NULL_HASH) - self.assertEqual(coinbase.output_index, 0xFFFFFFFF) + self.assertTrue(coinbase.txo_ref.is_null, NULL_HASH) + self.assertEqual(coinbase.txo_ref.position, 0xFFFFFFFF) self.assertEqual(coinbase.sequence, 4294967295) - self.assertTrue(coinbase.is_coinbase) - self.assertEqual(coinbase.script, None) + self.assertIsNotNone(coinbase.coinbase) + self.assertIsNone(coinbase.script) self.assertEqual( coinbase.coinbase[8:], b'The Times 03/Jan/2009 Chancellor on brink of second bailout for banks' @@ -83,7 +83,7 @@ class TestTransactionSerialization(unittest.TestCase): out = tx.outputs[0] self.assertEqual(out.amount, 5000000000) - self.assertEqual(out.index, 0) + self.assertEqual(out.position, 0) self.assertTrue(out.script.is_pay_pubkey) self.assertFalse(out.script.is_pay_pubkey_hash) self.assertFalse(out.script.is_pay_script_hash) @@ -106,19 +106,16 @@ class TestTransactionSerialization(unittest.TestCase): self.assertEqual(len(tx.outputs), 2) coinbase = tx.inputs[0] - self.assertEqual(coinbase.output_txhash, NULL_HASH) - self.assertEqual(coinbase.output_index, 0xFFFFFFFF) + self.assertTrue(coinbase.txo_ref.is_null) + self.assertEqual(coinbase.txo_ref.position, 0xFFFFFFFF) self.assertEqual(coinbase.sequence, 4294967295) - self.assertTrue(coinbase.is_coinbase) - self.assertEqual(coinbase.script, None) - self.assertEqual( - coinbase.coinbase[9:22], - b'/BTC.COM/NYA/' - ) + self.assertIsNotNone(coinbase.coinbase) + self.assertIsNone(coinbase.script) + self.assertEqual(coinbase.coinbase[9:22], b'/BTC.COM/NYA/') out = tx.outputs[0] self.assertEqual(out.amount, 1561039505) - self.assertEqual(out.index, 0) + self.assertEqual(out.position, 0) self.assertFalse(out.script.is_pay_pubkey) self.assertFalse(out.script.is_pay_pubkey_hash) self.assertTrue(out.script.is_pay_script_hash) @@ -126,7 +123,7 @@ class TestTransactionSerialization(unittest.TestCase): out1 = tx.outputs[1] self.assertEqual(out1.amount, 0) - self.assertEqual(out1.index, 1) + self.assertEqual(out1.position, 1) self.assertEqual( hexlify(out1.script.values['data']), b'aa21a9ede6c99265a6b9e1d36c962fda0516b35709c49dc3b8176fa7e5d5f1f6197884b4' @@ -155,19 +152,20 @@ class TestTransactionSigning(unittest.TestCase): ) yield account.ensure_address_gap() - address1 = (yield account.receiving.get_addresses())[0] - address2 = (yield account.receiving.get_addresses())[0] + address1, address2 = yield account.receiving.get_addresses(2) pubkey_hash1 = self.ledger.address_to_hash160(address1) pubkey_hash2 = self.ledger.address_to_hash160(address2) - tx = ledger_class.transaction_class() \ - .add_inputs([ledger_class.transaction_class.input_class.spend(get_output(2*COIN, pubkey_hash1))]) \ - .add_outputs([ledger_class.transaction_class.output_class.pay_pubkey_hash(int(1.9*COIN), pubkey_hash2)]) \ + tx_class = ledger_class.transaction_class + + tx = tx_class() \ + .add_inputs([tx_class.input_class.spend(get_output(2*COIN, pubkey_hash1))]) \ + .add_outputs([tx_class.output_class.pay_pubkey_hash(int(1.9*COIN), pubkey_hash2)]) \ yield tx.sign([account]) self.assertEqual( hexlify(tx.inputs[0].script.values['signature']), - b'3044022064cd6b95c9e0084253c10dd56bcec2bfd816c29aad05fbea490511d79540462b02201aa9d6f73' - b'48bb0c76b28d1ad87cf4ffd51cf4de0b299af8bf0ecad70e3369ef201' + b'304402203d463519290d06891e461ea5256c56097ccdad53379b1bb4e51ec5abc6e9fd02022034ed15b9' + b'd7c678716c4aa7c0fd26c688e8f9db8075838f2839ab55d551b62c0a01' ) diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index 2adce9dde..c52119e4e 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -32,6 +32,7 @@ class TestWalletCreation(unittest.TestCase): 'name': 'Main Wallet', 'accounts': [ { + 'name': 'An Account', 'ledger': 'btc_mainnet', 'seed': "carbon smart garage balance margin twelve chest sword toast envelope bottom stomac" @@ -43,10 +44,11 @@ class TestWalletCreation(unittest.TestCase): 'public_key': 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' 'iW44g14WF52fYC5J483wqQ5ZP', + 'is_hd': True, 'receiving_gap': 10, - 'receiving_maximum_use_per_address': 2, + 'receiving_maximum_uses_per_address': 2, 'change_gap': 10, - 'change_maximum_use_per_address': 2, + 'change_maximum_uses_per_address': 2, } ] } diff --git a/torba/baseaccount.py b/torba/baseaccount.py index ec29a184a..c3ca0df37 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -200,7 +200,7 @@ class BaseAccount(object): def to_dict(self): private_key = self.private_key if not self.encrypted and self.private_key: - private_key = self.private_key.extended_key_string().decode() + private_key = self.private_key.extended_key_string() d = { 'ledger': self.ledger.get_id(), @@ -208,7 +208,7 @@ class BaseAccount(object): 'seed': self.seed, 'encrypted': self.encrypted, 'private_key': private_key, - 'public_key': self.public_key.extended_key_string().decode(), + 'public_key': self.public_key.extended_key_string(), 'is_hd': False } @@ -260,7 +260,7 @@ class BaseAccount(object): else: return self.private_key.child(chain).child(index) - def get_balance(self, confirmations, **constraints): + def get_balance(self, confirmations=6, **constraints): if confirmations == 0: return self.ledger.db.get_balance_for_account(self, **constraints) else: diff --git a/torba/basedatabase.py b/torba/basedatabase.py index d8c4b12c0..b274e971f 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -6,7 +6,7 @@ import sqlite3 from twisted.internet import defer from twisted.enterprise import adbapi -import torba.baseaccount +from torba.hash import TXRefImmutable log = logging.getLogger(__name__) @@ -131,8 +131,8 @@ class BaseDatabase(SQLiteMixin): CREATE_TXO_TABLE = """ create table if not exists txo ( - txoid text primary key, txid text references tx, + txoid text primary key, address text references pubkey_address, position integer not null, amount integer not null, @@ -158,8 +158,9 @@ class BaseDatabase(SQLiteMixin): def txo_to_row(self, tx, address, txo): return { - 'txid': sqlite3.Binary(tx.hash), - 'address': sqlite3.Binary(address), + 'txid': tx.id, + 'txoid': txo.id, + 'address': address, 'position': txo.position, 'amount': txo.amount, 'script': sqlite3.Binary(txo.script.source) @@ -170,7 +171,7 @@ class BaseDatabase(SQLiteMixin): def _steps(t): if save_tx == 'insert': t.execute(*self._insert_sql('tx', { - 'txhash': sqlite3.Binary(tx.hash), + 'txid': tx.id, 'raw': sqlite3.Binary(tx.raw), 'height': height, 'is_verified': is_verified @@ -178,16 +179,15 @@ class BaseDatabase(SQLiteMixin): elif save_tx == 'update': t.execute(*self._update_sql("tx", { 'height': height, 'is_verified': is_verified - }, 'txhash = ?', (sqlite3.Binary(tx.hash),) + }, 'txid = ?', (tx.id,) )) existing_txos = list(map(itemgetter(0), t.execute( - "SELECT position FROM txo WHERE txhash = ?", - (sqlite3.Binary(tx.hash),) + "SELECT position FROM txo WHERE txid = ?", (tx.id,) ).fetchall())) for txo in tx.outputs: - if txo.index in existing_txos: + if txo.position in existing_txos: continue if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == hash: t.execute(*self._insert_sql("txo", self.txo_to_row(tx, address, txo))) @@ -195,20 +195,17 @@ class BaseDatabase(SQLiteMixin): # TODO: implement script hash payments print('Database.save_transaction_io: pay script hash is not implemented!') - existing_txis = [txi[0] for txi in t.execute( - "SELECT txoid FROM txi WHERE txhash = ? AND address = ?", - (sqlite3.Binary(tx.hash), sqlite3.Binary(address))).fetchall()] + spent_txoids = [txi[0] for txi in t.execute( + "SELECT txoid FROM txi WHERE txid = ? AND address = ?", (tx.id, address) + ).fetchall()] for txi in tx.inputs: - txoid = t.execute( - "SELECT txoid FROM txo WHERE txhash = ? AND position = ?", - (sqlite3.Binary(txi.output_txhash), txi.output_index) - ).fetchone() - if txoid is not None and txoid[0] not in existing_txis: + txoid = txi.txo_ref.id + if txoid not in spent_txoids: t.execute(*self._insert_sql("txi", { - 'txhash': sqlite3.Binary(tx.hash), - 'address': sqlite3.Binary(address), - 'txoid': txoid[0], + 'txid': tx.id, + 'txoid': txoid, + 'address': address, })) self._set_address_history(t, address, history) @@ -225,16 +222,10 @@ class BaseDatabase(SQLiteMixin): def release_reserved_outputs(self, txoids): return self.reserve_spent_outputs(txoids, is_reserved=False) - def get_txoid_for_txo(self, txo): - return self.query_one_value( - "SELECT txoid FROM txo WHERE txhash = ? AND position = ?", - (sqlite3.Binary(txo.transaction.hash), txo.index) - ) - @defer.inlineCallbacks - def get_transaction(self, txhash): + def get_transaction(self, txid): result = yield self.db.runQuery( - "SELECT raw, height, is_verified FROM tx WHERE txhash = ?", (sqlite3.Binary(txhash),) + "SELECT raw, height, is_verified FROM tx WHERE txid = ?", (txid,) ) if result: defer.returnValue(result[0]) @@ -254,13 +245,13 @@ class BaseDatabase(SQLiteMixin): col, op = key[:-len('__lte')], '<=' extras.append('{} {} :{}'.format(col, op, key)) extra_sql = ' AND ' + ' AND '.join(extras) - values = {'account': sqlite3.Binary(account.public_key.address)} + values = {'account': account.public_key.address} values.update(constraints) result = yield self.db.runQuery( """ SELECT SUM(amount) FROM txo - JOIN tx ON tx.txhash=txo.txhash + JOIN tx ON tx.txid=txo.txid JOIN pubkey_address ON pubkey_address.address=txo.address WHERE pubkey_address.account=:account AND @@ -279,11 +270,11 @@ class BaseDatabase(SQLiteMixin): extra_sql = ' AND ' + ' AND '.join( '{} = :{}'.format(c, c) for c in constraints.keys() ) - values = {'account': sqlite3.Binary(account.public_key.address)} + values = {'account': account.public_key.address} values.update(constraints) utxos = yield self.db.runQuery( """ - SELECT amount, script, txhash, txo.position, txoid + SELECT amount, script, txid, txo.position FROM txo JOIN pubkey_address ON pubkey_address.address=txo.address WHERE account=:account AND txo.is_reserved=0 AND txoid NOT IN (SELECT txoid FROM txi) """+extra_sql, values @@ -293,9 +284,8 @@ class BaseDatabase(SQLiteMixin): output_class( values[0], output_class.script_class(values[1]), - values[2], - index=values[3], - txoid=values[4] + TXRefImmutable.from_id(values[2]), + position=values[3] ) for values in utxos ]) @@ -307,18 +297,18 @@ class BaseDatabase(SQLiteMixin): ) + ', '.join(['(?, ?, ?, ?, ?)'] * len(keys)) values = [] for position, pubkey in keys: - values.append(sqlite3.Binary(pubkey.address)) - values.append(sqlite3.Binary(account.public_key.address)) + values.append(pubkey.address) + values.append(account.public_key.address) values.append(chain) values.append(position) - values.append(sqlite3.Binary(pubkey.pubkey_bytes)) + values.append(pubkey.pubkey_bytes) return self.db.runOperation(sql, values) @staticmethod def _set_address_history(t, address, history): t.execute( "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", - (history, history.count(':')//2, sqlite3.Binary(address)) + (history, history.count(':')//2, address) ) def set_address_history(self, address, history): diff --git a/torba/baseledger.py b/torba/baseledger.py index fba46c48b..f62816957 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -77,7 +77,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): self.on_transaction = self._on_transaction_controller.stream self.on_transaction.listen( lambda e: log.info('({}) on_transaction: address={}, height={}, is_verified={}, tx.id={}'.format( - self.get_id(), e.address, e.height, e.is_verified, e.tx.hex_id) + self.get_id(), e.address, e.height, e.is_verified, e.tx.id) ) ) @@ -136,7 +136,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): match = yield self.db.get_address(address) if match: for account in self.accounts: - if bytes(match['account']) == account.public_key.address: + if match['account'] == account.public_key.address: defer.returnValue(account.get_private_key(match['chain'], match['position'])) @defer.inlineCallbacks @@ -178,7 +178,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): @defer.inlineCallbacks def is_valid_transaction(self, tx, height): height <= len(self.headers) or defer.returnValue(False) - merkle = yield self.network.get_merkle(tx.hex_id.decode(), height) + merkle = yield self.network.get_merkle(tx.id, height) merkle_root = self.get_root_of_merkle_tree(merkle['merkle'], merkle['pos'], tx.hash) header = self.headers[height] defer.returnValue(merkle_root == header['merkle_root']) @@ -262,7 +262,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): synced_history.append((hex_id, remote_height)) - if i < len(local_history) and local_history[i] == (hex_id.decode(), remote_height): + if i < len(local_history) and local_history[i] == (hex_id, remote_height): continue lock = self._transaction_processing_locks.setdefault(hex_id, defer.DeferredLock()) @@ -271,7 +271,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): #try: # see if we have a local copy of transaction, otherwise fetch it from server - raw, local_height, is_verified = yield self.db.get_transaction(unhexlify(hex_id)[::-1]) + raw, local_height, is_verified = yield self.db.get_transaction(hex_id) save_tx = None if raw is None: _raw = yield self.network.get_transaction(hex_id) @@ -288,7 +288,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): yield self.db.save_transaction_io( save_tx, tx, remote_height, is_verified, address, self.address_to_hash160(address), - ''.join('{}:{}:'.format(tx_id.decode(), tx_height) for tx_id, tx_height in synced_history) + ''.join('{}:{}:'.format(tx_id, tx_height) for tx_id, tx_height in synced_history) ) log.debug("{}: sync'ed tx {} for address: {}, height: {}, verified: {}".format( @@ -320,4 +320,4 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): yield self.update_history(address) def broadcast(self, tx): - return self.network.broadcast(hexlify(tx.raw)) + return self.network.broadcast(hexlify(tx.raw).decode()) diff --git a/torba/basenetwork.py b/torba/basenetwork.py index 44720a0c6..cdc74c61b 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -1,4 +1,3 @@ -import six import json import socket import logging @@ -13,27 +12,6 @@ from torba.stream import StreamController log = logging.getLogger(__name__) -if six.PY3: - buffer = memoryview - - -def unicode2bytes(string): - if isinstance(string, six.text_type): - return string.encode('iso-8859-1') - elif isinstance(string, list): - return [unicode2bytes(s) for s in string] - return string - - -def bytes2unicode(maybe_bytes): - if isinstance(maybe_bytes, buffer): - maybe_bytes = str(maybe_bytes) - if isinstance(maybe_bytes, bytes): - return maybe_bytes.decode() - elif isinstance(maybe_bytes, (list, tuple)): - return [bytes2unicode(b) for b in maybe_bytes] - return maybe_bytes - class StratumClientProtocol(LineOnlyReceiver): delimiter = b'\n' @@ -86,14 +64,7 @@ class StratumClientProtocol(LineOnlyReceiver): log.debug('received: {}'.format(line)) try: - # `line` comes in as a byte string but `json.loads` automatically converts everything to - # unicode. For keys it's not a big deal but for values there is an expectation - # everywhere else in wallet code that most values are byte strings. - message = json.loads( - line, object_hook=lambda obj: { - k: unicode2bytes(v) for k, v in obj.items() - } - ) + message = json.loads(line) except (ValueError, TypeError): raise ValueError("Cannot decode message '{}'".format(line.strip())) @@ -118,7 +89,7 @@ class StratumClientProtocol(LineOnlyReceiver): message = json.dumps({ 'id': message_id, 'method': method, - 'params': [bytes2unicode(arg) for arg in args] + 'params': args }) log.debug('sent: {}'.format(message)) self.sendLine(message.encode('latin-1')) @@ -160,8 +131,8 @@ class BaseNetwork: self.on_status = self._on_status_controller.stream self.subscription_controllers = { - b'blockchain.headers.subscribe': self._on_header_controller, - b'blockchain.address.subscribe': self._on_status_controller, + 'blockchain.headers.subscribe': self._on_header_controller, + 'blockchain.address.subscribe': self._on_status_controller, } @defer.inlineCallbacks diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 6eaf14ac3..75c5cb45c 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -9,30 +9,60 @@ import torba.baseaccount import torba.baseledger from torba.basescript import BaseInputScript, BaseOutputScript from torba.coinselection import CoinSelector -from torba.constants import COIN +from torba.constants import COIN, NULL_HASH32 from torba.bcd_data_stream import BCDataStream -from torba.hash import sha256 +from torba.hash import sha256, TXRef, TXRefImmutable, TXORef from torba.util import ReadOnlyList log = logging.getLogger() -NULL_HASH = b'\x00'*32 +class TXRefMutable(TXRef): + + __slots__ = 'tx', + + def __init__(self, tx): + super(TXRefMutable, self).__init__() + self.tx = tx + + @property + def id(self): + if self._id is None: + self._id = hexlify(self.hash[::-1]).decode() + return self._id + + @property + def hash(self): + if self._hash is None: + self._hash = sha256(sha256(self.tx.raw)) + return self._hash + + def reset(self): + self._id = None + self._hash = None + + +class TXORefResolvable(TXORef): + + __slots__ = '_txo', + + def __init__(self, txo): + super(TXORefResolvable, self).__init__(txo.tx_ref, txo.position) + self._txo = txo + + @property + def txo(self): + return self._txo class InputOutput(object): - def __init__(self, txhash, index=None): - self._txhash = txhash # type: bytes - self.transaction = None # type: BaseTransaction - self.index = index # type: int + __slots__ = 'tx_ref', 'position' - @property - def txhash(self): - if self._txhash is None: - self._txhash = self.transaction.hash - return self._txhash + def __init__(self, tx_ref=None, position=None): + self.tx_ref = tx_ref # type: TXRef + self.position = position # type: int @property def size(self): @@ -52,49 +82,49 @@ class BaseInput(InputOutput): NULL_SIGNATURE = b'\x00'*72 NULL_PUBLIC_KEY = b'\x00'*33 - def __init__(self, output_or_txhash_index, script, sequence=0xFFFFFFFF, txhash=None): - super(BaseInput, self).__init__(txhash) - if isinstance(output_or_txhash_index, BaseOutput): - self.output = output_or_txhash_index # type: BaseOutput - self.output_txhash = self.output.txhash - self.output_index = self.output.index - else: - self.output = None # type: BaseOutput - self.output_txhash, self.output_index = output_or_txhash_index + __slots__ = 'txo_ref', 'sequence', 'coinbase', 'script' + + def __init__(self, txo_ref, script, sequence=0xFFFFFFFF, tx_ref=None, position=None): + # type: (TXORef, BaseInputScript, int, TXRef, int) -> None + super(BaseInput, self).__init__(tx_ref, position) + self.txo_ref = txo_ref self.sequence = sequence - self.is_coinbase = self.output_txhash == NULL_HASH - self.coinbase = script if self.is_coinbase else None - self.script = script if not self.is_coinbase else None # type: BaseInputScript + self.coinbase = script if txo_ref.is_null else None + self.script = script if not txo_ref.is_null else None # type: BaseInputScript + + @property + def is_coinbase(self): + return self.coinbase is not None @classmethod - def spend(cls, output): + def spend(cls, txo): # type: (BaseOutput) -> BaseInput """ Create an input to spend the output.""" - assert output.script.is_pay_pubkey_hash, 'Attempting to spend unsupported output.' + assert txo.script.is_pay_pubkey_hash, 'Attempting to spend unsupported output.' script = cls.script_class.redeem_pubkey_hash(cls.NULL_SIGNATURE, cls.NULL_PUBLIC_KEY) - return cls(output, script) + return cls(txo.ref, script) @property def amount(self): """ Amount this input adds to the transaction. """ - if self.output is None: - raise ValueError('Cannot get input value without referenced output.') - return self.output.amount + if self.txo_ref.txo is None: + raise ValueError('Cannot resolve output to get amount.') + return self.txo_ref.txo.amount @classmethod def deserialize_from(cls, stream): - txhash = stream.read(32) - index = stream.read_uint32() + tx_ref = TXRefImmutable.from_hash(stream.read(32)) + position = stream.read_uint32() script = stream.read_string() sequence = stream.read_uint32() return cls( - (txhash, index), - cls.script_class(script) if not txhash == NULL_HASH else script, + TXORef(tx_ref, position), + cls.script_class(script) if not tx_ref.is_null else script, sequence ) def serialize_to(self, stream, alternate_script=None): - stream.write(self.output_txhash) - stream.write_uint32(self.output_index) + stream.write(self.txo_ref.tx_ref.hash) + stream.write_uint32(self.txo_ref.position) if alternate_script is not None: stream.write_string(alternate_script) else: @@ -107,7 +137,7 @@ class BaseInput(InputOutput): class BaseOutputEffectiveAmountEstimator(object): - __slots__ = 'coin', 'txi', 'txo', 'fee', 'effective_amount' + __slots__ = 'txo', 'txi', 'fee', 'effective_amount' def __init__(self, ledger, txo): # type: (torba.baseledger.BaseLedger, BaseOutput) -> None self.txo = txo @@ -124,11 +154,21 @@ class BaseOutput(InputOutput): script_class = BaseOutputScript estimator_class = BaseOutputEffectiveAmountEstimator - def __init__(self, amount, script, txhash=None, index=None, txoid=None): - super(BaseOutput, self).__init__(txhash, index) - self.amount = amount # type: int - self.script = script # type: BaseOutputScript - self.txoid = txoid + __slots__ = 'amount', 'script' + + def __init__(self, amount, script, tx_ref=None, position=None): + # type: (int, BaseOutputScript, TXRef, int) -> None + super(BaseOutput, self).__init__(tx_ref, position) + self.amount = amount + self.script = script + + @property + def ref(self): + return TXORefResolvable(self) + + @property + def id(self): + return self.ref.id def get_estimator(self, ledger): return self.estimator_class(ledger, self) @@ -156,8 +196,7 @@ class BaseTransaction: def __init__(self, raw=None, version=1, locktime=0): self._raw = raw - self._hash = None - self._id = None + self.ref = TXRefMutable(self) self.version = version # type: int self.locktime = locktime # type: int self._inputs = [] # type: List[BaseInput] @@ -165,21 +204,13 @@ class BaseTransaction: if raw is not None: self._deserialize() - @property - def hex_id(self): - return hexlify(self.id) - @property def id(self): - if self._id is None: - self._id = self.hash[::-1] - return self._id + return self.ref.id @property def hash(self): - if self._hash is None: - self._hash = sha256(sha256(self.raw)) - return self._hash + return self.ref.hash @property def raw(self): @@ -188,9 +219,8 @@ class BaseTransaction: return self._raw def _reset(self): - self._id = None - self._hash = None self._raw = None + self.ref.reset() @property def inputs(self): # type: () -> ReadOnlyList[BaseInput] @@ -201,35 +231,36 @@ class BaseTransaction: return ReadOnlyList(self._outputs) def _add(self, new_ios, existing_ios): + # type: (List[InputOutput], List[InputOutput]) -> BaseTransaction for txio in new_ios: - txio.transaction = self - txio.index = len(existing_ios) + txio.tx_ref = self.ref + txio.position = len(existing_ios) existing_ios.append(txio) self._reset() return self - def add_inputs(self, inputs): + def add_inputs(self, inputs): # type: (List[BaseInput]) -> BaseTransaction return self._add(inputs, self._inputs) - def add_outputs(self, outputs): + def add_outputs(self, outputs): # type: (List[BaseOutput]) -> BaseTransaction return self._add(outputs, self._outputs) @property - def fee(self): + def fee(self): # type: () -> int """ Fee that will actually be paid.""" return self.input_sum - self.output_sum @property - def size(self): + def size(self): # type: () -> int """ Size in bytes of the entire transaction. """ return len(self.raw) @property - def base_size(self): + def base_size(self): # type: () -> int """ Size in bytes of transaction meta data and all outputs; without inputs. """ return len(self._serialize(with_inputs=False)) - def _serialize(self, with_inputs=True): + def _serialize(self, with_inputs=True): # type: (bool) -> bytes stream = BCDataStream() stream.write_uint32(self.version) if with_inputs: @@ -242,13 +273,13 @@ class BaseTransaction: stream.write_uint32(self.locktime) return stream.get_bytes() - def _serialize_for_signature(self, signing_input): + def _serialize_for_signature(self, signing_input): # type: (int) -> bytes stream = BCDataStream() stream.write_uint32(self.version) stream.write_compact_size(len(self._inputs)) for i, txin in enumerate(self._inputs): if signing_input == i: - txin.serialize_to(stream, txin.output.script.source) + txin.serialize_to(stream, txin.txo_ref.txo.script.source) else: txin.serialize_to(stream, b'') stream.write_compact_size(len(self._outputs)) @@ -300,7 +331,7 @@ class BaseTransaction: selector = CoinSelector( txos, amount, ledger.get_input_output_fee( - cls.output_class.pay_pubkey_hash(COIN, NULL_HASH) + cls.output_class.pay_pubkey_hash(COIN, NULL_HASH32) ) ) @@ -308,7 +339,7 @@ class BaseTransaction: if not spendables: raise ValueError('Not enough funds to cover this transaction.') - reserved_outputs = [s.txo.txoid for s in spendables] + reserved_outputs = [s.txo.id for s in spendables] if reserve_outputs: yield ledger.db.reserve_spent_outputs(reserved_outputs) @@ -340,14 +371,14 @@ class BaseTransaction: ]) ledger = cls.ensure_all_have_same_ledger(funding_accounts, change_account) - reserved_outputs = [utxo.txoid for utxo in assets] + reserved_outputs = [utxo.id for utxo in assets] if reserve_outputs: yield ledger.db.reserve_spent_outputs(reserved_outputs) try: cost_of_change = ( ledger.get_transaction_base_fee(tx) + - ledger.get_input_output_fee(cls.output_class.pay_pubkey_hash(COIN, NULL_HASH)) + ledger.get_input_output_fee(cls.output_class.pay_pubkey_hash(COIN, NULL_HASH32)) ) liquidated_total = sum(utxo.amount for utxo in assets) if liquidated_total > cost_of_change: @@ -372,7 +403,7 @@ class BaseTransaction: def sign(self, funding_accounts): # type: (Iterable[torba.baseaccount.BaseAccount]) -> BaseTransaction ledger = self.ensure_all_have_same_ledger(funding_accounts) for i, txi in enumerate(self._inputs): - txo_script = txi.output.script + txo_script = txi.txo_ref.txo.script if txo_script.is_pay_pubkey_hash: address = ledger.hash160_to_address(txo_script.values['pubkey_hash']) private_key = yield ledger.get_private_key_for_address(address) diff --git a/torba/coinselection.py b/torba/coinselection.py index 398781676..0c1adede0 100644 --- a/torba/coinselection.py +++ b/torba/coinselection.py @@ -21,14 +21,14 @@ class CoinSelector: if six.PY3 and seed is not None: self.random.seed(seed, version=1) - def select(self): + def select(self): # type: () -> List[torba.basetransaction.BaseOutputAmountEstimator] if not self.txos: return if self.target > self.available: return return self.branch_and_bound() or self.single_random_draw() - def branch_and_bound(self): + def branch_and_bound(self): # type: () -> List[torba.basetransaction.BaseOutputAmountEstimator] # see bitcoin implementation for more info: # https://github.com/bitcoin/bitcoin/blob/master/src/wallet/coinselection.cpp @@ -84,7 +84,7 @@ class CoinSelector: self.txos[i] for i, include in enumerate(best_selection) if include ] - def single_random_draw(self): + def single_random_draw(self): # type: () -> List[torba.basetransaction.BaseOutputAmountEstimator] self.random.shuffle(self.txos, self.random.random) selection = [] amount = 0 diff --git a/torba/constants.py b/torba/constants.py index 9fab12b5f..c1497ac19 100644 --- a/torba/constants.py +++ b/torba/constants.py @@ -1,3 +1,4 @@ +NULL_HASH32 = b'\x00'*32 CENT = 1000000 COIN = 100*CENT diff --git a/torba/hash.py b/torba/hash.py index 3d7092e58..d8ab42bb6 100644 --- a/torba/hash.py +++ b/torba/hash.py @@ -20,6 +20,7 @@ from cryptography.hazmat.primitives.padding import PKCS7 from cryptography.hazmat.backends import default_backend from torba.util import bytes_to_int, int_to_bytes +from torba.constants import NULL_HASH32 _sha256 = hashlib.sha256 _sha512 = hashlib.sha512 @@ -27,6 +28,67 @@ _new_hash = hashlib.new _new_hmac = hmac.new +class TXRef(object): + + __slots__ = '_id', '_hash' + + def __init__(self): + self._id = None + self._hash = None + + @property + def id(self): + return self._id + + @property + def hash(self): + return self._hash + + @property + def is_null(self): + return self.hash == NULL_HASH32 + + +class TXRefImmutable(TXRef): + + __slots__ = () + + @classmethod + def from_hash(cls, tx_hash): # type: (bytes) -> TXRefImmutable + ref = cls() + ref._hash = tx_hash + ref._id = hexlify(tx_hash[::-1]).decode() + return ref + + @classmethod + def from_id(cls, tx_id): # type: (str) -> TXRefImmutable + ref = cls() + ref._id = tx_id + ref._hash = unhexlify(tx_id)[::-1] + return ref + + +class TXORef(object): + + __slots__ = 'tx_ref', 'position' + + def __init__(self, tx_ref, position): # type: (TXRef, int) -> None + self.tx_ref = tx_ref + self.position = position + + @property + def id(self): + return '{}:{}'.format(self.tx_ref.id, self.position) + + @property + def is_null(self): + return self.tx_ref.is_null + + @property + def txo(self): + return None + + def sha256(x): """ Simple wrapper of hashlib sha256. """ return _sha256(x).digest() @@ -164,7 +226,7 @@ class Base58(object): break txt += u'1' - return txt[::-1].encode() + return txt[::-1] @classmethod def decode_check(cls, txt, hash_fn=double_sha256): diff --git a/torba/manager.py b/torba/manager.py index f535be24e..ac803e419 100644 --- a/torba/manager.py +++ b/torba/manager.py @@ -1,8 +1,10 @@ +from decimal import Decimal from typing import List, Dict, Type from twisted.internet import defer from torba.baseledger import BaseLedger, LedgerRegistry from torba.wallet import Wallet, WalletStorage +from torba.constants import COIN class WalletManager(object): @@ -39,12 +41,18 @@ class WalletManager(object): return wallet @defer.inlineCallbacks - def get_balance(self): + def get_balances(self, confirmations=6): balances = {} - for ledger in self.ledgers.values(): - for account in ledger.accounts: - balances.setdefault(ledger.get_id(), 0) - balances[ledger.get_id()] += yield account.get_balance() + for i, ledger in enumerate(self.ledgers.values()): + ledger_balances = balances[ledger.get_id()] = [] + for j, account in enumerate(ledger.accounts): + satoshis = yield account.get_balance(confirmations) + ledger_balances.append({ + 'account': account.name, + 'coins': round(Decimal(satoshis) / COIN, 2), + 'satoshis': satoshis, + 'is_default_account': i == 0 and j == 0 + }) defer.returnValue(balances) @property From 0f786a8c43e974e6ca93028da0cc8399c3ad1cac Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 14 Jul 2018 22:16:39 -0400 Subject: [PATCH 053/383] removed unused methods --- torba/basedatabase.py | 37 +++---------------------------------- 1 file changed, 3 insertions(+), 34 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index b274e971f..82026afad 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -32,12 +32,6 @@ class SQLiteMixin(object): self.db.close() return defer.succeed(True) - def _debug_sql(self, sql): - """ For use during debugging to execute arbitrary SQL queries without waiting on reactor. """ - conn = self.db.connectionFactory(self.db) - trans = self.db.transactionFactory(self, conn) - return trans.execute(sql).fetchall() - def _insert_sql(self, table, data): # type: (str, dict) -> tuple[str, List] columns, values = [], [] @@ -61,20 +55,11 @@ class SQLiteMixin(object): ) return sql, values - @defer.inlineCallbacks - def query_one_value_list(self, query, params): - # type: (str, Union[dict,tuple]) -> defer.Deferred[List] - result = yield self.db.runQuery(query, params) - if result: - defer.returnValue([i[0] for i in result]) - else: - defer.returnValue([]) - @defer.inlineCallbacks def query_one_value(self, query, params=None, default=None): result = yield self.db.runQuery(query, params) if result: - defer.returnValue(result[0][0]) + defer.returnValue(result[0][0] or default) else: defer.returnValue(default) @@ -94,17 +79,6 @@ class SQLiteMixin(object): else: defer.returnValue(default) - def query_count(self, sql, params): - return self.query_one_value( - "SELECT count(*) FROM ({})".format(sql), params - ) - - def insert_and_return_id(self, table, data): - def do_insert(t): - t.execute(*self._insert_sql(table, data)) - return t.lastrowid - return self.db.runInteraction(do_insert) - class BaseDatabase(SQLiteMixin): @@ -232,7 +206,6 @@ class BaseDatabase(SQLiteMixin): else: defer.returnValue((None, None, False)) - @defer.inlineCallbacks def get_balance_for_account(self, account, **constraints): extra_sql = "" if constraints: @@ -247,7 +220,7 @@ class BaseDatabase(SQLiteMixin): extra_sql = ' AND ' + ' AND '.join(extras) values = {'account': account.public_key.address} values.update(constraints) - result = yield self.db.runQuery( + return self.query_one_value( """ SELECT SUM(amount) FROM txo @@ -256,12 +229,8 @@ class BaseDatabase(SQLiteMixin): WHERE pubkey_address.account=:account AND txoid NOT IN (SELECT txoid FROM txi) - """+extra_sql, values + """+extra_sql, values, 0 ) - if result: - defer.returnValue(result[0][0] or 0) - else: - defer.returnValue(0) @defer.inlineCallbacks def get_utxos_for_account(self, account, **constraints): From fcc7177a9a81b25899cb66e001258f154e76dc61 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 14 Jul 2018 22:38:18 -0400 Subject: [PATCH 054/383] unit tests for bcd_data_stream --- tests/unit/test_bcd_data_stream.py | 23 +++++++++++++++++++++++ torba/bcd_data_stream.py | 4 ---- 2 files changed, 23 insertions(+), 4 deletions(-) create mode 100644 tests/unit/test_bcd_data_stream.py diff --git a/tests/unit/test_bcd_data_stream.py b/tests/unit/test_bcd_data_stream.py new file mode 100644 index 000000000..577c0ebf2 --- /dev/null +++ b/tests/unit/test_bcd_data_stream.py @@ -0,0 +1,23 @@ +from twisted.trial import unittest + +from torba.bcd_data_stream import BCDataStream + + +class TestBCDataStream(unittest.TestCase): + + def test_write_read(self): + s = BCDataStream() + s.write_string(b'a'*252) + s.write_string(b'b'*254) + s.write_string(b'c'*(0xFFFF + 1)) + # s.write_string(b'd'*(0xFFFFFFFF + 1)) + s.write_boolean(True) + s.write_boolean(False) + s.reset() + + self.assertEqual(s.read_string(), b'a'*252) + self.assertEqual(s.read_string(), b'b'*254) + self.assertEqual(s.read_string(), b'c'*(0xFFFF + 1)) + # self.assertEqual(s.read_string(), b'd'*(0xFFFFFFFF + 1)) + self.assertEqual(s.read_boolean(), True) + self.assertEqual(s.read_boolean(), False) diff --git a/torba/bcd_data_stream.py b/torba/bcd_data_stream.py index 1eb602015..ab06cdecc 100644 --- a/torba/bcd_data_stream.py +++ b/torba/bcd_data_stream.py @@ -7,10 +7,6 @@ class BCDataStream: def __init__(self, data=None): self.data = BytesIO(data) - @property - def is_at_beginning(self): - return self.data.tell() == 0 - def reset(self): self.data.seek(0) From e36e4c6354555bea759aa74be117d33493e03770 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 15 Jul 2018 00:40:46 -0400 Subject: [PATCH 055/383] pubkey should stay as blob --- torba/basedatabase.py | 4 +-- torba/baseledger.py | 61 ++++++++++++++++++++++--------------------- 2 files changed, 33 insertions(+), 32 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 82026afad..a850aa2b7 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -88,7 +88,7 @@ class BaseDatabase(SQLiteMixin): account text not null, chain integer not null, position integer not null, - pubkey text not null, + pubkey blob not null, history text, used_times integer not null default 0 ); @@ -270,7 +270,7 @@ class BaseDatabase(SQLiteMixin): values.append(account.public_key.address) values.append(chain) values.append(position) - values.append(pubkey.pubkey_bytes) + values.append(sqlite3.Binary(pubkey.pubkey_bytes)) return self.db.runOperation(sql, values) @staticmethod diff --git a/torba/baseledger.py b/torba/baseledger.py index f62816957..f07b5c3b6 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -269,41 +269,42 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): yield lock.acquire() - #try: - # see if we have a local copy of transaction, otherwise fetch it from server - raw, local_height, is_verified = yield self.db.get_transaction(hex_id) - save_tx = None - if raw is None: - _raw = yield self.network.get_transaction(hex_id) - tx = self.transaction_class(unhexlify(_raw)) - save_tx = 'insert' - else: - tx = self.transaction_class(raw) + try: - if remote_height > 0 and not is_verified: - is_verified = yield self.is_valid_transaction(tx, remote_height) - is_verified = 1 if is_verified else 0 - if save_tx is None: - save_tx = 'update' + # see if we have a local copy of transaction, otherwise fetch it from server + raw, local_height, is_verified = yield self.db.get_transaction(hex_id) + save_tx = None + if raw is None: + _raw = yield self.network.get_transaction(hex_id) + tx = self.transaction_class(unhexlify(_raw)) + save_tx = 'insert' + else: + tx = self.transaction_class(raw) - yield self.db.save_transaction_io( - save_tx, tx, remote_height, is_verified, address, self.address_to_hash160(address), - ''.join('{}:{}:'.format(tx_id, tx_height) for tx_id, tx_height in synced_history) - ) + if remote_height > 0 and not is_verified: + is_verified = yield self.is_valid_transaction(tx, remote_height) + is_verified = 1 if is_verified else 0 + if save_tx is None: + save_tx = 'update' - log.debug("{}: sync'ed tx {} for address: {}, height: {}, verified: {}".format( - self.get_id(), hex_id, address, remote_height, is_verified - )) - self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) + yield self.db.save_transaction_io( + save_tx, tx, remote_height, is_verified, address, self.address_to_hash160(address), + ''.join('{}:{}:'.format(tx_id, tx_height) for tx_id, tx_height in synced_history) + ) - #except: - # log.exception('Failed to synchronize transaction:') - # raise + log.debug("{}: sync'ed tx {} for address: {}, height: {}, verified: {}".format( + self.get_id(), hex_id, address, remote_height, is_verified + )) + self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) - #finally: - lock.release() - if not lock.locked: - del self._transaction_processing_locks[hex_id] + except: + log.exception('Failed to synchronize transaction:') + raise + + finally: + lock.release() + if not lock.locked: + del self._transaction_processing_locks[hex_id] @defer.inlineCallbacks def subscribe_history(self, address): From 97532fb30066fe23194ecce9fd396ea694702f73 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 15 Jul 2018 16:04:11 -0400 Subject: [PATCH 056/383] don't delete lock if it's not in locks dict and other fun things --- tests/unit/test_ledger.py | 8 +++++++- torba/baseaccount.py | 1 - torba/baseledger.py | 12 +++++++----- 3 files changed, 14 insertions(+), 7 deletions(-) diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index 708d2fc4d..afedf6042 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -55,12 +55,18 @@ class MainNetTestLedger(MainNetLedger): }) -class TestSynchronization(unittest.TestCase): +class LedgerTestCase(unittest.TestCase): def setUp(self): self.ledger = MainNetTestLedger() return self.ledger.db.start() + def tearDown(self): + return self.ledger.db.stop() + + +class TestSynchronization(LedgerTestCase): + @defer.inlineCallbacks def test_update_history(self): account = self.ledger.account_class.generate(self.ledger, u"torba") diff --git a/torba/baseaccount.py b/torba/baseaccount.py index c3ca0df37..a10ae7257 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -1,7 +1,6 @@ from typing import Dict from twisted.internet import defer -import torba.baseledger from torba.mnemonic import Mnemonic from torba.bip32 import PrivateKey, PubKey, from_extended_key_string from torba.hash import double_sha256, aes_encrypt, aes_decrypt diff --git a/torba/baseledger.py b/torba/baseledger.py index f07b5c3b6..e2b22d8aa 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -90,8 +90,9 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): def get_id(cls): return '{}_{}'.format(cls.symbol.lower(), cls.network_name.lower()) - def hash160_to_address(self, h160): - raw_address = self.pubkey_address_prefix + h160 + @classmethod + def hash160_to_address(cls, h160): + raw_address = cls.pubkey_address_prefix + h160 return Base58.encode(bytearray(raw_address + double_sha256(raw_address)[0:4])) @staticmethod @@ -100,8 +101,9 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): prefix, pubkey_bytes, addr_checksum = bytes[0], bytes[1:21], bytes[21:] return pubkey_bytes - def public_key_to_address(self, public_key): - return self.hash160_to_address(hash160(public_key)) + @classmethod + def public_key_to_address(cls, public_key): + return cls.hash160_to_address(hash160(public_key)) @staticmethod def private_key_to_wif(private_key): @@ -303,7 +305,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): finally: lock.release() - if not lock.locked: + if not lock.locked and hex_id in self._transaction_processing_locks: del self._transaction_processing_locks[hex_id] @defer.inlineCallbacks From 686eb7b1f05801b4e5d9b3db5ba4a79ea2dc2f9f Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Sun, 15 Jul 2018 17:41:52 -0300 Subject: [PATCH 057/383] fix a failure for channels where we catch the wrong error --- torba/baseledger.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index e2b22d8aa..0f4a522c6 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -299,9 +299,9 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): )) self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) - except: + except Exception as e: log.exception('Failed to synchronize transaction:') - raise + raise e finally: lock.release() From 10fd654edce307521858353907cafdf4d0debcb3 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 16 Jul 2018 23:58:29 -0400 Subject: [PATCH 058/383] improved account balance support --- torba/__init__.py | 2 +- torba/baseaccount.py | 9 +++---- torba/basedatabase.py | 56 ++++++++++++++++++++++++++++--------------- torba/baseledger.py | 12 ++++++---- torba/manager.py | 6 +++++ 5 files changed, 55 insertions(+), 30 deletions(-) diff --git a/torba/__init__.py b/torba/__init__.py index bc9d27d55..ebb33d435 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__ = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.0.1' +__version__ = '0.0.2' diff --git a/torba/baseaccount.py b/torba/baseaccount.py index a10ae7257..92d64846c 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -260,13 +260,10 @@ class BaseAccount(object): return self.private_key.child(chain).child(index) def get_balance(self, confirmations=6, **constraints): - if confirmations == 0: - return self.ledger.db.get_balance_for_account(self, **constraints) - else: + if confirmations > 0: height = self.ledger.headers.height - (confirmations-1) - return self.ledger.db.get_balance_for_account( - self, height__lte=height, height__not=-1, **constraints - ) + constraints.update({'height__lte': height, 'height__not': -1}) + return self.ledger.db.get_balance_for_account(self, **constraints) def get_unspent_outputs(self, **constraints): return self.ledger.db.get_utxos_for_account(self, **constraints) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index a850aa2b7..3d4df697f 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -57,7 +57,7 @@ class SQLiteMixin(object): @defer.inlineCallbacks def query_one_value(self, query, params=None, default=None): - result = yield self.db.runQuery(query, params) + result = yield self.run_query(query, params) if result: defer.returnValue(result[0][0] or default) else: @@ -65,7 +65,7 @@ class SQLiteMixin(object): @defer.inlineCallbacks def query_dict_value_list(self, query, fields, params=None): - result = yield self.db.runQuery(query.format(', '.join(fields)), params) + result = yield self.run_query(query.format(', '.join(fields)), params) if result: defer.returnValue([dict(zip(fields, r)) for r in result]) else: @@ -79,6 +79,22 @@ class SQLiteMixin(object): else: defer.returnValue(default) + @staticmethod + def execute(t, sql, values): + log.debug(sql) + log.debug(values) + return t.execute(sql, values) + + def run_operation(self, sql, values): + log.debug(sql) + log.debug(values) + return self.db.runOperation(sql, values) + + def run_query(self, sql, values): + log.debug(sql) + log.debug(values) + return self.db.runQuery(sql, values) + class BaseDatabase(SQLiteMixin): @@ -144,39 +160,39 @@ class BaseDatabase(SQLiteMixin): def _steps(t): if save_tx == 'insert': - t.execute(*self._insert_sql('tx', { + self.execute(t, *self._insert_sql('tx', { 'txid': tx.id, 'raw': sqlite3.Binary(tx.raw), 'height': height, 'is_verified': is_verified })) elif save_tx == 'update': - t.execute(*self._update_sql("tx", { + self.execute(t, *self._update_sql("tx", { 'height': height, 'is_verified': is_verified }, 'txid = ?', (tx.id,) )) - existing_txos = list(map(itemgetter(0), t.execute( - "SELECT position FROM txo WHERE txid = ?", (tx.id,) + existing_txos = list(map(itemgetter(0), self.execute( + t, "SELECT position FROM txo WHERE txid = ?", (tx.id,) ).fetchall())) for txo in tx.outputs: if txo.position in existing_txos: continue if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == hash: - t.execute(*self._insert_sql("txo", self.txo_to_row(tx, address, txo))) + self.execute(t, *self._insert_sql("txo", self.txo_to_row(tx, address, txo))) elif txo.script.is_pay_script_hash: # TODO: implement script hash payments print('Database.save_transaction_io: pay script hash is not implemented!') - spent_txoids = [txi[0] for txi in t.execute( - "SELECT txoid FROM txi WHERE txid = ? AND address = ?", (tx.id, address) + spent_txoids = [txi[0] for txi in self.execute( + t, "SELECT txoid FROM txi WHERE txid = ? AND address = ?", (tx.id, address) ).fetchall()] for txi in tx.inputs: txoid = txi.txo_ref.id if txoid not in spent_txoids: - t.execute(*self._insert_sql("txi", { + self.execute(t, *self._insert_sql("txi", { 'txid': tx.id, 'txoid': txoid, 'address': address, @@ -187,7 +203,7 @@ class BaseDatabase(SQLiteMixin): return self.db.runInteraction(_steps) def reserve_spent_outputs(self, txoids, is_reserved=True): - return self.db.runOperation( + return self.run_operation( "UPDATE txo SET is_reserved = ? WHERE txoid IN ({})".format( ', '.join(['?']*len(txoids)) ), [is_reserved]+txoids @@ -198,7 +214,7 @@ class BaseDatabase(SQLiteMixin): @defer.inlineCallbacks def get_transaction(self, txid): - result = yield self.db.runQuery( + result = yield self.run_query( "SELECT raw, height, is_verified FROM tx WHERE txid = ?", (txid,) ) if result: @@ -206,7 +222,7 @@ class BaseDatabase(SQLiteMixin): else: defer.returnValue((None, None, False)) - def get_balance_for_account(self, account, **constraints): + def get_balance_for_account(self, account, include_reserved=False, **constraints): extra_sql = "" if constraints: extras = [] @@ -218,6 +234,8 @@ class BaseDatabase(SQLiteMixin): col, op = key[:-len('__lte')], '<=' extras.append('{} {} :{}'.format(col, op, key)) extra_sql = ' AND ' + ' AND '.join(extras) + if not include_reserved: + extra_sql += ' AND is_reserved=0' values = {'account': account.public_key.address} values.update(constraints) return self.query_one_value( @@ -241,7 +259,7 @@ class BaseDatabase(SQLiteMixin): ) values = {'account': account.public_key.address} values.update(constraints) - utxos = yield self.db.runQuery( + utxos = yield self.run_query( """ SELECT amount, script, txid, txo.position FROM txo JOIN pubkey_address ON pubkey_address.address=txo.address @@ -271,12 +289,12 @@ class BaseDatabase(SQLiteMixin): values.append(chain) values.append(position) values.append(sqlite3.Binary(pubkey.pubkey_bytes)) - return self.db.runOperation(sql, values) + return self.run_operation(sql, values) - @staticmethod - def _set_address_history(t, address, history): - t.execute( - "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", + @classmethod + def _set_address_history(cls, t, address, history): + cls.execute( + t, "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", (history, history.count(':')//2, address) ) diff --git a/torba/baseledger.py b/torba/baseledger.py index 0f4a522c6..cfe80169e 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -7,7 +7,7 @@ from typing import Dict, Type, Iterable, Generator from operator import itemgetter from collections import namedtuple -from twisted.internet import defer +from twisted.internet import defer, reactor from torba import baseaccount from torba import basedatabase @@ -69,7 +69,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): self.network = self.config.get('network') or self.network_class(self) self.network.on_header.listen(self.process_header) self.network.on_status.listen(self.process_status) - self.accounts = set() + self.accounts = [] self.headers = self.config.get('headers') or self.headers_class(self) self.fee_per_byte = self.config.get('fee_per_byte', self.default_fee_per_byte) @@ -123,7 +123,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): @defer.inlineCallbacks def add_account(self, account): # type: (baseaccount.BaseAccount) -> None - self.accounts.add(account) + self.accounts.append(account) if self.network.is_connected: yield self.update_account(account) @@ -297,7 +297,11 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): log.debug("{}: sync'ed tx {} for address: {}, height: {}, verified: {}".format( self.get_id(), hex_id, address, remote_height, is_verified )) - self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) + + reactor.callLater( + 0.01, self._on_transaction_controller.add, + TransactionEvent(address, tx, remote_height, is_verified) + ) except Exception as e: log.exception('Failed to synchronize transaction:') diff --git a/torba/manager.py b/torba/manager.py index ac803e419..2cb998758 100644 --- a/torba/manager.py +++ b/torba/manager.py @@ -65,6 +65,12 @@ class WalletManager(object): for wallet in self.wallets: return wallet.default_account + @property + def accounts(self): + for wallet in self.wallets: + for account in wallet.accounts: + yield account + @defer.inlineCallbacks def start(self): self.running = True From 3f17dd336b0559043fca7014642d939bc2882d1c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 17 Jul 2018 00:01:22 -0400 Subject: [PATCH 059/383] 0.0.3 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index ebb33d435..8e2fe445a 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__ = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.0.2' +__version__ = '0.0.3' From 7c39e55089bdd123a24d2d96f4ee900bdde8e26c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 17 Jul 2018 00:09:02 -0400 Subject: [PATCH 060/383] callLater breaks determinism --- torba/baseledger.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index cfe80169e..25c6f22bb 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -3,11 +3,11 @@ import six import hashlib import logging from binascii import hexlify, unhexlify -from typing import Dict, Type, Iterable, Generator +from typing import Dict, Type, Iterable from operator import itemgetter from collections import namedtuple -from twisted.internet import defer, reactor +from twisted.internet import defer from torba import baseaccount from torba import basedatabase @@ -298,10 +298,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): self.get_id(), hex_id, address, remote_height, is_verified )) - reactor.callLater( - 0.01, self._on_transaction_controller.add, - TransactionEvent(address, tx, remote_height, is_verified) - ) + self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) except Exception as e: log.exception('Failed to synchronize transaction:') From 67dc297c9747fc3ab906f900140254b596d20c25 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 21 Jul 2018 14:39:53 -0400 Subject: [PATCH 061/383] use floats() instead of Decimal() when we need to serialized to JSON (while providing satoshis for accuracy) --- torba/manager.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/torba/manager.py b/torba/manager.py index 2cb998758..7a674afb9 100644 --- a/torba/manager.py +++ b/torba/manager.py @@ -1,4 +1,3 @@ -from decimal import Decimal from typing import List, Dict, Type from twisted.internet import defer @@ -49,7 +48,7 @@ class WalletManager(object): satoshis = yield account.get_balance(confirmations) ledger_balances.append({ 'account': account.name, - 'coins': round(Decimal(satoshis) / COIN, 2), + 'coins': round(satoshis/COIN, 2), 'satoshis': satoshis, 'is_default_account': i == 0 and j == 0 }) From a4519d3add0574cd0851978a123028aca7ae7cdc Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 21 Jul 2018 14:43:47 -0400 Subject: [PATCH 062/383] 0.0.4 --- setup.py | 2 +- torba/__init__.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index c0c2f9d9b..997be8e02 100644 --- a/setup.py +++ b/setup.py @@ -27,7 +27,7 @@ setup( ), packages=find_packages(exclude=('tests',)), include_package_data=True, - python_requires='>=2.7', + python_requires='>=3.7', install_requires=( 'twisted', 'ecdsa', diff --git a/torba/__init__.py b/torba/__init__.py index 8e2fe445a..a3b65bdd9 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__ = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.0.3' +__version__ = '0.0.4' From 0a2d916931a746cd471b765eea506c01934ca1e3 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 21 Jul 2018 15:06:20 -0400 Subject: [PATCH 063/383] py37 --- .travis.yml | 2 +- tox.ini | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index cc452243a..272294117 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,7 +1,7 @@ language: python python: - - "3.6" + - "3.7" install: - pip install tox-travis coverage diff --git a/tox.ini b/tox.ini index f859459b7..feaffd283 100644 --- a/tox.ini +++ b/tox.ini @@ -1,6 +1,6 @@ [tox] #envlist = unit,integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} -envlist = py36-unit,py36-integration-torba.coin.bitcoinsegwit +envlist = py37-unit,py37-integration-torba.coin.bitcoinsegwit [testenv] deps = From 93555cad3c54370ff5c2a056ee4476a2bbfff434 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 21 Jul 2018 15:57:26 -0400 Subject: [PATCH 064/383] ask travis to use xenial --- .travis.yml | 1 + tox.ini | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 272294117..b8dd1b77d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,3 +1,4 @@ +dist: xenial language: python python: diff --git a/tox.ini b/tox.ini index feaffd283..746107260 100644 --- a/tox.ini +++ b/tox.ini @@ -1,6 +1,6 @@ [tox] #envlist = unit,integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} -envlist = py37-unit,py37-integration-torba.coin.bitcoinsegwit +envlist = unit,integration-torba.coin.bitcoinsegwit [testenv] deps = From a03069bf89e24ed061efd5b7c774c3617e6325d3 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 21 Jul 2018 16:02:38 -0400 Subject: [PATCH 065/383] travis-ci sudo:true --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index b8dd1b77d..95224a7be 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,4 +1,5 @@ dist: xenial +sudo: true language: python python: From 2f83ebb3b5c0f68a370b6c10f3c8046cb3ee77bf Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 21 Jul 2018 16:12:25 -0400 Subject: [PATCH 066/383] tox fix --- tox.ini | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tox.ini b/tox.ini index 746107260..feaffd283 100644 --- a/tox.ini +++ b/tox.ini @@ -1,6 +1,6 @@ [tox] #envlist = unit,integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} -envlist = unit,integration-torba.coin.bitcoinsegwit +envlist = py37-unit,py37-integration-torba.coin.bitcoinsegwit [testenv] deps = From 25046124c05f00f5c99d8f9b1fe4cb55b6ac31d7 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 22 Jul 2018 22:52:21 -0400 Subject: [PATCH 067/383] fix balance with confirmations and header event reporting --- torba/baseaccount.py | 2 +- torba/basedatabase.py | 2 ++ torba/baseledger.py | 4 ++-- 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 92d64846c..39f933992 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -262,7 +262,7 @@ class BaseAccount(object): def get_balance(self, confirmations=6, **constraints): if confirmations > 0: height = self.ledger.headers.height - (confirmations-1) - constraints.update({'height__lte': height, 'height__not': -1}) + constraints.update({'height__lte': height, 'height__gt': 0}) return self.ledger.db.get_balance_for_account(self, **constraints) def get_unspent_outputs(self, **constraints): diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 3d4df697f..0c8d0a54f 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -232,6 +232,8 @@ class BaseDatabase(SQLiteMixin): col, op = key[:-len('__not')], '!=' elif key.endswith('__lte'): col, op = key[:-len('__lte')], '<=' + elif key.endswith('__gt'): + col, op = key[:-len('__gt')], '>' extras.append('{} {} :{}'.format(col, op, key)) extra_sql = ' AND ' + ' AND '.join(extras) if not include_reserved: diff --git a/torba/baseledger.py b/torba/baseledger.py index 25c6f22bb..b1d857716 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -212,7 +212,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): if headers['count'] <= 0: break yield self.headers.connect(height_sought, unhexlify(headers['hex'])) - self._on_header_controller.add(height_sought) + self._on_header_controller.add(self.headers.height) @defer.inlineCallbacks def process_header(self, response): @@ -222,7 +222,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): if header['height'] == len(self.headers): # New header from network directly connects after the last local header. yield self.headers.connect(len(self.headers), unhexlify(header['hex'])) - self._on_header_controller.add(len(self.headers)) + self._on_header_controller.add(self.headers.height) elif header['height'] > len(self.headers): # New header is several heights ahead of local, do download instead. yield self.update_headers() From c2a9027c19902115475e0f542939e1fa08e9a65d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 24 Jul 2018 04:02:53 -0400 Subject: [PATCH 068/383] python 3.6 is also supported --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 997be8e02..49b3d1130 100644 --- a/setup.py +++ b/setup.py @@ -27,7 +27,7 @@ setup( ), packages=find_packages(exclude=('tests',)), include_package_data=True, - python_requires='>=3.7', + python_requires='>=3.6', install_requires=( 'twisted', 'ecdsa', From 40651322d0772448e3b32258c7e57b0e70542987 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 25 Jul 2018 12:05:25 -0400 Subject: [PATCH 069/383] add account id to account balance listing --- torba/manager.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/torba/manager.py b/torba/manager.py index 7a674afb9..4f7f6e823 100644 --- a/torba/manager.py +++ b/torba/manager.py @@ -50,7 +50,8 @@ class WalletManager(object): 'account': account.name, 'coins': round(satoshis/COIN, 2), 'satoshis': satoshis, - 'is_default_account': i == 0 and j == 0 + 'is_default_account': i == j == 0, + 'id': account.public_key.address }) defer.returnValue(balances) From 5a2a3727b27ff52b7dabbce1724384218e0fc524 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 25 Jul 2018 23:29:41 -0400 Subject: [PATCH 070/383] + Account.get_max_gap() --- torba/baseaccount.py | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 39f933992..0f1c0c3f1 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -24,6 +24,9 @@ class KeyManager(object): self.account, self.chain_number, limit, max_used_times, order_by ) + def get_max_gap(self): # type: () -> defer.Deferred + raise NotImplementedError + def ensure_address_gap(self): # type: () -> defer.Deferred raise NotImplementedError @@ -65,6 +68,19 @@ class KeyChain(KeyManager): ) defer.returnValue([key[1].address for key in new_keys]) + @defer.inlineCallbacks + def get_max_gap(self): + addresses = yield self._query_addresses(order_by="position ASC") + max_gap = 0 + current_gap = 0 + for address in addresses: + if address['used_times'] == 0: + current_gap += 1 + else: + max_gap = max(max_gap, current_gap) + current_gap = 0 + defer.returnValue(max_gap) + @defer.inlineCallbacks def ensure_address_gap(self): addresses = yield self._query_addresses(self.gap, None, "position DESC") @@ -100,6 +116,9 @@ class SingleKey(KeyManager): # type: ('BaseAccount', PubKey) -> None super(SingleKey, self).__init__(account, root_public_key, chain_number) + def get_max_gap(self): + return defer.succeed(0) + @defer.inlineCallbacks def ensure_address_gap(self): exists = yield self.get_address_records() @@ -265,5 +284,14 @@ class BaseAccount(object): constraints.update({'height__lte': height, 'height__gt': 0}) return self.ledger.db.get_balance_for_account(self, **constraints) + @defer.inlineCallbacks + def get_max_gap(self): + change_gap = yield self.change.get_max_gap() + receiving_gap = yield self.receiving.get_max_gap() + defer.returnValue({ + 'max_change_gap': change_gap, + 'max_receiving_gap': receiving_gap, + }) + def get_unspent_outputs(self, **constraints): return self.ledger.db.get_utxos_for_account(self, **constraints) From 746aef474afebf4cfe5c15d1882437f5355c822c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 26 Jul 2018 14:35:44 -0400 Subject: [PATCH 071/383] hash.py dropping py2 backwards compat --- torba/hash.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/torba/hash.py b/torba/hash.py index d8ab42bb6..af1f74897 100644 --- a/torba/hash.py +++ b/torba/hash.py @@ -182,13 +182,13 @@ class Base58(object): @classmethod def decode(cls, txt): """ Decodes txt into a big-endian bytearray. """ - if six.PY2 and isinstance(txt, buffer): + if isinstance(txt, memoryview): txt = str(txt) - if isinstance(txt, six.binary_type): + if isinstance(txt, bytes): txt = txt.decode() - if not isinstance(txt, six.text_type): + if not isinstance(txt, str): raise TypeError('a string is required') if not txt: From b0bd0b1fc09331d839fb5ab8e2a81f005c032a57 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 28 Jul 2018 20:52:54 -0400 Subject: [PATCH 072/383] + reserving outpoints should no longer have race conditions + converted all comment type annotations to python 3 style syntax annotations + pylint & mypy --- .travis.yml | 28 +++-- setup.cfg | 23 ++++ setup.py | 3 +- tests/unit/test_coinselection.py | 12 +- tests/unit/test_ledger.py | 8 +- tests/unit/test_wallet.py | 6 +- torba/__init__.py | 2 +- torba/baseaccount.py | 91 +++++++------- torba/basedatabase.py | 39 +++--- torba/baseheader.py | 110 ++++++++--------- torba/baseledger.py | 121 ++++++++++++------- torba/{manager.py => basemanager.py} | 10 +- torba/basenetwork.py | 20 ++-- torba/basescript.py | 21 ++-- torba/basetransaction.py | 173 ++++++++++++++------------- torba/bcd_data_stream.py | 6 +- torba/bip32.py | 45 +++---- torba/coin/__init__.py | 2 +- torba/coin/bitcoincash.py | 9 +- torba/coin/bitcoinsegwit.py | 9 +- torba/coinselection.py | 28 +++-- torba/hash.py | 51 ++------ torba/mnemonic.py | 22 ++-- torba/stream.py | 42 ++----- torba/util.py | 23 ++-- torba/wallet.py | 25 ++-- 26 files changed, 482 insertions(+), 447 deletions(-) rename torba/{manager.py => basemanager.py} (89%) diff --git a/.travis.yml b/.travis.yml index 95224a7be..5b4e00b5a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,13 +5,25 @@ language: python python: - "3.7" -install: - - pip install tox-travis coverage - - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch lbryumx && popd - - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd +jobs: + include: -script: tox + - stage: code quality + name: "pylint & mypy" + install: + - pip install pylint mypy + - pip install -e . + script: + - pylint --rcfile=setup.cfg torba + - mypy torba -after_success: - - coverage combine tests/ - - bash <(curl -s https://codecov.io/bash) + - stage: test + name: "Unit Tests" + install: + - pip install tox-travis coverage + - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch lbryumx && popd + - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd + script: tox + after_success: + - coverage combine tests/ + - bash <(curl -s https://codecov.io/bash) diff --git a/setup.cfg b/setup.cfg index 96b5abc5a..66c7c22cf 100644 --- a/setup.cfg +++ b/setup.cfg @@ -5,3 +5,26 @@ branch = True source = torba .tox/*/lib/python*/site-packages/torba + +[mypy-twisted.*,cryptography.*,ecdsa.*,pbkdf2] +ignore_missing_imports = True + +[pylint] +max-args=10 +max-line-length=110 +good-names=T,t,n,i,j,k,x,y,s,f,d,h,c,e,op,db,tx,io,cachedproperty,log,id +valid-metaclass-classmethod-first-arg=mcs +disable= + fixme, + no-else-return, + cyclic-import, + missing-docstring, + duplicate-code, + expression-not-assigned, + inconsistent-return-statements, + too-few-public-methods, + too-many-locals, + too-many-arguments, + too-many-public-methods, + too-many-instance-attributes, + protected-access diff --git a/setup.py b/setup.py index 49b3d1130..4e1b7b954 100644 --- a/setup.py +++ b/setup.py @@ -32,8 +32,7 @@ setup( 'twisted', 'ecdsa', 'pbkdf2', - 'cryptography', - 'typing' + 'cryptography' ), extras_require={ 'test': ( diff --git a/tests/unit/test_coinselection.py b/tests/unit/test_coinselection.py index b2adbbd92..e607fc3ef 100644 --- a/tests/unit/test_coinselection.py +++ b/tests/unit/test_coinselection.py @@ -30,13 +30,13 @@ class BaseSelectionTestCase(unittest.TestCase): class TestCoinSelectionTests(BaseSelectionTestCase): def test_empty_coins(self): - self.assertIsNone(CoinSelector([], 0, 0).select()) + self.assertEqual(CoinSelector([], 0, 0).select(), []) def test_skip_binary_search_if_total_not_enough(self): fee = utxo(CENT).get_estimator(self.ledger).fee big_pool = self.estimates(utxo(CENT+fee) for _ in range(100)) selector = CoinSelector(big_pool, 101 * CENT, 0) - self.assertIsNone(selector.select()) + self.assertEqual(selector.select(), []) self.assertEqual(selector.tries, 0) # Never tried. # check happy path selector = CoinSelector(big_pool, 100 * CENT, 0) @@ -108,7 +108,7 @@ class TestOfficialBitcoinCoinSelectionTests(BaseSelectionTestCase): self.assertEqual([3 * CENT, 2 * CENT], search(utxo_pool, 5 * CENT, 0.5 * CENT)) # Select 11 Cent, not possible - self.assertIsNone(search(utxo_pool, 11 * CENT, 0.5 * CENT)) + self.assertEqual(search(utxo_pool, 11 * CENT, 0.5 * CENT), []) # Select 10 Cent utxo_pool += self.estimates(utxo(5 * CENT)) @@ -126,12 +126,12 @@ class TestOfficialBitcoinCoinSelectionTests(BaseSelectionTestCase): ) # Select 0.25 Cent, not possible - self.assertIsNone(search(utxo_pool, 0.25 * CENT, 0.5 * CENT)) + self.assertEqual(search(utxo_pool, 0.25 * CENT, 0.5 * CENT), []) # Iteration exhaustion test utxo_pool, target = self.make_hard_case(17) selector = CoinSelector(utxo_pool, target, 0) - self.assertIsNone(selector.branch_and_bound()) + self.assertEqual(selector.branch_and_bound(), []) self.assertEqual(selector.tries, MAXIMUM_TRIES) # Should exhaust utxo_pool, target = self.make_hard_case(14) self.assertIsNotNone(search(utxo_pool, target, 0)) # Should not exhaust @@ -152,4 +152,4 @@ class TestOfficialBitcoinCoinSelectionTests(BaseSelectionTestCase): # Select 1 Cent with pool of only greater than 5 Cent utxo_pool = self.estimates(utxo(i * CENT) for i in range(5, 21)) for _ in range(100): - self.assertIsNone(search(utxo_pool, 1 * CENT, 2 * CENT)) + self.assertEqual(search(utxo_pool, 1 * CENT, 2 * CENT), []) diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index afedf6042..6a6aff21b 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -1,4 +1,3 @@ -import six from binascii import hexlify from twisted.trial import unittest from twisted.internet import defer @@ -7,9 +6,6 @@ from torba.coin.bitcoinsegwit import MainNetLedger from .test_transaction import get_transaction, get_output -if six.PY3: - buffer = memoryview - class MockNetwork: @@ -50,9 +46,7 @@ class MainNetTestLedger(MainNetLedger): network_name = 'unittest' def __init__(self): - super(MainNetLedger, self).__init__({ - 'db': MainNetLedger.database_class(':memory:') - }) + super().__init__({'db': MainNetLedger.database_class(':memory:')}) class LedgerTestCase(unittest.TestCase): diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index c52119e4e..b52ee4ebb 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -3,14 +3,14 @@ from twisted.trial import unittest from torba.coin.bitcoinsegwit import MainNetLedger as BTCLedger from torba.coin.bitcoincash import MainNetLedger as BCHLedger -from torba.manager import WalletManager +from torba.basemanager import BaseWalletManager from torba.wallet import Wallet, WalletStorage class TestWalletCreation(unittest.TestCase): def setUp(self): - self.manager = WalletManager() + self.manager = BaseWalletManager() config = {'data_path': '/tmp/wallet'} self.btc_ledger = self.manager.get_or_create_ledger(BTCLedger.get_id(), config) self.bch_ledger = self.manager.get_or_create_ledger(BCHLedger.get_id(), config) @@ -63,7 +63,7 @@ class TestWalletCreation(unittest.TestCase): self.assertDictEqual(wallet_dict, wallet.to_dict()) def test_read_write(self): - manager = WalletManager() + manager = BaseWalletManager() config = {'data_path': '/tmp/wallet'} ledger = manager.get_or_create_ledger(BTCLedger.get_id(), config) diff --git a/torba/__init__.py b/torba/__init__.py index a3b65bdd9..210e2b896 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ -__path__ = __import__('pkgutil').extend_path(__path__, __name__) +__path__: str = __import__('pkgutil').extend_path(__path__, __name__) __version__ = '0.0.4' diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 0f1c0c3f1..532b364da 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -1,12 +1,16 @@ -from typing import Dict +import typing +from typing import Sequence from twisted.internet import defer from torba.mnemonic import Mnemonic from torba.bip32 import PrivateKey, PubKey, from_extended_key_string from torba.hash import double_sha256, aes_encrypt, aes_decrypt +if typing.TYPE_CHECKING: + from torba import baseledger -class KeyManager(object): + +class KeyManager: __slots__ = 'account', 'public_key', 'chain_number' @@ -19,27 +23,27 @@ class KeyManager(object): def db(self): return self.account.ledger.db - def _query_addresses(self, limit=None, max_used_times=None, order_by=None): + def _query_addresses(self, limit: int = None, max_used_times: int = None, order_by=None): return self.db.get_addresses( self.account, self.chain_number, limit, max_used_times, order_by ) - def get_max_gap(self): # type: () -> defer.Deferred + def get_max_gap(self) -> defer.Deferred: raise NotImplementedError - def ensure_address_gap(self): # type: () -> defer.Deferred + def ensure_address_gap(self) -> defer.Deferred: raise NotImplementedError - def get_address_records(self, limit=None, only_usable=False): # type: (int, bool) -> defer.Deferred + def get_address_records(self, limit: int = None, only_usable: bool = False) -> defer.Deferred: raise NotImplementedError @defer.inlineCallbacks - def get_addresses(self, limit=None, only_usable=False): # type: (int, bool) -> defer.Deferred + def get_addresses(self, limit: int = None, only_usable: bool = False) -> defer.Deferred: records = yield self.get_address_records(limit=limit, only_usable=only_usable) defer.returnValue([r['address'] for r in records]) @defer.inlineCallbacks - def get_or_create_usable_address(self): # type: () -> defer.Deferred + def get_or_create_usable_address(self) -> defer.Deferred: addresses = yield self.get_addresses(limit=1, only_usable=True) if addresses: defer.returnValue(addresses[0]) @@ -52,14 +56,14 @@ class KeyChain(KeyManager): __slots__ = 'gap', 'maximum_uses_per_address' - def __init__(self, account, root_public_key, chain_number, gap, maximum_uses_per_address): - # type: ('BaseAccount', PubKey, int, int, int) -> None - super(KeyChain, self).__init__(account, root_public_key.child(chain_number), chain_number) + def __init__(self, account: 'BaseAccount', root_public_key: PubKey, + chain_number: int, gap: int, maximum_uses_per_address: int) -> None: + super().__init__(account, root_public_key.child(chain_number), chain_number) self.gap = gap self.maximum_uses_per_address = maximum_uses_per_address @defer.inlineCallbacks - def generate_keys(self, start, end): + def generate_keys(self, start: int, end: int) -> defer.Deferred: new_keys = [] for index in range(start, end+1): new_keys.append((index, self.public_key.child(index))) @@ -69,7 +73,7 @@ class KeyChain(KeyManager): defer.returnValue([key[1].address for key in new_keys]) @defer.inlineCallbacks - def get_max_gap(self): + def get_max_gap(self) -> defer.Deferred: addresses = yield self._query_addresses(order_by="position ASC") max_gap = 0 current_gap = 0 @@ -82,7 +86,7 @@ class KeyChain(KeyManager): defer.returnValue(max_gap) @defer.inlineCallbacks - def ensure_address_gap(self): + def ensure_address_gap(self) -> defer.Deferred: addresses = yield self._query_addresses(self.gap, None, "position DESC") existing_gap = 0 @@ -100,7 +104,7 @@ class KeyChain(KeyManager): new_keys = yield self.generate_keys(start, end-1) defer.returnValue(new_keys) - def get_address_records(self, limit=None, only_usable=False): + def get_address_records(self, limit: int = None, only_usable: bool = False): return self._query_addresses( limit, self.maximum_uses_per_address if only_usable else None, "used_times ASC, position ASC" @@ -112,15 +116,11 @@ class SingleKey(KeyManager): __slots__ = () - def __init__(self, account, root_public_key, chain_number): - # type: ('BaseAccount', PubKey) -> None - super(SingleKey, self).__init__(account, root_public_key, chain_number) - - def get_max_gap(self): + def get_max_gap(self) -> defer.Deferred: return defer.succeed(0) @defer.inlineCallbacks - def ensure_address_gap(self): + def ensure_address_gap(self) -> defer.Deferred: exists = yield self.get_address_records() if not exists: yield self.db.add_keys( @@ -129,20 +129,20 @@ class SingleKey(KeyManager): defer.returnValue([self.public_key.address]) defer.returnValue([]) - def get_address_records(self, **kwargs): + def get_address_records(self, limit: int = None, only_usable: bool = False) -> defer.Deferred: return self._query_addresses() -class BaseAccount(object): +class BaseAccount: mnemonic_class = Mnemonic private_key_class = PrivateKey public_key_class = PubKey - def __init__(self, ledger, name, seed, encrypted, is_hd, private_key, - public_key, receiving_gap=20, change_gap=6, - receiving_maximum_uses_per_address=2, change_maximum_uses_per_address=2): - # type: (torba.baseledger.BaseLedger, str, str, bool, bool, PrivateKey, PubKey, int, int, int, int) -> None + def __init__(self, ledger: 'baseledger.BaseLedger', name: str, seed: str, encrypted: bool, is_hd: bool, + private_key: PrivateKey, public_key: PubKey, receiving_gap: int = 20, change_gap: int = 6, + receiving_maximum_uses_per_address: int = 2, change_maximum_uses_per_address: int = 2 + ) -> None: self.ledger = ledger self.name = name self.seed = seed @@ -150,25 +150,26 @@ class BaseAccount(object): self.private_key = private_key self.public_key = public_key if is_hd: - receiving, change = self.keychains = ( - KeyChain(self, public_key, 0, receiving_gap, receiving_maximum_uses_per_address), - KeyChain(self, public_key, 1, change_gap, change_maximum_uses_per_address) + self.receiving: KeyManager = KeyChain( + self, public_key, 0, receiving_gap, receiving_maximum_uses_per_address ) + self.change: KeyManager = KeyChain( + self, public_key, 1, change_gap, change_maximum_uses_per_address + ) + self.keychains: Sequence[KeyManager] = (self.receiving, self.change) else: - self.keychains = SingleKey(self, public_key, 0), - receiving = change = self.keychains[0] - self.receiving = receiving # type: KeyManager - self.change = change # type: KeyManager + self.change = self.receiving = SingleKey(self, public_key, 0) + self.keychains = (self.receiving,) ledger.add_account(self) @classmethod - def generate(cls, ledger, password, **kwargs): # type: (torba.baseledger.BaseLedger, str) -> BaseAccount + def generate(cls, ledger: 'baseledger.BaseLedger', password: str, **kwargs): seed = cls.mnemonic_class().make_seed() return cls.from_seed(ledger, seed, password, **kwargs) @classmethod - def from_seed(cls, ledger, seed, password, is_hd=True, **kwargs): - # type: (torba.baseledger.BaseLedger, str, str) -> BaseAccount + def from_seed(cls, ledger: 'baseledger.BaseLedger', seed: str, password: str, + is_hd: bool = True, **kwargs): private_key = cls.get_private_key_from_seed(ledger, seed, password) return cls( ledger=ledger, name='Account #{}'.format(private_key.public_key.address), @@ -179,14 +180,13 @@ class BaseAccount(object): ) @classmethod - def get_private_key_from_seed(cls, ledger, seed, password): - # type: (torba.baseledger.BaseLedger, str, str) -> PrivateKey + def get_private_key_from_seed(cls, ledger: 'baseledger.BaseLedger', seed: str, password: str): return cls.private_key_class.from_seed( ledger, cls.mnemonic_class.mnemonic_to_seed(seed, password) ) @classmethod - def from_dict(cls, ledger, d): # type: (torba.baseledger.BaseLedger, Dict) -> BaseAccount + def from_dict(cls, ledger: 'baseledger.BaseLedger', d: dict): if not d['encrypted'] and d['private_key']: private_key = from_extended_key_string(ledger, d['private_key']) public_key = private_key.public_key @@ -264,21 +264,20 @@ class BaseAccount(object): defer.returnValue(addresses) @defer.inlineCallbacks - def get_addresses(self, limit=None, max_used_times=None): # type: (int, int) -> defer.Deferred + def get_addresses(self, limit: int = None, max_used_times: int = None) -> defer.Deferred: records = yield self.get_address_records(limit, max_used_times) defer.returnValue([r['address'] for r in records]) - def get_address_records(self, limit=None, max_used_times=None): # type: (int, int) -> defer.Deferred + def get_address_records(self, limit: int = None, max_used_times: int = None) -> defer.Deferred: return self.ledger.db.get_addresses(self, None, limit, max_used_times) - def get_private_key(self, chain, index): + def get_private_key(self, chain: int, index: int) -> PrivateKey: assert not self.encrypted, "Cannot get private key on encrypted wallet account." if isinstance(self.receiving, SingleKey): return self.private_key - else: - return self.private_key.child(chain).child(index) + return self.private_key.child(chain).child(index) - def get_balance(self, confirmations=6, **constraints): + def get_balance(self, confirmations: int = 6, **constraints): if confirmations > 0: height = self.ledger.headers.height - (confirmations-1) constraints.update({'height__lte': height, 'height__gt': 0}) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 0c8d0a54f..b086f7700 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -1,5 +1,5 @@ import logging -from typing import List, Union +from typing import Tuple, List, Sequence from operator import itemgetter import sqlite3 @@ -11,13 +11,13 @@ from torba.hash import TXRefImmutable log = logging.getLogger(__name__) -class SQLiteMixin(object): +class SQLiteMixin: - CREATE_TABLES_QUERY = None + CREATE_TABLES_QUERY: Sequence[str] = () def __init__(self, path): self._db_path = path - self.db = None + self.db: adbapi.ConnectionPool = None def start(self): log.info("connecting to database: %s", self._db_path) @@ -32,8 +32,8 @@ class SQLiteMixin(object): self.db.close() return defer.succeed(True) - def _insert_sql(self, table, data): - # type: (str, dict) -> tuple[str, List] + @staticmethod + def _insert_sql(table: str, data: dict) -> Tuple[str, List]: columns, values = [], [] for column, value in data.items(): columns.append(column) @@ -43,8 +43,8 @@ class SQLiteMixin(object): ) return sql, values - def _update_sql(self, table, data, where, constraints): - # type: (str, dict) -> tuple[str, List] + @staticmethod + def _update_sql(table: str, data: dict, where: str, constraints: list) -> Tuple[str, list]: columns, values = [], [] for column, value in data.items(): columns.append("{} = ?".format(column)) @@ -146,7 +146,8 @@ class BaseDatabase(SQLiteMixin): CREATE_TXI_TABLE ) - def txo_to_row(self, tx, address, txo): + @staticmethod + def txo_to_row(tx, address, txo): return { 'txid': tx.id, 'txoid': txo.id, @@ -156,7 +157,7 @@ class BaseDatabase(SQLiteMixin): 'script': sqlite3.Binary(txo.script.source) } - def save_transaction_io(self, save_tx, tx, height, is_verified, address, hash, history): + def save_transaction_io(self, save_tx, tx, height, is_verified, address, txhash, history): def _steps(t): if save_tx == 'insert': @@ -168,9 +169,8 @@ class BaseDatabase(SQLiteMixin): })) elif save_tx == 'update': self.execute(t, *self._update_sql("tx", { - 'height': height, 'is_verified': is_verified - }, 'txid = ?', (tx.id,) - )) + 'height': height, 'is_verified': is_verified + }, 'txid = ?', (tx.id,))) existing_txos = list(map(itemgetter(0), self.execute( t, "SELECT position FROM txo WHERE txid = ?", (tx.id,) @@ -179,7 +179,7 @@ class BaseDatabase(SQLiteMixin): for txo in tx.outputs: if txo.position in existing_txos: continue - if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == hash: + if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == txhash: self.execute(t, *self._insert_sql("txo", self.txo_to_row(tx, address, txo))) elif txo.script.is_pay_script_hash: # TODO: implement script hash payments @@ -202,15 +202,16 @@ class BaseDatabase(SQLiteMixin): return self.db.runInteraction(_steps) - def reserve_spent_outputs(self, txoids, is_reserved=True): + def reserve_outputs(self, txos, is_reserved=True): + txoids = [txo.id for txo in txos] return self.run_operation( "UPDATE txo SET is_reserved = ? WHERE txoid IN ({})".format( ', '.join(['?']*len(txoids)) ), [is_reserved]+txoids ) - def release_reserved_outputs(self, txoids): - return self.reserve_spent_outputs(txoids, is_reserved=False) + def release_outputs(self, txos): + return self.reserve_outputs(txos, is_reserved=False) @defer.inlineCallbacks def get_transaction(self, txid): @@ -226,7 +227,7 @@ class BaseDatabase(SQLiteMixin): extra_sql = "" if constraints: extras = [] - for key in constraints.keys(): + for key in constraints: col, op = key, '=' if key.endswith('__not'): col, op = key[:-len('__not')], '!=' @@ -257,7 +258,7 @@ class BaseDatabase(SQLiteMixin): extra_sql = "" if constraints: extra_sql = ' AND ' + ' AND '.join( - '{} = :{}'.format(c, c) for c in constraints.keys() + '{} = :{}'.format(c, c) for c in constraints ) values = {'account': account.public_key.address} values.update(constraints) diff --git a/torba/baseheader.py b/torba/baseheader.py index 8815a6437..e28fde892 100644 --- a/torba/baseheader.py +++ b/torba/baseheader.py @@ -1,13 +1,16 @@ import os import struct import logging +import typing from binascii import unhexlify from twisted.internet import threads, defer -from torba.stream import StreamController, execute_serially +from torba.stream import StreamController from torba.util import int_to_hex, rev_hex, hash_encode from torba.hash import double_sha256, pow_hash +if typing.TYPE_CHECKING: + from torba import baseledger log = logging.getLogger(__name__) @@ -17,7 +20,7 @@ class BaseHeaders: header_size = 80 verify_bits_to_target = True - def __init__(self, ledger): # type: (baseledger.BaseLedger) -> BaseHeaders + def __init__(self, ledger: 'baseledger.BaseLedger') -> None: self.ledger = ledger self._size = None self._on_change_controller = StreamController() @@ -62,7 +65,6 @@ class BaseHeaders: header = self.sync_read_header(height) return self._deserialize(height, header) - @execute_serially @defer.inlineCallbacks def connect(self, start, headers): yield threads.deferToThread(self._sync_connect, start, headers) @@ -84,8 +86,9 @@ class BaseHeaders: _old_size = self._size self._size = self.sync_read_length() change = self._size - _old_size - log.info('{}: added {} header blocks, final height {}'.format( - self.ledger.get_id(), change, self.height) + log.info( + '%s: added %s header blocks, final height %s', + self.ledger.get_id(), change, self.height ) self._on_change_controller.add(change) @@ -101,7 +104,7 @@ class BaseHeaders: assert previous_hash == header['prev_block_hash'], \ "prev hash mismatch: {} vs {}".format(previous_hash, header['prev_block_hash']) - bits, target = self._calculate_next_work_required(height, previous_header, header) + bits, _ = self._calculate_next_work_required(height, previous_header, header) assert bits == header['bits'], \ "bits mismatch: {} vs {} (hash: {})".format( bits, header['bits'], self._hash_header(header)) @@ -154,37 +157,37 @@ class BaseHeaders: if self.verify_bits_to_target: bits = last['bits'] - bitsN = (bits >> 24) & 0xff - assert 0x03 <= bitsN <= 0x1d, \ - "First part of bits should be in [0x03, 0x1d], but it was {}".format(hex(bitsN)) - bitsBase = bits & 0xffffff - assert 0x8000 <= bitsBase <= 0x7fffff, \ - "Second part of bits should be in [0x8000, 0x7fffff] but it was {}".format(bitsBase) + bits_n = (bits >> 24) & 0xff + assert 0x03 <= bits_n <= 0x1d, \ + "First part of bits should be in [0x03, 0x1d], but it was {}".format(hex(bits_n)) + bits_base = bits & 0xffffff + assert 0x8000 <= bits_base <= 0x7fffff, \ + "Second part of bits should be in [0x8000, 0x7fffff] but it was {}".format(bits_base) # new target - retargetTimespan = self.ledger.target_timespan - nActualTimespan = last['timestamp'] - first['timestamp'] + retarget_timespan = self.ledger.target_timespan + n_actual_timespan = last['timestamp'] - first['timestamp'] - nModulatedTimespan = retargetTimespan + (nActualTimespan - retargetTimespan) // 8 + n_modulated_timespan = retarget_timespan + (n_actual_timespan - retarget_timespan) // 8 - nMinTimespan = retargetTimespan - (retargetTimespan // 8) - nMaxTimespan = retargetTimespan + (retargetTimespan // 2) + n_min_timespan = retarget_timespan - (retarget_timespan // 8) + n_max_timespan = retarget_timespan + (retarget_timespan // 2) # Limit adjustment step - if nModulatedTimespan < nMinTimespan: - nModulatedTimespan = nMinTimespan - elif nModulatedTimespan > nMaxTimespan: - nModulatedTimespan = nMaxTimespan + if n_modulated_timespan < n_min_timespan: + n_modulated_timespan = n_min_timespan + elif n_modulated_timespan > n_max_timespan: + n_modulated_timespan = n_max_timespan # Retarget - bnPowLimit = _ArithUint256(self.ledger.max_target) - bnNew = _ArithUint256.SetCompact(last['bits']) - bnNew *= nModulatedTimespan - bnNew //= nModulatedTimespan - if bnNew > bnPowLimit: - bnNew = bnPowLimit + bn_pow_limit = _ArithUint256(self.ledger.max_target) + bn_new = _ArithUint256.set_compact(last['bits']) + bn_new *= n_modulated_timespan + bn_new //= n_modulated_timespan + if bn_new > bn_pow_limit: + bn_new = bn_pow_limit - return bnNew.GetCompact(), bnNew._value + return bn_new.get_compact(), bn_new._value class _ArithUint256: @@ -197,49 +200,48 @@ class _ArithUint256: return hex(self._value) @staticmethod - def fromCompact(nCompact): + def from_compact(n_compact): """Convert a compact representation into its value""" - nSize = nCompact >> 24 + n_size = n_compact >> 24 # the lower 23 bits - nWord = nCompact & 0x007fffff - if nSize <= 3: - return nWord >> 8 * (3 - nSize) + n_word = n_compact & 0x007fffff + if n_size <= 3: + return n_word >> 8 * (3 - n_size) else: - return nWord << 8 * (nSize - 3) + return n_word << 8 * (n_size - 3) @classmethod - def SetCompact(cls, nCompact): - return cls(cls.fromCompact(nCompact)) + def set_compact(cls, n_compact): + return cls(cls.from_compact(n_compact)) def bits(self): """Returns the position of the highest bit set plus one.""" - bn = bin(self._value)[2:] - for i, d in enumerate(bn): + bits = bin(self._value)[2:] + for i, d in enumerate(bits): if d: - return (len(bn) - i) + 1 + return (len(bits) - i) + 1 return 0 - def GetLow64(self): + def get_low64(self): return self._value & 0xffffffffffffffff - def GetCompact(self): + def get_compact(self): """Convert a value into its compact representation""" - nSize = (self.bits() + 7) // 8 - nCompact = 0 - if nSize <= 3: - nCompact = self.GetLow64() << 8 * (3 - nSize) + n_size = (self.bits() + 7) // 8 + if n_size <= 3: + n_compact = self.get_low64() << 8 * (3 - n_size) else: - bn = _ArithUint256(self._value >> 8 * (nSize - 3)) - nCompact = bn.GetLow64() + n = _ArithUint256(self._value >> 8 * (n_size - 3)) + n_compact = n.get_low64() # The 0x00800000 bit denotes the sign. # Thus, if it is already set, divide the mantissa by 256 and increase the exponent. - if nCompact & 0x00800000: - nCompact >>= 8 - nSize += 1 - assert (nCompact & ~0x007fffff) == 0 - assert nSize < 256 - nCompact |= nSize << 24 - return nCompact + if n_compact & 0x00800000: + n_compact >>= 8 + n_size += 1 + assert (n_compact & ~0x007fffff) == 0 + assert n_size < 256 + n_compact |= n_size << 24 + return n_compact def __mul__(self, x): # Take the mod because we are limited to an unsigned 256 bit number diff --git a/torba/baseledger.py b/torba/baseledger.py index b1d857716..bf64bfd01 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -1,6 +1,4 @@ import os -import six -import hashlib import logging from binascii import hexlify, unhexlify from typing import Dict, Type, Iterable @@ -14,17 +12,22 @@ from torba import basedatabase from torba import baseheader from torba import basenetwork from torba import basetransaction -from torba.stream import StreamController, execute_serially -from torba.hash import hash160, double_sha256, Base58 +from torba.coinselection import CoinSelector +from torba.constants import COIN, NULL_HASH32 +from torba.stream import StreamController +from torba.hash import hash160, double_sha256, sha256, Base58 log = logging.getLogger(__name__) +LedgerType = Type['BaseLedger'] + class LedgerRegistry(type): - ledgers = {} # type: Dict[str, Type[BaseLedger]] + + ledgers: Dict[str, LedgerType] = {} def __new__(mcs, name, bases, attrs): - cls = super(LedgerRegistry, mcs).__new__(mcs, name, bases, attrs) # type: Type[BaseLedger] + cls: LedgerType = super().__new__(mcs, name, bases, attrs) if not (name == 'BaseLedger' and not bases): ledger_id = cls.get_id() assert ledger_id not in mcs.ledgers,\ @@ -33,7 +36,7 @@ class LedgerRegistry(type): return cls @classmethod - def get_ledger_class(mcs, ledger_id): # type: (str) -> Type[BaseLedger] + def get_ledger_class(mcs, ledger_id: str) -> LedgerType: return mcs.ledgers[ledger_id] @@ -41,11 +44,11 @@ class TransactionEvent(namedtuple('TransactionEvent', ('address', 'tx', 'height' pass -class BaseLedger(six.with_metaclass(LedgerRegistry)): +class BaseLedger(metaclass=LedgerRegistry): - name = None - symbol = None - network_name = None + name: str + symbol: str + network_name: str account_class = baseaccount.BaseAccount database_class = basedatabase.BaseDatabase @@ -54,10 +57,10 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): transaction_class = basetransaction.BaseTransaction secret_prefix = None - pubkey_address_prefix = None - script_address_prefix = None - extended_public_key_prefix = None - extended_private_key_prefix = None + pubkey_address_prefix: bytes + script_address_prefix: bytes + extended_public_key_prefix: bytes + extended_private_key_prefix: bytes default_fee_per_byte = 10 @@ -71,13 +74,14 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): self.network.on_status.listen(self.process_status) self.accounts = [] self.headers = self.config.get('headers') or self.headers_class(self) - self.fee_per_byte = self.config.get('fee_per_byte', self.default_fee_per_byte) + self.fee_per_byte: int = self.config.get('fee_per_byte', self.default_fee_per_byte) self._on_transaction_controller = StreamController() self.on_transaction = self._on_transaction_controller.stream self.on_transaction.listen( - lambda e: log.info('({}) on_transaction: address={}, height={}, is_verified={}, tx.id={}'.format( - self.get_id(), e.address, e.height, e.is_verified, e.tx.id) + lambda e: log.info( + '(%s) on_transaction: address=%s, height=%s, is_verified=%s, tx.id=%s', + self.get_id(), e.address, e.height, e.is_verified, e.tx.id ) ) @@ -85,6 +89,8 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): self.on_header = self._on_header_controller.stream self._transaction_processing_locks = {} + self._utxo_reservation_lock = defer.DeferredLock() + self._header_processing_lock = defer.DeferredLock() @classmethod def get_id(cls): @@ -97,9 +103,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): @staticmethod def address_to_hash160(address): - bytes = Base58.decode(address) - prefix, pubkey_bytes, addr_checksum = bytes[0], bytes[1:21], bytes[21:] - return pubkey_bytes + return Base58.decode(address)[1:21] @classmethod def public_key_to_address(cls, public_key): @@ -113,7 +117,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): def path(self): return os.path.join(self.config['data_path'], self.get_id()) - def get_input_output_fee(self, io): + def get_input_output_fee(self, io: basetransaction.InputOutput) -> int: """ Fee based on size of the input / output. """ return self.fee_per_byte * io.size @@ -122,14 +126,14 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): return self.fee_per_byte * tx.base_size @defer.inlineCallbacks - def add_account(self, account): # type: (baseaccount.BaseAccount) -> None + def add_account(self, account: baseaccount.BaseAccount) -> defer.Deferred: self.accounts.append(account) if self.network.is_connected: yield self.update_account(account) @defer.inlineCallbacks def get_transaction(self, txhash): - raw, height, is_verified = yield self.db.get_transaction(txhash) + raw, _, _ = yield self.db.get_transaction(txhash) if raw is not None: defer.returnValue(self.transaction_class(raw)) @@ -142,8 +146,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): defer.returnValue(account.get_private_key(match['chain'], match['position'])) @defer.inlineCallbacks - def get_effective_amount_estimators(self, funding_accounts): - # type: (Iterable[baseaccount.BaseAccount]) -> defer.Deferred + def get_effective_amount_estimators(self, funding_accounts: Iterable[baseaccount.BaseAccount]): estimators = [] for account in funding_accounts: utxos = yield account.get_unspent_outputs() @@ -151,12 +154,39 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): estimators.append(utxo.get_estimator(self)) defer.returnValue(estimators) + @defer.inlineCallbacks + def get_spendable_utxos(self, amount: int, funding_accounts): + yield self._utxo_reservation_lock.acquire() + try: + txos = yield self.get_effective_amount_estimators(funding_accounts) + selector = CoinSelector( + txos, amount, + self.get_input_output_fee( + self.transaction_class.output_class.pay_pubkey_hash(COIN, NULL_HASH32) + ) + ) + spendables = selector.select() + if spendables: + yield self.reserve_outputs(s.txo for s in spendables) + except Exception: + log.exception('Failed to get spendable utxos:') + raise + finally: + self._utxo_reservation_lock.release() + defer.returnValue(spendables) + + def reserve_outputs(self, txos): + return self.db.reserve_outputs(txos) + + def release_outputs(self, txos): + return self.db.release_outputs(txos) + @defer.inlineCallbacks def get_local_status(self, address): address_details = yield self.db.get_address(address) history = address_details['history'] or '' - hash = hashlib.sha256(history.encode()).digest() - defer.returnValue(hexlify(hash)) + h = sha256(history.encode()) + defer.returnValue(hexlify(h)) @defer.inlineCallbacks def get_local_history(self, address): @@ -203,7 +233,6 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): yield self.network.stop() yield self.db.stop() - @execute_serially @defer.inlineCallbacks def update_headers(self): while True: @@ -216,18 +245,19 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): @defer.inlineCallbacks def process_header(self, response): - header = response[0] - if self.update_headers.is_running: - return - if header['height'] == len(self.headers): - # New header from network directly connects after the last local header. - yield self.headers.connect(len(self.headers), unhexlify(header['hex'])) - self._on_header_controller.add(self.headers.height) - elif header['height'] > len(self.headers): - # New header is several heights ahead of local, do download instead. - yield self.update_headers() + yield self._header_processing_lock.acquire() + try: + header = response[0] + if header['height'] == len(self.headers): + # New header from network directly connects after the last local header. + yield self.headers.connect(len(self.headers), unhexlify(header['hex'])) + self._on_header_controller.add(self.headers.height) + elif header['height'] > len(self.headers): + # New header is several heights ahead of local, do download instead. + yield self.update_headers() + finally: + self._header_processing_lock.release() - @execute_serially def update_accounts(self): return defer.DeferredList([ self.update_account(a) for a in self.accounts @@ -274,7 +304,7 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): try: # see if we have a local copy of transaction, otherwise fetch it from server - raw, local_height, is_verified = yield self.db.get_transaction(hex_id) + raw, _, is_verified = yield self.db.get_transaction(hex_id) save_tx = None if raw is None: _raw = yield self.network.get_transaction(hex_id) @@ -294,15 +324,16 @@ class BaseLedger(six.with_metaclass(LedgerRegistry)): ''.join('{}:{}:'.format(tx_id, tx_height) for tx_id, tx_height in synced_history) ) - log.debug("{}: sync'ed tx {} for address: {}, height: {}, verified: {}".format( + log.debug( + "%s: sync'ed tx %s for address: %s, height: %s, verified: %s", self.get_id(), hex_id, address, remote_height, is_verified - )) + ) self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) - except Exception as e: + except Exception: log.exception('Failed to synchronize transaction:') - raise e + raise finally: lock.release() diff --git a/torba/manager.py b/torba/basemanager.py similarity index 89% rename from torba/manager.py rename to torba/basemanager.py index 4f7f6e823..7c18a16ef 100644 --- a/torba/manager.py +++ b/torba/basemanager.py @@ -1,4 +1,4 @@ -from typing import List, Dict, Type +from typing import Type, MutableSequence, MutableMapping from twisted.internet import defer from torba.baseledger import BaseLedger, LedgerRegistry @@ -6,16 +6,16 @@ from torba.wallet import Wallet, WalletStorage from torba.constants import COIN -class WalletManager(object): +class BaseWalletManager: - def __init__(self, wallets=None, ledgers=None): - # type: (List[Wallet], Dict[Type[BaseLedger],BaseLedger]) -> None + def __init__(self, wallets: MutableSequence[Wallet] = None, + ledgers: MutableMapping[Type[BaseLedger], BaseLedger] = None) -> None: self.wallets = wallets or [] self.ledgers = ledgers or {} self.running = False @classmethod - def from_config(cls, config): # type: (Dict) -> WalletManager + def from_config(cls, config: dict) -> 'BaseWalletManager': manager = cls() for ledger_id, ledger_config in config.get('ledgers', {}).items(): manager.get_or_create_ledger(ledger_id, ledger_config) diff --git a/torba/basenetwork.py b/torba/basenetwork.py index cdc74c61b..c1f3926d9 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -21,6 +21,7 @@ class StratumClientProtocol(LineOnlyReceiver): self.request_id = 0 self.lookup_table = {} self.session = {} + self.network = None self.on_disconnected_controller = StreamController() self.on_disconnected = self.on_disconnected_controller.stream @@ -52,7 +53,7 @@ class StratumClientProtocol(LineOnlyReceiver): socket.SOL_TCP, socket.TCP_KEEPCNT, 5 # Failed keepalive probles before declaring other end dead ) - except Exception as err: + except Exception as err: # pylint: disable=broad-except # Supported only by the socket transport, # but there's really no better place in code to trigger this. log.warning("Error setting up socket: %s", err) @@ -61,7 +62,7 @@ class StratumClientProtocol(LineOnlyReceiver): self.on_disconnected_controller.add(True) def lineReceived(self, line): - log.debug('received: {}'.format(line)) + log.debug('received: %s', line) try: message = json.loads(line) @@ -82,7 +83,7 @@ class StratumClientProtocol(LineOnlyReceiver): controller = self.network.subscription_controllers[message['method']] controller.add(message.get('params')) else: - log.warning("Cannot handle message '%s'" % line) + log.warning("Cannot handle message '%s'", line) def rpc(self, method, *args): message_id = self._get_id() @@ -91,7 +92,7 @@ class StratumClientProtocol(LineOnlyReceiver): 'method': method, 'params': args }) - log.debug('sent: {}'.format(message)) + log.debug('sent: %s', message) self.sendLine(message.encode('latin-1')) d = self.lookup_table[message_id] = defer.Deferred() return d @@ -138,20 +139,21 @@ class BaseNetwork: @defer.inlineCallbacks def start(self): for server in cycle(self.config['default_servers']): - endpoint = clientFromString(reactor, 'tcp:{}:{}'.format(*server)) - log.debug("Attempting connection to SPV wallet server: {}:{}".format(*server)) + connection_string = 'tcp:{}:{}'.format(*server) + endpoint = clientFromString(reactor, connection_string) + log.debug("Attempting connection to SPV wallet server: %s", connection_string) self.service = ClientService(endpoint, StratumClientFactory(self)) self.service.startService() try: self.client = yield self.service.whenConnected(failAfterFailures=2) yield self.ensure_server_version() - log.info("Successfully connected to SPV wallet server: {}:{}".format(*server)) + log.info("Successfully connected to SPV wallet server: %s", connection_string) self._on_connected_controller.add(True) yield self.client.on_disconnected.first except CancelledError: return - except Exception: - log.exception("Connecting to {}:{} raised an exception:".format(*server)) + except Exception: # pylint: disable=broad-except + log.exception("Connecting to %s raised an exception:", connection_string) finally: self.client = None if not self.running: diff --git a/torba/basescript.py b/torba/basescript.py index 4cacf6e47..da3527477 100644 --- a/torba/basescript.py +++ b/torba/basescript.py @@ -1,6 +1,7 @@ from itertools import chain from binascii import hexlify from collections import namedtuple +from typing import List from torba.bcd_data_stream import BCDataStream from torba.util import subclass_tuple @@ -25,17 +26,21 @@ OP_DROP = 0x75 # template matching opcodes (not real opcodes) # base class for PUSH_DATA related opcodes +# pylint: disable=invalid-name PUSH_DATA_OP = namedtuple('PUSH_DATA_OP', 'name') # opcode for variable length strings +# pylint: disable=invalid-name PUSH_SINGLE = subclass_tuple('PUSH_SINGLE', PUSH_DATA_OP) # opcode for variable number of variable length strings +# pylint: disable=invalid-name PUSH_MANY = subclass_tuple('PUSH_MANY', PUSH_DATA_OP) # opcode with embedded subscript parsing +# pylint: disable=invalid-name PUSH_SUBSCRIPT = namedtuple('PUSH_SUBSCRIPT', 'name template') def is_push_data_opcode(opcode): - return isinstance(opcode, PUSH_DATA_OP) or isinstance(opcode, PUSH_SUBSCRIPT) + return isinstance(opcode, (PUSH_DATA_OP, PUSH_SUBSCRIPT)) def is_push_data_token(token): @@ -61,15 +66,15 @@ def push_data(data): def read_data(token, stream): if token < OP_PUSHDATA1: return stream.read(token) - elif token == OP_PUSHDATA1: + if token == OP_PUSHDATA1: return stream.read(stream.read_uint8()) - elif token == OP_PUSHDATA2: + if token == OP_PUSHDATA2: return stream.read(stream.read_uint16()) - else: - return stream.read(stream.read_uint32()) + return stream.read(stream.read_uint32()) # opcode for OP_1 - OP_16 +# pylint: disable=invalid-name SMALL_INTEGER = namedtuple('SMALL_INTEGER', 'name') @@ -233,7 +238,7 @@ class Parser: raise ParseError("Not a push single or subscript: {}".format(opcode)) -class Template(object): +class Template: __slots__ = 'name', 'opcodes' @@ -264,11 +269,11 @@ class Template(object): return source.get_bytes() -class Script(object): +class Script: __slots__ = 'source', 'template', 'values' - templates = [] + templates: List[Template] = [] def __init__(self, source=None, template=None, values=None, template_hint=None): self.source = source diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 75c5cb45c..0f326dfa2 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -1,29 +1,30 @@ -import six import logging -from typing import List, Iterable +import typing +from typing import List, Iterable, Optional from binascii import hexlify from twisted.internet import defer -import torba.baseaccount -import torba.baseledger from torba.basescript import BaseInputScript, BaseOutputScript -from torba.coinselection import CoinSelector +from torba.baseaccount import BaseAccount from torba.constants import COIN, NULL_HASH32 from torba.bcd_data_stream import BCDataStream -from torba.hash import sha256, TXRef, TXRefImmutable, TXORef +from torba.hash import sha256, TXRef, TXRefImmutable from torba.util import ReadOnlyList +if typing.TYPE_CHECKING: + from torba import baseledger + log = logging.getLogger() class TXRefMutable(TXRef): - __slots__ = 'tx', + __slots__ = ('tx',) - def __init__(self, tx): - super(TXRefMutable, self).__init__() + def __init__(self, tx: 'BaseTransaction') -> None: + super().__init__() self.tx = tx @property @@ -43,12 +44,35 @@ class TXRefMutable(TXRef): self._hash = None +class TXORef: + + __slots__ = 'tx_ref', 'position' + + def __init__(self, tx_ref: TXRef, position: int) -> None: + self.tx_ref = tx_ref + self.position = position + + @property + def id(self): + return '{}:{}'.format(self.tx_ref.id, self.position) + + @property + def is_null(self): + return self.tx_ref.is_null + + @property + def txo(self) -> Optional['BaseOutput']: + return None + + class TXORefResolvable(TXORef): - __slots__ = '_txo', + __slots__ = ('_txo',) - def __init__(self, txo): - super(TXORefResolvable, self).__init__(txo.tx_ref, txo.position) + def __init__(self, txo: 'BaseOutput') -> None: + assert txo.tx_ref is not None + assert txo.position is not None + super().__init__(txo.tx_ref, txo.position) self._txo = txo @property @@ -56,23 +80,23 @@ class TXORefResolvable(TXORef): return self._txo -class InputOutput(object): +class InputOutput: __slots__ = 'tx_ref', 'position' - def __init__(self, tx_ref=None, position=None): - self.tx_ref = tx_ref # type: TXRef - self.position = position # type: int + def __init__(self, tx_ref: TXRef = None, position: int = None) -> None: + self.tx_ref = tx_ref + self.position = position @property - def size(self): + def size(self) -> int: """ Size of this input / output in bytes. """ stream = BCDataStream() self.serialize_to(stream) return len(stream.get_bytes()) - def serialize_to(self, stream): - raise NotImplemented + def serialize_to(self, stream, alternate_script=None): + raise NotImplementedError class BaseInput(InputOutput): @@ -84,27 +108,27 @@ class BaseInput(InputOutput): __slots__ = 'txo_ref', 'sequence', 'coinbase', 'script' - def __init__(self, txo_ref, script, sequence=0xFFFFFFFF, tx_ref=None, position=None): - # type: (TXORef, BaseInputScript, int, TXRef, int) -> None - super(BaseInput, self).__init__(tx_ref, position) + def __init__(self, txo_ref: TXORef, script: BaseInputScript, sequence: int = 0xFFFFFFFF, + tx_ref: TXRef = None, position: int = None) -> None: + super().__init__(tx_ref, position) self.txo_ref = txo_ref self.sequence = sequence self.coinbase = script if txo_ref.is_null else None - self.script = script if not txo_ref.is_null else None # type: BaseInputScript + self.script = script if not txo_ref.is_null else None @property def is_coinbase(self): return self.coinbase is not None @classmethod - def spend(cls, txo): # type: (BaseOutput) -> BaseInput + def spend(cls, txo: 'BaseOutput') -> 'BaseInput': """ Create an input to spend the output.""" assert txo.script.is_pay_pubkey_hash, 'Attempting to spend unsupported output.' script = cls.script_class.redeem_pubkey_hash(cls.NULL_SIGNATURE, cls.NULL_PUBLIC_KEY) return cls(txo.ref, script) @property - def amount(self): + def amount(self) -> int: """ Amount this input adds to the transaction. """ if self.txo_ref.txo is None: raise ValueError('Cannot resolve output to get amount.') @@ -135,15 +159,15 @@ class BaseInput(InputOutput): stream.write_uint32(self.sequence) -class BaseOutputEffectiveAmountEstimator(object): +class BaseOutputEffectiveAmountEstimator: __slots__ = 'txo', 'txi', 'fee', 'effective_amount' - def __init__(self, ledger, txo): # type: (torba.baseledger.BaseLedger, BaseOutput) -> None + def __init__(self, ledger: 'baseledger.BaseLedger', txo: 'BaseOutput') -> None: self.txo = txo self.txi = ledger.transaction_class.input_class.spend(txo) - self.fee = ledger.get_input_output_fee(self.txi) - self.effective_amount = txo.amount - self.fee + self.fee: int = ledger.get_input_output_fee(self.txi) + self.effective_amount: int = txo.amount - self.fee def __lt__(self, other): return self.effective_amount < other.effective_amount @@ -156,9 +180,9 @@ class BaseOutput(InputOutput): __slots__ = 'amount', 'script' - def __init__(self, amount, script, tx_ref=None, position=None): - # type: (int, BaseOutputScript, TXRef, int) -> None - super(BaseOutput, self).__init__(tx_ref, position) + def __init__(self, amount: int, script: BaseOutputScript, + tx_ref: TXRef = None, position: int = None) -> None: + super().__init__(tx_ref, position) self.amount = amount self.script = script @@ -184,7 +208,7 @@ class BaseOutput(InputOutput): script=cls.script_class(stream.read_string()) ) - def serialize_to(self, stream): + def serialize_to(self, stream, alternate_script=None): stream.write_uint64(self.amount) stream.write_string(self.script.source) @@ -194,7 +218,7 @@ class BaseTransaction: input_class = BaseInput output_class = BaseOutput - def __init__(self, raw=None, version=1, locktime=0): + def __init__(self, raw=None, version=1, locktime=0) -> None: self._raw = raw self.ref = TXRefMutable(self) self.version = version # type: int @@ -230,8 +254,7 @@ class BaseTransaction: def outputs(self): # type: () -> ReadOnlyList[BaseOutput] return ReadOnlyList(self._outputs) - def _add(self, new_ios, existing_ios): - # type: (List[InputOutput], List[InputOutput]) -> BaseTransaction + def _add(self, new_ios: Iterable[InputOutput], existing_ios: List) -> 'BaseTransaction': for txio in new_ios: txio.tx_ref = self.ref txio.position = len(existing_ios) @@ -239,28 +262,28 @@ class BaseTransaction: self._reset() return self - def add_inputs(self, inputs): # type: (List[BaseInput]) -> BaseTransaction + def add_inputs(self, inputs: Iterable[BaseInput]) -> 'BaseTransaction': return self._add(inputs, self._inputs) - def add_outputs(self, outputs): # type: (List[BaseOutput]) -> BaseTransaction + def add_outputs(self, outputs: Iterable[BaseOutput]) -> 'BaseTransaction': return self._add(outputs, self._outputs) @property - def fee(self): # type: () -> int + def fee(self) -> int: """ Fee that will actually be paid.""" return self.input_sum - self.output_sum @property - def size(self): # type: () -> int + def size(self) -> int: """ Size in bytes of the entire transaction. """ return len(self.raw) @property - def base_size(self): # type: () -> int + def base_size(self) -> int: """ Size in bytes of transaction meta data and all outputs; without inputs. """ return len(self._serialize(with_inputs=False)) - def _serialize(self, with_inputs=True): # type: (bool) -> bytes + def _serialize(self, with_inputs: bool = True) -> bytes: stream = BCDataStream() stream.write_uint32(self.version) if with_inputs: @@ -273,12 +296,13 @@ class BaseTransaction: stream.write_uint32(self.locktime) return stream.get_bytes() - def _serialize_for_signature(self, signing_input): # type: (int) -> bytes + def _serialize_for_signature(self, signing_input: int) -> bytes: stream = BCDataStream() stream.write_uint32(self.version) stream.write_compact_size(len(self._inputs)) for i, txin in enumerate(self._inputs): if signing_input == i: + assert txin.txo_ref.txo is not None txin.serialize_to(stream, txin.txo_ref.txo.script.source) else: txin.serialize_to(stream, b'') @@ -304,8 +328,9 @@ class BaseTransaction: self.locktime = stream.read_uint32() @classmethod - def ensure_all_have_same_ledger(cls, funding_accounts, change_account=None): - # type: (Iterable[torba.baseaccount.BaseAccount], torba.baseaccount.BaseAccount) -> torba.baseledger.BaseLedger + def ensure_all_have_same_ledger( + cls, funding_accounts: Iterable[BaseAccount], change_account: BaseAccount = None)\ + -> 'baseledger.BaseLedger': ledger = None for account in funding_accounts: if ledger is None: @@ -316,33 +341,24 @@ class BaseTransaction: ) if change_account is not None and change_account.ledger != ledger: raise ValueError('Change account must use same ledger as funding accounts.') + if ledger is None: + raise ValueError('No ledger found.') return ledger @classmethod @defer.inlineCallbacks - def pay(cls, outputs, funding_accounts, change_account, reserve_outputs=True): - # type: (List[BaseOutput], List[torba.baseaccount.BaseAccount], torba.baseaccount.BaseAccount) -> defer.Deferred + def pay(cls, outputs: Iterable[BaseOutput], funding_accounts: Iterable[BaseAccount], + change_account: BaseAccount): """ Efficiently spend utxos from funding_accounts to cover the new outputs. """ tx = cls().add_outputs(outputs) ledger = cls.ensure_all_have_same_ledger(funding_accounts, change_account) amount = tx.output_sum + ledger.get_transaction_base_fee(tx) - txos = yield ledger.get_effective_amount_estimators(funding_accounts) - selector = CoinSelector( - txos, amount, - ledger.get_input_output_fee( - cls.output_class.pay_pubkey_hash(COIN, NULL_HASH32) - ) - ) + spendables = yield ledger.get_spendable_utxos(amount, funding_accounts) - spendables = selector.select() if not spendables: raise ValueError('Not enough funds to cover this transaction.') - reserved_outputs = [s.txo.id for s in spendables] - if reserve_outputs: - yield ledger.db.reserve_spent_outputs(reserved_outputs) - try: spent_sum = sum(s.effective_amount for s in spendables) if spent_sum > amount: @@ -351,30 +367,25 @@ class BaseTransaction: change_amount = spent_sum - amount tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) - tx.add_inputs([s.txi for s in spendables]) + tx.add_inputs(s.txi for s in spendables) yield tx.sign(funding_accounts) - except Exception: - if reserve_outputs: - yield ledger.db.release_reserved_outputs(reserved_outputs) - raise + except Exception as e: + log.exception('Failed to synchronize transaction:') + yield ledger.release_outputs(s.txo for s in spendables) + raise e defer.returnValue(tx) @classmethod @defer.inlineCallbacks - def liquidate(cls, assets, funding_accounts, change_account, reserve_outputs=True): + def liquidate(cls, assets, funding_accounts, change_account): """ Spend assets (utxos) supplementing with funding_accounts if fee is higher than asset value. """ - tx = cls().add_inputs([ cls.input_class.spend(utxo) for utxo in assets ]) ledger = cls.ensure_all_have_same_ledger(funding_accounts, change_account) - - reserved_outputs = [utxo.id for utxo in assets] - if reserve_outputs: - yield ledger.db.reserve_spent_outputs(reserved_outputs) - + yield ledger.reserve_outputs(assets) try: cost_of_change = ( ledger.get_transaction_base_fee(tx) + @@ -386,41 +397,35 @@ class BaseTransaction: change_hash160 = change_account.ledger.address_to_hash160(change_address) change_amount = liquidated_total - cost_of_change tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) - yield tx.sign(funding_accounts) - except Exception: - if reserve_outputs: - yield ledger.db.release_reserved_outputs(reserved_outputs) + yield ledger.release_outputs(assets) raise - defer.returnValue(tx) - def signature_hash_type(self, hash_type): + @staticmethod + def signature_hash_type(hash_type): return hash_type @defer.inlineCallbacks - def sign(self, funding_accounts): # type: (Iterable[torba.baseaccount.BaseAccount]) -> BaseTransaction + def sign(self, funding_accounts: Iterable[BaseAccount]) -> defer.Deferred: ledger = self.ensure_all_have_same_ledger(funding_accounts) for i, txi in enumerate(self._inputs): + assert txi.script is not None + assert txi.txo_ref.txo is not None txo_script = txi.txo_ref.txo.script if txo_script.is_pay_pubkey_hash: address = ledger.hash160_to_address(txo_script.values['pubkey_hash']) private_key = yield ledger.get_private_key_for_address(address) tx = self._serialize_for_signature(i) txi.script.values['signature'] = \ - private_key.sign(tx) + six.int2byte(self.signature_hash_type(1)) + private_key.sign(tx) + bytes((self.signature_hash_type(1),)) txi.script.values['pubkey'] = private_key.public_key.pubkey_bytes txi.script.generate() else: raise NotImplementedError("Don't know how to spend this output.") self._reset() - def sort(self): - # See https://github.com/kristovatlas/rfc/blob/master/bips/bip-li01.mediawiki - self._inputs.sort(key=lambda i: (i['prevout_hash'], i['prevout_n'])) - self._outputs.sort(key=lambda o: (o[2], pay_script(o[0], o[1]))) - @property def input_sum(self): return sum(i.amount for i in self.inputs) diff --git a/torba/bcd_data_stream.py b/torba/bcd_data_stream.py index ab06cdecc..1c04be005 100644 --- a/torba/bcd_data_stream.py +++ b/torba/bcd_data_stream.py @@ -35,9 +35,9 @@ class BCDataStream: return size if size == 253: return self.read_uint16() - elif size == 254: + if size == 254: return self.read_uint32() - elif size == 255: + if size == 255: return self.read_uint64() def write_compact_size(self, size): @@ -70,7 +70,7 @@ class BCDataStream: def _read_struct(self, fmt): value = self.read(fmt.size) - if len(value) > 0: + if value: return fmt.unpack(value)[0] def read_int8(self): diff --git a/torba/bip32.py b/torba/bip32.py index 5bb06cd1e..7ef76aea6 100644 --- a/torba/bip32.py +++ b/torba/bip32.py @@ -10,7 +10,6 @@ import struct import hashlib -from six import int2byte, byte2int, indexbytes import ecdsa import ecdsa.ellipticcurve as EC @@ -24,7 +23,7 @@ class DerivationError(Exception): """ Raised when an invalid derivation occurs. """ -class _KeyBase(object): +class _KeyBase: """ A BIP32 Key, public or private. """ CURVE = ecdsa.SECP256k1 @@ -63,17 +62,23 @@ class _KeyBase(object): if len(raw_serkey) != 33: raise ValueError('raw_serkey must have length 33') - return (ver_bytes + int2byte(self.depth) + return (ver_bytes + bytes((self.depth,)) + self.parent_fingerprint() + struct.pack('>I', self.n) + self.chain_code + raw_serkey) + def identifier(self): + raise NotImplementedError + + def extended_key(self): + raise NotImplementedError + def fingerprint(self): """ Return the key's fingerprint as 4 bytes. """ return self.identifier()[:4] def parent_fingerprint(self): """ Return the parent key's fingerprint as 4 bytes. """ - return self.parent.fingerprint() if self.parent else int2byte(0)*4 + return self.parent.fingerprint() if self.parent else bytes((0,)*4) def extended_key_string(self): """ Return an extended key as a base58 string. """ @@ -84,7 +89,7 @@ class PubKey(_KeyBase): """ A BIP32 public key. """ def __init__(self, ledger, pubkey, chain_code, n, depth, parent=None): - super(PubKey, self).__init__(ledger, chain_code, n, depth, parent) + super().__init__(ledger, chain_code, n, depth, parent) if isinstance(pubkey, ecdsa.VerifyingKey): self.verifying_key = pubkey else: @@ -97,16 +102,16 @@ class PubKey(_KeyBase): raise TypeError('pubkey must be raw bytes') if len(pubkey) != 33: raise ValueError('pubkey must be 33 bytes') - if indexbytes(pubkey, 0) not in (2, 3): + if pubkey[0] not in (2, 3): raise ValueError('invalid pubkey prefix byte') curve = cls.CURVE.curve - is_odd = indexbytes(pubkey, 0) == 3 + is_odd = pubkey[0] == 3 x = bytes_to_int(pubkey[1:]) # p is the finite field order - a, b, p = curve.a(), curve.b(), curve.p() - y2 = pow(x, 3, p) + b + a, b, p = curve.a(), curve.b(), curve.p() # pylint: disable=invalid-name + y2 = pow(x, 3, p) + b # pylint: disable=invalid-name assert a == 0 # Otherwise y2 += a * pow(x, 2, p) y = NT.square_root_mod_prime(y2 % p, p) if bool(y & 1) != is_odd: @@ -119,7 +124,7 @@ class PubKey(_KeyBase): def pubkey_bytes(self): """ Return the compressed public key as 33 bytes. """ point = self.verifying_key.pubkey.point - prefix = int2byte(2 + (point.y() & 1)) + prefix = bytes((2 + (point.y() & 1),)) padded_bytes = _exponent_to_bytes(point.x()) return prefix + padded_bytes @@ -137,10 +142,10 @@ class PubKey(_KeyBase): raise ValueError('invalid BIP32 public key child number') msg = self.pubkey_bytes + struct.pack('>I', n) - L, R = self._hmac_sha512(msg) + L, R = self._hmac_sha512(msg) # pylint: disable=invalid-name curve = self.CURVE - L = bytes_to_int(L) + L = bytes_to_int(L) # pylint: disable=invalid-name if L >= curve.order: raise DerivationError @@ -172,7 +177,7 @@ class LowSValueSigningKey(ecdsa.SigningKey): def sign_number(self, number, entropy=None, k=None): order = self.privkey.order - r, s = ecdsa.SigningKey.sign_number(self, number, entropy, k) + r, s = ecdsa.SigningKey.sign_number(self, number, entropy, k) # pylint: disable=invalid-name if s > order / 2: s = order - s return r, s @@ -184,7 +189,7 @@ class PrivateKey(_KeyBase): HARDENED = 1 << 31 def __init__(self, ledger, privkey, chain_code, n, depth, parent=None): - super(PrivateKey, self).__init__(ledger, chain_code, n, depth, parent) + super().__init__(ledger, chain_code, n, depth, parent) if isinstance(privkey, ecdsa.SigningKey): self.signing_key = privkey else: @@ -254,10 +259,10 @@ class PrivateKey(_KeyBase): serkey = self.public_key.pubkey_bytes msg = serkey + struct.pack('>I', n) - L, R = self._hmac_sha512(msg) + L, R = self._hmac_sha512(msg) # pylint: disable=invalid-name curve = self.CURVE - L = bytes_to_int(L) + L = bytes_to_int(L) # pylint: disable=invalid-name exponent = (L + bytes_to_int(self.private_key_bytes)) % curve.order if exponent == 0 or L >= curve.order: raise DerivationError @@ -286,7 +291,7 @@ class PrivateKey(_KeyBase): def _exponent_to_bytes(exponent): """Convert an exponent to 32 big-endian bytes""" - return (int2byte(0)*32 + int_to_bytes(exponent))[-32:] + return (bytes((0,)*32) + int_to_bytes(exponent))[-32:] def _from_extended_key(ledger, ekey): @@ -296,8 +301,8 @@ def _from_extended_key(ledger, ekey): if len(ekey) != 78: raise ValueError('extended key must have length 78') - depth = indexbytes(ekey, 4) - fingerprint = ekey[5:9] # Not used + depth = ekey[4] + # fingerprint = ekey[5:9] n, = struct.unpack('>I', ekey[9:13]) chain_code = ekey[13:45] @@ -305,7 +310,7 @@ def _from_extended_key(ledger, ekey): pubkey = ekey[45:] key = PubKey(ledger, pubkey, chain_code, n, depth) elif ekey[:4] == ledger.extended_private_key_prefix: - if indexbytes(ekey, 45) != 0: + if ekey[45] != 0: raise ValueError('invalid extended private key prefix byte') privkey = ekey[46:] key = PrivateKey(ledger, privkey, chain_code, n, depth) diff --git a/torba/coin/__init__.py b/torba/coin/__init__.py index 69e3be50d..97b69ed6e 100644 --- a/torba/coin/__init__.py +++ b/torba/coin/__init__.py @@ -1 +1 @@ -__path__ = __import__('pkgutil').extend_path(__path__, __name__) +__path__: str = __import__('pkgutil').extend_path(__path__, __name__) diff --git a/torba/coin/bitcoincash.py b/torba/coin/bitcoincash.py index ca9a76a41..6678af616 100644 --- a/torba/coin/bitcoincash.py +++ b/torba/coin/bitcoincash.py @@ -6,7 +6,6 @@ __node_url__ = ( ) __electrumx__ = 'electrumx.lib.coins.BitcoinCashRegtest' -from six import int2byte from binascii import unhexlify from torba.baseledger import BaseLedger from torba.baseheader import BaseHeaders @@ -26,8 +25,8 @@ class MainNetLedger(BaseLedger): transaction_class = Transaction - pubkey_address_prefix = int2byte(0x00) - script_address_prefix = int2byte(0x05) + pubkey_address_prefix = bytes((0,)) + script_address_prefix = bytes((5,)) extended_public_key_prefix = unhexlify('0488b21e') extended_private_key_prefix = unhexlify('0488ade4') @@ -42,8 +41,8 @@ class RegTestLedger(MainNetLedger): headers_class = UnverifiedHeaders network_name = 'regtest' - pubkey_address_prefix = int2byte(111) - script_address_prefix = int2byte(196) + pubkey_address_prefix = bytes((111,)) + script_address_prefix = bytes((196,)) extended_public_key_prefix = unhexlify('043587cf') extended_private_key_prefix = unhexlify('04358394') diff --git a/torba/coin/bitcoinsegwit.py b/torba/coin/bitcoinsegwit.py index 68301a57a..fa293e072 100644 --- a/torba/coin/bitcoinsegwit.py +++ b/torba/coin/bitcoinsegwit.py @@ -6,7 +6,6 @@ __node_url__ = ( ) __electrumx__ = 'electrumx.lib.coins.BitcoinSegwitRegtest' -from six import int2byte from binascii import unhexlify from torba.baseledger import BaseLedger from torba.baseheader import BaseHeaders @@ -17,8 +16,8 @@ class MainNetLedger(BaseLedger): symbol = 'BTC' network_name = 'mainnet' - pubkey_address_prefix = int2byte(0x00) - script_address_prefix = int2byte(0x05) + pubkey_address_prefix = bytes((0,)) + script_address_prefix = bytes((5,)) extended_public_key_prefix = unhexlify('0488b21e') extended_private_key_prefix = unhexlify('0488ade4') @@ -33,8 +32,8 @@ class RegTestLedger(MainNetLedger): headers_class = UnverifiedHeaders network_name = 'regtest' - pubkey_address_prefix = int2byte(111) - script_address_prefix = int2byte(196) + pubkey_address_prefix = bytes((111,)) + script_address_prefix = bytes((196,)) extended_public_key_prefix = unhexlify('043587cf') extended_private_key_prefix = unhexlify('04358394') diff --git a/torba/coinselection.py b/torba/coinselection.py index 0c1adede0..bf3709636 100644 --- a/torba/coinselection.py +++ b/torba/coinselection.py @@ -1,16 +1,15 @@ -import six from random import Random from typing import List -import torba +from torba import basetransaction MAXIMUM_TRIES = 100000 class CoinSelector: - def __init__(self, txos, target, cost_of_change, seed=None): - # type: (List[torba.basetransaction.BaseOutputAmountEstimator], int, int, str) -> None + def __init__(self, txos: List[basetransaction.BaseOutputEffectiveAmountEstimator], + target: int, cost_of_change: int, seed: str = None) -> None: self.txos = txos self.target = target self.cost_of_change = cost_of_change @@ -18,17 +17,17 @@ class CoinSelector: self.tries = 0 self.available = sum(c.effective_amount for c in self.txos) self.random = Random(seed) - if six.PY3 and seed is not None: + if seed is not None: self.random.seed(seed, version=1) - def select(self): # type: () -> List[torba.basetransaction.BaseOutputAmountEstimator] + def select(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: if not self.txos: - return + return [] if self.target > self.available: - return + return [] return self.branch_and_bound() or self.single_random_draw() - def branch_and_bound(self): # type: () -> List[torba.basetransaction.BaseOutputAmountEstimator] + def branch_and_bound(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: # see bitcoin implementation for more info: # https://github.com/bitcoin/bitcoin/blob/master/src/wallet/coinselection.cpp @@ -36,9 +35,9 @@ class CoinSelector: current_value = 0 current_available_value = self.available - current_selection = [] + current_selection: List[bool] = [] best_waste = self.cost_of_change - best_selection = [] + best_selection: List[bool] = [] while self.tries < MAXIMUM_TRIES: self.tries += 1 @@ -70,7 +69,7 @@ class CoinSelector: utxo = self.txos[len(current_selection)] current_available_value -= utxo.effective_amount previous_utxo = self.txos[len(current_selection) - 1] if current_selection else None - if current_selection and not current_selection[-1] and \ + if current_selection and not current_selection[-1] and previous_utxo and \ utxo.effective_amount == previous_utxo.effective_amount and \ utxo.fee == previous_utxo.fee: current_selection.append(False) @@ -84,7 +83,9 @@ class CoinSelector: self.txos[i] for i, include in enumerate(best_selection) if include ] - def single_random_draw(self): # type: () -> List[torba.basetransaction.BaseOutputAmountEstimator] + return [] + + def single_random_draw(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: self.random.shuffle(self.txos, self.random.random) selection = [] amount = 0 @@ -93,3 +94,4 @@ class CoinSelector: amount += coin.effective_amount if amount >= self.target+self.cost_of_change: return selection + return [] diff --git a/torba/hash.py b/torba/hash.py index af1f74897..cf8f2f047 100644 --- a/torba/hash.py +++ b/torba/hash.py @@ -9,7 +9,6 @@ """ Cryptography hash functions and related classes. """ import os -import six import base64 import hashlib import hmac @@ -22,13 +21,8 @@ from cryptography.hazmat.backends import default_backend from torba.util import bytes_to_int, int_to_bytes from torba.constants import NULL_HASH32 -_sha256 = hashlib.sha256 -_sha512 = hashlib.sha512 -_new_hash = hashlib.new -_new_hmac = hmac.new - -class TXRef(object): +class TXRef: __slots__ = '_id', '_hash' @@ -68,50 +62,29 @@ class TXRefImmutable(TXRef): return ref -class TXORef(object): - - __slots__ = 'tx_ref', 'position' - - def __init__(self, tx_ref, position): # type: (TXRef, int) -> None - self.tx_ref = tx_ref - self.position = position - - @property - def id(self): - return '{}:{}'.format(self.tx_ref.id, self.position) - - @property - def is_null(self): - return self.tx_ref.is_null - - @property - def txo(self): - return None - - def sha256(x): """ Simple wrapper of hashlib sha256. """ - return _sha256(x).digest() + return hashlib.sha256(x).digest() def sha512(x): """ Simple wrapper of hashlib sha512. """ - return _sha512(x).digest() + return hashlib.sha512(x).digest() def ripemd160(x): """ Simple wrapper of hashlib ripemd160. """ - h = _new_hash('ripemd160') + h = hashlib.new('ripemd160') h.update(x) return h.digest() def pow_hash(x): - r = sha512(double_sha256(x)) - r1 = ripemd160(r[:len(r) // 2]) - r2 = ripemd160(r[len(r) // 2:]) - r3 = double_sha256(r1 + r2) - return r3 + h = sha512(double_sha256(x)) + return double_sha256( + ripemd160(h[:len(h) // 2]) + + ripemd160(h[len(h) // 2:]) + ) def double_sha256(x): @@ -121,7 +94,7 @@ def double_sha256(x): def hmac_sha512(key, msg): """ Use SHA-512 to provide an HMAC. """ - return _new_hmac(key, msg, _sha512).digest() + return hmac.new(key, msg, hashlib.sha512).digest() def hash160(x): @@ -165,7 +138,7 @@ class Base58Error(Exception): """ Exception used for Base58 errors. """ -class Base58(object): +class Base58: """ Class providing base 58 functionality. """ chars = u'123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' @@ -207,7 +180,7 @@ class Base58(object): break count += 1 if count: - result = six.int2byte(0) * count + result + result = bytes((0,)) * count + result return result diff --git a/torba/mnemonic.py b/torba/mnemonic.py index df1f5a238..3cabcf6cb 100644 --- a/torba/mnemonic.py +++ b/torba/mnemonic.py @@ -56,7 +56,7 @@ CJK_INTERVALS = [ def is_cjk(c): n = ord(c) - for start, end, name in CJK_INTERVALS: + for start, end, _ in CJK_INTERVALS: if start <= n <= end: return True return False @@ -93,7 +93,7 @@ def load_words(filename): return words -file_names = { +FILE_NAMES = { 'en': 'english.txt', 'es': 'spanish.txt', 'ja': 'japanese.txt', @@ -102,20 +102,22 @@ file_names = { } -class Mnemonic(object): +class Mnemonic: # Seed derivation no longer follows BIP39 # Mnemonic phrase uses a hash based checksum, instead of a words-dependent checksum def __init__(self, lang='en'): - filename = file_names.get(lang, 'english.txt') + filename = FILE_NAMES.get(lang, 'english.txt') self.words = load_words(filename) - @classmethod - def mnemonic_to_seed(self, mnemonic, passphrase=u''): - PBKDF2_ROUNDS = 2048 + @staticmethod + def mnemonic_to_seed(mnemonic, passphrase=u''): + pbkdf2_rounds = 2048 mnemonic = normalize_text(mnemonic) passphrase = normalize_text(passphrase) - return pbkdf2.PBKDF2(mnemonic, passphrase, iterations=PBKDF2_ROUNDS, macmodule=hmac, digestmodule=hashlib.sha512).read(64) + return pbkdf2.PBKDF2( + mnemonic, passphrase, iterations=pbkdf2_rounds, macmodule=hmac, digestmodule=hashlib.sha512 + ).read(64) def mnemonic_encode(self, i): n = len(self.words) @@ -131,8 +133,8 @@ class Mnemonic(object): words = seed.split() i = 0 while words: - w = words.pop() - k = self.words.index(w) + word = words.pop() + k = self.words.index(word) i = i*n + k return i diff --git a/torba/stream.py b/torba/stream.py index 6438b7184..79fbba796 100644 --- a/torba/stream.py +++ b/torba/stream.py @@ -1,27 +1,7 @@ -import six -from twisted.internet.defer import Deferred, DeferredLock, maybeDeferred, inlineCallbacks +import asyncio +from twisted.internet.defer import Deferred from twisted.python.failure import Failure -if six.PY3: - import asyncio - - -def execute_serially(f): - _lock = DeferredLock() - - @inlineCallbacks - def allow_only_one_at_a_time(*args, **kwargs): - yield _lock.acquire() - allow_only_one_at_a_time.is_running = True - try: - yield maybeDeferred(f, *args, **kwargs) - finally: - allow_only_one_at_a_time.is_running = False - _lock.release() - - allow_only_one_at_a_time.is_running = False - return allow_only_one_at_a_time - class BroadcastSubscription: @@ -76,10 +56,10 @@ class StreamController: @property def _iterate_subscriptions(self): - next = self._first_subscription - while next is not None: - subscription = next - next = next._next + next_sub = self._first_subscription + while next_sub is not None: + subscription = next_sub + next_sub = next_sub._next yield subscription def add(self, event): @@ -96,15 +76,15 @@ class StreamController: def _cancel(self, subscription): previous = subscription._previous - next = subscription._next + next_sub = subscription._next if previous is None: - self._first_subscription = next + self._first_subscription = next_sub else: - previous._next = next - if next is None: + previous._next = next_sub + if next_sub is None: self._last_subscription = previous else: - next._previous = previous + next_sub._previous = previous subscription._next = subscription._previous = subscription def _listen(self, on_data, on_error, on_done): diff --git a/torba/util.py b/torba/util.py index 9683a8dfe..00ee6ba4d 100644 --- a/torba/util.py +++ b/torba/util.py @@ -1,20 +1,19 @@ from binascii import unhexlify, hexlify -from collections import Sequence -from typing import TypeVar, Generic +from typing import TypeVar, Sequence T = TypeVar('T') -class ReadOnlyList(Sequence, Generic[T]): +class ReadOnlyList(Sequence[T]): def __init__(self, lst): self.lst = lst - def __getitem__(self, key): # type: (int) -> T + def __getitem__(self, key): return self.lst[key] - def __len__(self): + def __len__(self) -> int: return len(self.lst) @@ -22,13 +21,13 @@ def subclass_tuple(name, base): return type(name, (base,), {'__slots__': ()}) -class cachedproperty(object): +class cachedproperty: def __init__(self, f): self.f = f - def __get__(self, obj, type): - obj = obj or type + def __get__(self, obj, objtype): + obj = obj or objtype value = self.f(obj) setattr(obj, self.f.__name__, value) return value @@ -42,8 +41,8 @@ def bytes_to_int(be_bytes): def int_to_bytes(value): """ Converts an integer to a big-endian sequence of bytes. """ length = (value.bit_length() + 7) // 8 - h = '%x' % value - return unhexlify(('0' * (len(h) % 2) + h).zfill(length * 2)) + s = '%x' % value + return unhexlify(('0' * (len(s) % 2) + s).zfill(length * 2)) def rev_hex(s): @@ -56,8 +55,8 @@ def int_to_hex(i, length=1): return rev_hex(s) -def hex_to_int(s): - return int(b'0x' + hexlify(s[::-1]), 16) +def hex_to_int(x): + return int(b'0x' + hexlify(x[::-1]), 16) def hash_encode(x): diff --git a/torba/wallet.py b/torba/wallet.py index 1fe486396..ca6d48fab 100644 --- a/torba/wallet.py +++ b/torba/wallet.py @@ -1,10 +1,13 @@ import stat import json import os -from typing import List +import typing +from typing import Sequence, MutableSequence -import torba.baseaccount -import torba.baseledger +if typing.TYPE_CHECKING: + from torba import baseaccount + from torba import baseledger + from torba import basemanager class Wallet: @@ -14,24 +17,24 @@ class Wallet: by physical files on the filesystem. """ - def __init__(self, name='Wallet', accounts=None, storage=None): - # type: (str, List[torba.baseaccount.BaseAccount], WalletStorage) -> None + def __init__(self, name: str = 'Wallet', accounts: MutableSequence['baseaccount.BaseAccount'] = None, + storage: 'WalletStorage' = None) -> None: self.name = name - self.accounts = accounts or [] # type: List[torba.baseaccount.BaseAccount] + self.accounts = accounts or [] self.storage = storage or WalletStorage() - def generate_account(self, ledger): - # type: (torba.baseledger.BaseLedger) -> torba.baseaccount.BaseAccount + def generate_account(self, ledger: 'baseledger.BaseLedger') -> 'baseaccount.BaseAccount': account = ledger.account_class.generate(ledger, u'torba') self.accounts.append(account) return account @classmethod - def from_storage(cls, storage, manager): # type: (WalletStorage, 'WalletManager') -> Wallet + def from_storage(cls, storage: 'WalletStorage', manager: 'basemanager.BaseWalletManager') -> 'Wallet': json_dict = storage.read() accounts = [] - for account_dict in json_dict.get('accounts', []): + account_dicts: Sequence[dict] = json_dict.get('accounts', []) + for account_dict in account_dicts: ledger = manager.get_or_create_ledger(account_dict['ledger']) account = ledger.account_class.from_dict(ledger, account_dict) accounts.append(account) @@ -110,7 +113,7 @@ class WalletStorage: mode = stat.S_IREAD | stat.S_IWRITE try: os.rename(temp_path, self.path) - except: + except Exception: # pylint: disable=broad-except os.remove(self.path) os.rename(temp_path, self.path) os.chmod(self.path, mode) From a20c0609317ecce9fe579bbdd4bd0b2cbe05fe9c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 28 Jul 2018 20:57:50 -0400 Subject: [PATCH 073/383] install pylint from git --- .travis.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 5b4e00b5a..5cbdcb9ea 100644 --- a/.travis.yml +++ b/.travis.yml @@ -11,7 +11,8 @@ jobs: - stage: code quality name: "pylint & mypy" install: - - pip install pylint mypy + - pip install git+https://github.com/PyCQA/pylint.git + - pip install mypy - pip install -e . script: - pylint --rcfile=setup.cfg torba From 6be95dceabcf7be81131ca350d61c8f4f0acdec5 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 28 Jul 2018 21:08:04 -0400 Subject: [PATCH 074/383] split unit tests and integration tests --- .travis.yml | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 5cbdcb9ea..e1a76615c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -2,8 +2,7 @@ dist: xenial sudo: true language: python -python: - - "3.7" +python: "3.7" jobs: include: @@ -19,12 +18,23 @@ jobs: - mypy torba - stage: test + python: + - "3.6" + - "3.7" name: "Unit Tests" + install: + - pip install tox-travis coverage + script: tox -e unit + after_success: + - coverage combine tests/ + - bash <(curl -s https://codecov.io/bash) + + - name: "Integration Tests" install: - pip install tox-travis coverage - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch lbryumx && popd - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd - script: tox + script: tox -e integration after_success: - coverage combine tests/ - bash <(curl -s https://codecov.io/bash) From 2a42bda0a00e507ebeca258f3b660c5bcfea77a5 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 28 Jul 2018 22:49:16 -0400 Subject: [PATCH 075/383] .travis.yml --- .travis.yml | 33 ++++++++++++++++----------------- tox.ini | 8 +++++++- 2 files changed, 23 insertions(+), 18 deletions(-) diff --git a/.travis.yml b/.travis.yml index e1a76615c..e44da68f5 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,7 +1,6 @@ dist: xenial sudo: true language: python - python: "3.7" jobs: @@ -16,25 +15,25 @@ jobs: script: - pylint --rcfile=setup.cfg torba - mypy torba + after_success: skip - - stage: test - python: - - "3.6" - - "3.7" - name: "Unit Tests" + - &unit-tests + stage: unit tests install: - - pip install tox-travis coverage - script: tox -e unit - after_success: - - coverage combine tests/ - - bash <(curl -s https://codecov.io/bash) + - pip install tox-travis + script: TESTTYPE=unit tox + - <<: *unit-tests + python: "3.6" - - name: "Integration Tests" + - &integration-tests + stage: integration tests install: - - pip install tox-travis coverage + - pip install tox-travis - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch lbryumx && popd - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd - script: tox -e integration - after_success: - - coverage combine tests/ - - bash <(curl -s https://codecov.io/bash) + script: TESTTYPE=integration tox + +after_success: + - pip install coverage + - coverage combine tests/ + - bash <(curl -s https://codecov.io/bash) diff --git a/tox.ini b/tox.ini index feaffd283..7037984db 100644 --- a/tox.ini +++ b/tox.ini @@ -2,6 +2,11 @@ #envlist = unit,integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} envlist = py37-unit,py37-integration-torba.coin.bitcoinsegwit +[travis:env] +TESTTYPE = + unit: unit + integration: integration + [testenv] deps = coverage @@ -9,7 +14,8 @@ deps = integration: ../electrumx extras = test changedir = {toxinidir}/tests -setenv = integration: LEDGER={envname} +setenv = + integration: LEDGER={envname} commands = unit: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial unit integration: orchstr8 download From 420ba43d5a46a2f2ba381522322d0e52b3452687 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 28 Jul 2018 23:02:12 -0400 Subject: [PATCH 076/383] travis yaml parse error fix --- .travis.yml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index e44da68f5..20f62692e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -15,7 +15,7 @@ jobs: script: - pylint --rcfile=setup.cfg torba - mypy torba - after_success: skip + after_success: skip - &unit-tests stage: unit tests @@ -25,8 +25,7 @@ jobs: - <<: *unit-tests python: "3.6" - - &integration-tests - stage: integration tests + - stage: integration tests install: - pip install tox-travis - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch lbryumx && popd From 3a35951b464205a356679574a8af70228522ecc2 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 28 Jul 2018 23:43:17 -0400 Subject: [PATCH 077/383] travis yaml w/ anchors --- .travis.yml | 14 +++++++------- tox.ini | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.travis.yml b/.travis.yml index 20f62692e..2bfb24ae4 100644 --- a/.travis.yml +++ b/.travis.yml @@ -17,20 +17,20 @@ jobs: - mypy torba after_success: skip - - &unit-tests - stage: unit tests + - &tests + stage: tests + env: TESTTYPE=unit install: - pip install tox-travis - script: TESTTYPE=unit tox - - <<: *unit-tests + script: tox + - <<: *tests python: "3.6" - - - stage: integration tests + - <<: *tests + env: TESTTYPE=integration install: - pip install tox-travis - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch lbryumx && popd - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd - script: TESTTYPE=integration tox after_success: - pip install coverage diff --git a/tox.ini b/tox.ini index 7037984db..1eb951d74 100644 --- a/tox.ini +++ b/tox.ini @@ -1,6 +1,6 @@ [tox] #envlist = unit,integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} -envlist = py37-unit,py37-integration-torba.coin.bitcoinsegwit +envlist = py{37,36}-unit,py37-integration-torba.coin.bitcoinsegwit [travis:env] TESTTYPE = From cfeb7b249b09db5e63d33006925378afa685f6b1 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 28 Jul 2018 23:49:51 -0400 Subject: [PATCH 078/383] enable caching --- .travis.yml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.travis.yml b/.travis.yml index 2bfb24ae4..7be2faefb 100644 --- a/.travis.yml +++ b/.travis.yml @@ -36,3 +36,8 @@ after_success: - pip install coverage - coverage combine tests/ - bash <(curl -s https://codecov.io/bash) + +cache: + directories: + - $HOME/.cache/pip + - $TRAVIS_BUILD_DIR/.tox From 69ad8e384aed69f4bc86322c61ad43bd47f9afa9 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 29 Jul 2018 13:13:40 -0400 Subject: [PATCH 079/383] customizable address generator support --- tests/unit/test_account.py | 24 +++--- tests/unit/test_transaction.py | 2 +- tests/unit/test_wallet.py | 10 +-- torba/baseaccount.py | 138 ++++++++++++++++++--------------- torba/basetransaction.py | 5 +- torba/wallet.py | 2 +- 6 files changed, 98 insertions(+), 83 deletions(-) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index bc6726449..47266fef6 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -3,10 +3,10 @@ from twisted.trial import unittest from twisted.internet import defer from torba.coin.bitcoinsegwit import MainNetLedger -from torba.baseaccount import KeyChain, SingleKey +from torba.baseaccount import HierarchicalDeterministic, SingleKey -class TestKeyChainAccount(unittest.TestCase): +class TestHierarchicalDeterministicAccount(unittest.TestCase): @defer.inlineCallbacks def setUp(self): @@ -42,7 +42,7 @@ class TestKeyChainAccount(unittest.TestCase): def test_ensure_address_gap(self): account = self.account - self.assertIsInstance(account.receiving, KeyChain) + self.assertIsInstance(account.receiving, HierarchicalDeterministic) yield account.receiving.generate_keys(4, 7) yield account.receiving.generate_keys(0, 3) @@ -95,7 +95,7 @@ class TestKeyChainAccount(unittest.TestCase): account = self.ledger.account_class.from_seed( self.ledger, "carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" - "sent", "torba", receiving_gap=3, change_gap=2 + "sent", "torba", {'name': 'deterministic-chain', 'receiving_gap': 3, 'change_gap': 2} ) self.assertEqual( account.private_key.extended_key_string(), @@ -139,11 +139,11 @@ class TestKeyChainAccount(unittest.TestCase): 'public_key': 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' 'iW44g14WF52fYC5J483wqQ5ZP', - 'is_hd': True, - 'receiving_gap': 5, - 'receiving_maximum_uses_per_address': 2, - 'change_gap': 5, - 'change_maximum_uses_per_address': 2 + 'address_generator': { + 'name': 'deterministic-chain', + 'receiving': {'gap': 5, 'maximum_uses_per_address': 2}, + 'change': {'gap': 5, 'maximum_uses_per_address': 2} + } } account = self.ledger.account_class.from_dict(self.ledger, account_data) @@ -166,7 +166,7 @@ class TestSingleKeyAccount(unittest.TestCase): def setUp(self): self.ledger = MainNetLedger({'db': MainNetLedger.database_class(':memory:')}) yield self.ledger.db.start() - self.account = self.ledger.account_class.generate(self.ledger, u"torba", is_hd=False) + self.account = self.ledger.account_class.generate(self.ledger, u"torba", {'name': 'single-address'}) @defer.inlineCallbacks def test_generate_account(self): @@ -247,7 +247,7 @@ class TestSingleKeyAccount(unittest.TestCase): account = self.ledger.account_class.from_seed( self.ledger, "carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" - "sent", "torba", is_hd=False + "sent", "torba", {'name': 'single-address'} ) self.assertEqual( account.private_key.extended_key_string(), @@ -291,7 +291,7 @@ class TestSingleKeyAccount(unittest.TestCase): 'public_key': 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' 'iW44g14WF52fYC5J483wqQ5ZP', - 'is_hd': False + 'address_generator': {'name': 'single-address'} } account = self.ledger.account_class.from_dict(self.ledger, account_data) diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index 5966cf374..47af97eb7 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -148,7 +148,7 @@ class TestTransactionSigning(unittest.TestCase): account = self.ledger.account_class.from_seed( self.ledger, u"carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" - u"sent", u"torba" + u"sent", u"torba", {} ) yield account.ensure_address_gap() diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index b52ee4ebb..31a9cb8ab 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -44,11 +44,11 @@ class TestWalletCreation(unittest.TestCase): 'public_key': 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' 'iW44g14WF52fYC5J483wqQ5ZP', - 'is_hd': True, - 'receiving_gap': 10, - 'receiving_maximum_uses_per_address': 2, - 'change_gap': 10, - 'change_maximum_uses_per_address': 2, + 'address_generator': { + 'name': 'deterministic-chain', + 'receiving': {'gap': 17, 'maximum_uses_per_address': 3}, + 'change': {'gap': 10, 'maximum_uses_per_address': 3} + } } ] } diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 532b364da..eb2835bbd 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -1,5 +1,5 @@ import typing -from typing import Sequence +from typing import Tuple, Type from twisted.internet import defer from torba.mnemonic import Mnemonic @@ -10,7 +10,9 @@ if typing.TYPE_CHECKING: from torba import baseledger -class KeyManager: +class AddressManager: + + name: str __slots__ = 'account', 'public_key', 'chain_number' @@ -19,6 +21,15 @@ class KeyManager: self.public_key = public_key self.chain_number = chain_number + @classmethod + def from_dict(cls, account: 'BaseAccount', d: dict) \ + -> Tuple['AddressManager', 'AddressManager']: + raise NotImplementedError + + @classmethod + def to_dict(cls, receiving: 'AddressManager', change: 'AddressManager') -> dict: + return {'name': cls.name} + @property def db(self): return self.account.ledger.db @@ -28,6 +39,9 @@ class KeyManager: self.account, self.chain_number, limit, max_used_times, order_by ) + def get_private_key(self, index: int) -> PrivateKey: + raise NotImplementedError + def get_max_gap(self) -> defer.Deferred: raise NotImplementedError @@ -51,17 +65,38 @@ class KeyManager: defer.returnValue(addresses[0]) -class KeyChain(KeyManager): +class HierarchicalDeterministic(AddressManager): """ Implements simple version of Bitcoin Hierarchical Deterministic key management. """ + name = "deterministic-chain" + __slots__ = 'gap', 'maximum_uses_per_address' - def __init__(self, account: 'BaseAccount', root_public_key: PubKey, - chain_number: int, gap: int, maximum_uses_per_address: int) -> None: - super().__init__(account, root_public_key.child(chain_number), chain_number) + def __init__(self, account: 'BaseAccount', chain: int, gap: int, maximum_uses_per_address: int) -> None: + super().__init__(account, account.public_key.child(chain), chain) self.gap = gap self.maximum_uses_per_address = maximum_uses_per_address + @classmethod + def from_dict(cls, account: 'BaseAccount', d: dict) -> Tuple[AddressManager, AddressManager]: + return ( + cls(account, 0, **d.get('receiving', {'gap': 20, 'maximum_uses_per_address': 2})), + cls(account, 1, **d.get('change', {'gap': 6, 'maximum_uses_per_address': 2})) + ) + + @classmethod + def to_dict(cls, receiving: 'HierarchicalDeterministic', change: 'HierarchicalDeterministic') -> dict: + d = super().to_dict(receiving, change) + d['receiving'] = receiving.to_dict_instance() + d['change'] = change.to_dict_instance() + return d + + def to_dict_instance(self): + return {'gap': self.gap, 'maximum_uses_per_address': self.maximum_uses_per_address} + + def get_private_key(self, index: int) -> PrivateKey: + return self.account.private_key.child(self.chain_number).child(index) + @defer.inlineCallbacks def generate_keys(self, start: int, end: int) -> defer.Deferred: new_keys = [] @@ -111,11 +146,22 @@ class KeyChain(KeyManager): ) -class SingleKey(KeyManager): - """ Single Key manager always returns the same address for all operations. """ +class SingleKey(AddressManager): + """ Single Key address manager always returns the same address for all operations. """ + + name = "single-address" __slots__ = () + @classmethod + def from_dict(cls, account: 'BaseAccount', d: dict)\ + -> Tuple[AddressManager, AddressManager]: + same_address_manager = cls(account, account.public_key, 0) + return same_address_manager, same_address_manager + + def get_private_key(self, index: int) -> PrivateKey: + return self.account.private_key + def get_max_gap(self) -> defer.Deferred: return defer.succeed(0) @@ -138,10 +184,13 @@ class BaseAccount: mnemonic_class = Mnemonic private_key_class = PrivateKey public_key_class = PubKey + address_generators = { + SingleKey.name: SingleKey, + HierarchicalDeterministic.name: HierarchicalDeterministic, + } - def __init__(self, ledger: 'baseledger.BaseLedger', name: str, seed: str, encrypted: bool, is_hd: bool, - private_key: PrivateKey, public_key: PubKey, receiving_gap: int = 20, change_gap: int = 6, - receiving_maximum_uses_per_address: int = 2, change_maximum_uses_per_address: int = 2 + def __init__(self, ledger: 'baseledger.BaseLedger', name: str, seed: str, encrypted: bool, + private_key: PrivateKey, public_key: PubKey, address_generator: dict ) -> None: self.ledger = ledger self.name = name @@ -149,34 +198,26 @@ class BaseAccount: self.encrypted = encrypted self.private_key = private_key self.public_key = public_key - if is_hd: - self.receiving: KeyManager = KeyChain( - self, public_key, 0, receiving_gap, receiving_maximum_uses_per_address - ) - self.change: KeyManager = KeyChain( - self, public_key, 1, change_gap, change_maximum_uses_per_address - ) - self.keychains: Sequence[KeyManager] = (self.receiving, self.change) - else: - self.change = self.receiving = SingleKey(self, public_key, 0) - self.keychains = (self.receiving,) + generator_name = address_generator.get('name', HierarchicalDeterministic.name) + self.address_generator: Type[AddressManager] = self.address_generators[generator_name] + self.receiving, self.change = self.address_generator.from_dict(self, address_generator) + self.address_managers = {self.receiving, self.change} ledger.add_account(self) @classmethod - def generate(cls, ledger: 'baseledger.BaseLedger', password: str, **kwargs): + def generate(cls, ledger: 'baseledger.BaseLedger', password: str, address_generator: dict = None): seed = cls.mnemonic_class().make_seed() - return cls.from_seed(ledger, seed, password, **kwargs) + return cls.from_seed(ledger, seed, password, address_generator or {}) @classmethod - def from_seed(cls, ledger: 'baseledger.BaseLedger', seed: str, password: str, - is_hd: bool = True, **kwargs): + def from_seed(cls, ledger: 'baseledger.BaseLedger', seed: str, password: str, address_generator: dict): private_key = cls.get_private_key_from_seed(ledger, seed, password) return cls( ledger=ledger, name='Account #{}'.format(private_key.public_key.address), - seed=seed, encrypted=False, is_hd=is_hd, + seed=seed, encrypted=False, private_key=private_key, public_key=private_key.public_key, - **kwargs + address_generator=address_generator ) @classmethod @@ -193,54 +234,30 @@ class BaseAccount: else: private_key = d['private_key'] public_key = from_extended_key_string(ledger, d['public_key']) - - kwargs = dict( + return cls( ledger=ledger, name=d['name'], seed=d['seed'], encrypted=d['encrypted'], private_key=private_key, public_key=public_key, - is_hd=False + address_generator=d['address_generator'] ) - if d['is_hd']: - kwargs.update(dict( - receiving_gap=d['receiving_gap'], - change_gap=d['change_gap'], - receiving_maximum_uses_per_address=d['receiving_maximum_uses_per_address'], - change_maximum_uses_per_address=d['change_maximum_uses_per_address'], - is_hd=True - )) - - return cls(**kwargs) - def to_dict(self): private_key = self.private_key if not self.encrypted and self.private_key: private_key = self.private_key.extended_key_string() - - d = { + return { 'ledger': self.ledger.get_id(), 'name': self.name, 'seed': self.seed, 'encrypted': self.encrypted, 'private_key': private_key, 'public_key': self.public_key.extended_key_string(), - 'is_hd': False + 'address_generator': self.address_generator.to_dict(self.receiving, self.change) } - if isinstance(self.receiving, KeyChain) and isinstance(self.change, KeyChain): - d.update({ - 'receiving_gap': self.receiving.gap, - 'change_gap': self.change.gap, - 'receiving_maximum_uses_per_address': self.receiving.maximum_uses_per_address, - 'change_maximum_uses_per_address': self.change.maximum_uses_per_address, - 'is_hd': True - }) - - return d - def decrypt(self, password): assert self.encrypted, "Key is not encrypted." secret = double_sha256(password) @@ -258,8 +275,8 @@ class BaseAccount: @defer.inlineCallbacks def ensure_address_gap(self): addresses = [] - for keychain in self.keychains: - new_addresses = yield keychain.ensure_address_gap() + for address_manager in self.address_managers: + new_addresses = yield address_manager.ensure_address_gap() addresses.extend(new_addresses) defer.returnValue(addresses) @@ -273,9 +290,8 @@ class BaseAccount: def get_private_key(self, chain: int, index: int) -> PrivateKey: assert not self.encrypted, "Cannot get private key on encrypted wallet account." - if isinstance(self.receiving, SingleKey): - return self.private_key - return self.private_key.child(chain).child(index) + address_manager = {0: self.receiving, 1: self.change}[chain] + return address_manager.get_private_key(index) def get_balance(self, confirmations: int = 6, **constraints): if confirmations > 0: diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 0f326dfa2..e7dc1b4a7 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -328,9 +328,8 @@ class BaseTransaction: self.locktime = stream.read_uint32() @classmethod - def ensure_all_have_same_ledger( - cls, funding_accounts: Iterable[BaseAccount], change_account: BaseAccount = None)\ - -> 'baseledger.BaseLedger': + def ensure_all_have_same_ledger(cls, funding_accounts: Iterable[BaseAccount], + change_account: BaseAccount = None) -> 'baseledger.BaseLedger': ledger = None for account in funding_accounts: if ledger is None: diff --git a/torba/wallet.py b/torba/wallet.py index ca6d48fab..4e5afbd8d 100644 --- a/torba/wallet.py +++ b/torba/wallet.py @@ -24,7 +24,7 @@ class Wallet: self.storage = storage or WalletStorage() def generate_account(self, ledger: 'baseledger.BaseLedger') -> 'baseaccount.BaseAccount': - account = ledger.account_class.generate(ledger, u'torba') + account = ledger.account_class.generate(ledger, u'torba', {}) self.accounts.append(account) return account From e154c83ffeefa991e562163690596e97443fae28 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 29 Jul 2018 14:34:56 -0400 Subject: [PATCH 080/383] pylint and mypy fixes --- torba/baseaccount.py | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index eb2835bbd..406a52902 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -1,5 +1,5 @@ import typing -from typing import Tuple, Type +from typing import Dict, Tuple, Type, Optional, Any from twisted.internet import defer from torba.mnemonic import Mnemonic @@ -27,8 +27,18 @@ class AddressManager: raise NotImplementedError @classmethod - def to_dict(cls, receiving: 'AddressManager', change: 'AddressManager') -> dict: - return {'name': cls.name} + def to_dict(cls, receiving: 'AddressManager', change: 'AddressManager') -> Dict: + d: Dict[str, Any] = {'name': cls.name} + receiving_dict = receiving.to_dict_instance() + if receiving_dict: + d['receiving'] = receiving_dict + change_dict = change.to_dict_instance() + if change_dict: + d['change'] = change_dict + return d + + def to_dict_instance(self) -> Optional[dict]: + raise NotImplementedError @property def db(self): @@ -84,13 +94,6 @@ class HierarchicalDeterministic(AddressManager): cls(account, 1, **d.get('change', {'gap': 6, 'maximum_uses_per_address': 2})) ) - @classmethod - def to_dict(cls, receiving: 'HierarchicalDeterministic', change: 'HierarchicalDeterministic') -> dict: - d = super().to_dict(receiving, change) - d['receiving'] = receiving.to_dict_instance() - d['change'] = change.to_dict_instance() - return d - def to_dict_instance(self): return {'gap': self.gap, 'maximum_uses_per_address': self.maximum_uses_per_address} @@ -159,6 +162,9 @@ class SingleKey(AddressManager): same_address_manager = cls(account, account.public_key, 0) return same_address_manager, same_address_manager + def to_dict_instance(self): + return None + def get_private_key(self, index: int) -> PrivateKey: return self.account.private_key @@ -184,7 +190,7 @@ class BaseAccount: mnemonic_class = Mnemonic private_key_class = PrivateKey public_key_class = PubKey - address_generators = { + address_generators: Dict[str, Type[AddressManager]] = { SingleKey.name: SingleKey, HierarchicalDeterministic.name: HierarchicalDeterministic, } @@ -199,7 +205,7 @@ class BaseAccount: self.private_key = private_key self.public_key = public_key generator_name = address_generator.get('name', HierarchicalDeterministic.name) - self.address_generator: Type[AddressManager] = self.address_generators[generator_name] + self.address_generator = self.address_generators[generator_name] self.receiving, self.change = self.address_generator.from_dict(self, address_generator) self.address_managers = {self.receiving, self.change} ledger.add_account(self) From d3a171e63821d2a210c2816562b652b626ea7b6e Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 3 Aug 2018 10:41:40 -0400 Subject: [PATCH 081/383] + closest_match step between branch_and_bound and random_draw coin selections, + Transaction.create() single method instead of .pay()/.liquidate() also its more powerful --- tests/integration/test_transactions.py | 9 +- tests/unit/test_coinselection.py | 14 ++- tests/unit/test_transaction.py | 136 +++++++++++++++++++++++-- torba/baseledger.py | 12 +-- torba/basetransaction.py | 124 +++++++++++----------- torba/coinselection.py | 24 ++++- 6 files changed, 232 insertions(+), 87 deletions(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 6b44a90d1..5eb29284b 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -29,7 +29,8 @@ class BasicTransactionTests(IntegrationTestCase): address2 = await d2f(account2.receiving.get_or_create_usable_address()) hash2 = self.ledger.address_to_hash160(address2) - tx = await d2f(self.ledger.transaction_class.pay( + tx = await d2f(self.ledger.transaction_class.create( + [], [self.ledger.transaction_class.output_class.pay_pubkey_hash(2*COIN, hash2)], [account1], account1 )) @@ -42,8 +43,10 @@ class BasicTransactionTests(IntegrationTestCase): self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) utxos = await d2f(self.account.get_unspent_outputs()) - tx = await d2f(self.ledger.transaction_class.liquidate( - [utxos[0]], [account1], account1 + tx = await d2f(self.ledger.transaction_class.create( + [self.ledger.transaction_class.input_class.spend(utxos[0])], + [], + [account1], account1 )) await self.broadcast(tx) await self.on_transaction(tx) # mempool diff --git a/tests/unit/test_coinselection.py b/tests/unit/test_coinselection.py index e607fc3ef..a8d11880f 100644 --- a/tests/unit/test_coinselection.py +++ b/tests/unit/test_coinselection.py @@ -66,6 +66,18 @@ class TestCoinSelectionTests(BaseSelectionTestCase): self.assertEqual([2 * CENT], [c.txo.amount for c in match]) self.assertFalse(selector.exact_match) + def test_pick(self): + utxo_pool = self.estimates( + utxo(1*CENT), + utxo(1*CENT), + utxo(3*CENT), + utxo(5*CENT), + utxo(10*CENT), + ) + selector = CoinSelector(utxo_pool, 3*CENT, 0) + match = selector.select() + self.assertEqual([5*CENT], [c.txo.amount for c in match]) + class TestOfficialBitcoinCoinSelectionTests(BaseSelectionTestCase): @@ -108,7 +120,7 @@ class TestOfficialBitcoinCoinSelectionTests(BaseSelectionTestCase): self.assertEqual([3 * CENT, 2 * CENT], search(utxo_pool, 5 * CENT, 0.5 * CENT)) # Select 11 Cent, not possible - self.assertEqual(search(utxo_pool, 11 * CENT, 0.5 * CENT), []) + self.assertEqual([], search(utxo_pool, 11 * CENT, 0.5 * CENT)) # Select 10 Cent utxo_pool += self.estimates(utxo(5 * CENT)) diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index 47af97eb7..61b6b4187 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -1,4 +1,5 @@ from binascii import hexlify, unhexlify +from itertools import cycle from twisted.trial import unittest from twisted.internet import defer @@ -17,8 +18,8 @@ def get_output(amount=CENT, pubkey_hash=NULL_HASH): .outputs[0] -def get_input(): - return ledger_class.transaction_class.input_class.spend(get_output()) +def get_input(amount=CENT, pubkey_hash=NULL_HASH): + return ledger_class.transaction_class.input_class.spend(get_output(amount, pubkey_hash)) def get_transaction(txo=None): @@ -31,27 +32,22 @@ class TestSizeAndFeeEstimation(unittest.TestCase): def setUp(self): self.ledger = ledger_class({'db': ledger_class.database_class(':memory:')}) - return self.ledger.db.start() - - def io_fee(self, io): - return self.ledger.get_input_output_fee(io) def test_output_size_and_fee(self): txo = get_output() self.assertEqual(txo.size, 46) - self.assertEqual(self.io_fee(txo), 46 * FEE_PER_BYTE) + self.assertEqual(txo.get_fee(self.ledger), 46 * FEE_PER_BYTE) def test_input_size_and_fee(self): txi = get_input() self.assertEqual(txi.size, 148) - self.assertEqual(self.io_fee(txi), 148 * FEE_PER_BYTE) + self.assertEqual(txi.get_fee(self.ledger), 148 * FEE_PER_BYTE) def test_transaction_size_and_fee(self): tx = get_transaction() - base_size = tx.size - 1 - tx.inputs[0].size self.assertEqual(tx.size, 204) - self.assertEqual(tx.base_size, base_size) - self.assertEqual(self.ledger.get_transaction_base_fee(tx), FEE_PER_BYTE * base_size) + self.assertEqual(tx.base_size, tx.size - tx.inputs[0].size - tx.outputs[0].size) + self.assertEqual(tx.get_base_fee(self.ledger), FEE_PER_BYTE * tx.base_size) class TestTransactionSerialization(unittest.TestCase): @@ -169,3 +165,121 @@ class TestTransactionSigning(unittest.TestCase): b'304402203d463519290d06891e461ea5256c56097ccdad53379b1bb4e51ec5abc6e9fd02022034ed15b9' b'd7c678716c4aa7c0fd26c688e8f9db8075838f2839ab55d551b62c0a01' ) + + +class TransactionIOBalancing(unittest.TestCase): + + @defer.inlineCallbacks + def setUp(self): + self.ledger = ledger_class({'db': ledger_class.database_class(':memory:')}) + yield self.ledger.db.start() + self.account = self.ledger.account_class.from_seed( + self.ledger, + u"carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" + u"sent", u"torba", {} + ) + + addresses = yield self.account.ensure_address_gap() + self.pubkey_hash = [self.ledger.address_to_hash160(a) for a in addresses] + self.hash_cycler = cycle(self.pubkey_hash) + + def txo(self, amount, address=None): + return get_output(int(amount*COIN), address or next(self.hash_cycler)) + + def txi(self, txo): + return ledger_class.transaction_class.input_class.spend(txo) + + def tx(self, inputs, outputs): + return ledger_class.transaction_class.create(inputs, outputs, [self.account], self.account) + + @defer.inlineCallbacks + def create_utxos(self, amounts): + utxos = [self.txo(amount) for amount in amounts] + + self.funding_tx = ledger_class.transaction_class() \ + .add_inputs([self.txi(self.txo(sum(amounts)+0.1))]) \ + .add_outputs(utxos) + + save_tx = 'insert' + for utxo in utxos: + yield self.ledger.db.save_transaction_io( + save_tx, self.funding_tx, 1, True, + self.ledger.hash160_to_address(utxo.script.values['pubkey_hash']), + utxo.script.values['pubkey_hash'], '' + ) + save_tx = 'update' + + defer.returnValue(utxos) + + @staticmethod + def inputs(tx): + return [round(i.amount/COIN, 2) for i in tx.inputs] + + @staticmethod + def outputs(tx): + return [round(o.amount/COIN, 2) for o in tx.outputs] + + @defer.inlineCallbacks + def test_basic_use_cases(self): + self.ledger.fee_per_byte = int(.01*CENT) + + # available UTXOs for filling missing inputs + utxos = yield self.create_utxos([ + 1, 1, 3, 5, 10 + ]) + + # pay 3 coins (3.02 w/ fees) + tx = yield self.tx( + [], # inputs + [self.txo(3)] # outputs + ) + # best UTXO match is 5 (as UTXO 3 will be short 0.02 to cover fees) + self.assertEqual(self.inputs(tx), [5]) + # a change of 1.98 is added to reach balance + self.assertEqual(self.outputs(tx), [3, 1.98]) + + yield self.ledger.release_outputs(utxos) + + # pay 2.98 coins (3.00 w/ fees) + tx = yield self.tx( + [], # inputs + [self.txo(2.98)] # outputs + ) + # best UTXO match is 3 and no change is needed + self.assertEqual(self.inputs(tx), [3]) + self.assertEqual(self.outputs(tx), [2.98]) + + yield self.ledger.release_outputs(utxos) + + # supplied input and output, but input is not enough to cover output + tx = yield self.tx( + [self.txi(self.txo(10))], # inputs + [self.txo(11)] # outputs + ) + # additional input is chosen (UTXO 3) + self.assertEqual([10, 3], self.inputs(tx)) + # change is now needed to consume extra input + self.assertEqual([11, 1.96], self.outputs(tx)) + + yield self.ledger.release_outputs(utxos) + + # liquidating a UTXO + tx = yield self.tx( + [self.txi(self.txo(10))], # inputs + [] # outputs + ) + self.assertEqual([10], self.inputs(tx)) + # missing change added to consume the amount + self.assertEqual([9.98], self.outputs(tx)) + + yield self.ledger.release_outputs(utxos) + + # liquidating at a loss, requires adding extra inputs + tx = yield self.tx( + [self.txi(self.txo(0.01))], # inputs + [] # outputs + ) + # UTXO 1 is added to cover some of the fee + self.assertEqual([0.01, 1], self.inputs(tx)) + # change is now needed to consume extra input + self.assertEqual([0.97], self.outputs(tx)) diff --git a/torba/baseledger.py b/torba/baseledger.py index bf64bfd01..3cbbf0b72 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -117,14 +117,6 @@ class BaseLedger(metaclass=LedgerRegistry): def path(self): return os.path.join(self.config['data_path'], self.get_id()) - def get_input_output_fee(self, io: basetransaction.InputOutput) -> int: - """ Fee based on size of the input / output. """ - return self.fee_per_byte * io.size - - def get_transaction_base_fee(self, tx): - """ Fee for the transaction header and all outputs; without inputs. """ - return self.fee_per_byte * tx.base_size - @defer.inlineCallbacks def add_account(self, account: baseaccount.BaseAccount) -> defer.Deferred: self.accounts.append(account) @@ -161,9 +153,7 @@ class BaseLedger(metaclass=LedgerRegistry): txos = yield self.get_effective_amount_estimators(funding_accounts) selector = CoinSelector( txos, amount, - self.get_input_output_fee( - self.transaction_class.output_class.pay_pubkey_hash(COIN, NULL_HASH32) - ) + self.transaction_class.output_class.pay_pubkey_hash(COIN, NULL_HASH32).get_fee(self) ) spendables = selector.select() if spendables: diff --git a/torba/basetransaction.py b/torba/basetransaction.py index e7dc1b4a7..b74a49fdd 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -95,6 +95,9 @@ class InputOutput: self.serialize_to(stream) return len(stream.get_bytes()) + def get_fee(self, ledger): + return self.size * ledger.fee_per_byte + def serialize_to(self, stream, alternate_script=None): raise NotImplementedError @@ -166,7 +169,7 @@ class BaseOutputEffectiveAmountEstimator: def __init__(self, ledger: 'baseledger.BaseLedger', txo: 'BaseOutput') -> None: self.txo = txo self.txi = ledger.transaction_class.input_class.spend(txo) - self.fee: int = ledger.get_input_output_fee(self.txi) + self.fee: int = self.txi.get_fee(ledger) self.effective_amount: int = txo.amount - self.fee def __lt__(self, other): @@ -268,11 +271,6 @@ class BaseTransaction: def add_outputs(self, outputs: Iterable[BaseOutput]) -> 'BaseTransaction': return self._add(outputs, self._outputs) - @property - def fee(self) -> int: - """ Fee that will actually be paid.""" - return self.input_sum - self.output_sum - @property def size(self) -> int: """ Size in bytes of the entire transaction. """ @@ -280,8 +278,32 @@ class BaseTransaction: @property def base_size(self) -> int: - """ Size in bytes of transaction meta data and all outputs; without inputs. """ - return len(self._serialize(with_inputs=False)) + """ Size of transaction without inputs or outputs in bytes. """ + return ( + self.size + - sum(txi.size for txi in self._inputs) + - sum(txo.size for txo in self._outputs) + ) + + @property + def input_sum(self): + return sum(i.amount for i in self.inputs) + + @property + def output_sum(self): + return sum(o.amount for o in self.outputs) + + def get_base_fee(self, ledger): + """ Fee for base tx excluding inputs and outputs. """ + return self.base_size * ledger.fee_per_byte + + def get_effective_input_sum(self, ledger): + """ Sum of input values *minus* the cost involved to spend them. """ + return sum(txi.amount - txi.get_fee(ledger) for txi in self._inputs) + + def get_total_output_sum(self, ledger): + """ Sum of output values *plus* the cost involved to spend them. """ + return sum(txo.amount + txo.get_fee(ledger) for txo in self._outputs) def _serialize(self, with_inputs: bool = True) -> bytes: stream = BCDataStream() @@ -346,62 +368,56 @@ class BaseTransaction: @classmethod @defer.inlineCallbacks - def pay(cls, outputs: Iterable[BaseOutput], funding_accounts: Iterable[BaseAccount], - change_account: BaseAccount): - """ Efficiently spend utxos from funding_accounts to cover the new outputs. """ + def create(cls, inputs: Iterable[BaseInput], outputs: Iterable[BaseOutput], + funding_accounts: Iterable[BaseAccount], change_account: BaseAccount): + """ Find optimal set of inputs when only outputs are provided; add change + outputs if only inputs are provided or if inputs are greater than outputs. """ + + tx = cls() \ + .add_inputs(inputs) \ + .add_outputs(outputs) - tx = cls().add_outputs(outputs) ledger = cls.ensure_all_have_same_ledger(funding_accounts, change_account) - amount = tx.output_sum + ledger.get_transaction_base_fee(tx) - spendables = yield ledger.get_spendable_utxos(amount, funding_accounts) - if not spendables: - raise ValueError('Not enough funds to cover this transaction.') + # value of the outputs plus associated fees + cost = ( + tx.get_base_fee(ledger) + + tx.get_total_output_sum(ledger) + ) + # value of the inputs less the cost to spend those inputs + payment = tx.get_effective_input_sum(ledger) try: - spent_sum = sum(s.effective_amount for s in spendables) - if spent_sum > amount: - change_address = yield change_account.change.get_or_create_usable_address() - change_hash160 = change_account.ledger.address_to_hash160(change_address) - change_amount = spent_sum - amount - tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) - tx.add_inputs(s.txi for s in spendables) + if payment < cost: + deficit = cost - payment + spendables = yield ledger.get_spendable_utxos(deficit, funding_accounts) + if not spendables: + raise ValueError('Not enough funds to cover this transaction.') + payment += sum(s.effective_amount for s in spendables) + tx.add_inputs(s.txi for s in spendables) + + if payment > cost: + cost_of_change = ( + tx.get_base_fee(ledger) + + cls.output_class.pay_pubkey_hash(COIN, NULL_HASH32).get_fee(ledger) + ) + change = payment - cost + if change > cost_of_change: + change_address = yield change_account.change.get_or_create_usable_address() + change_hash160 = change_account.ledger.address_to_hash160(change_address) + change_amount = change - cost_of_change + tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) + yield tx.sign(funding_accounts) except Exception as e: log.exception('Failed to synchronize transaction:') - yield ledger.release_outputs(s.txo for s in spendables) + yield ledger.release_outputs(tx.outputs) raise e defer.returnValue(tx) - @classmethod - @defer.inlineCallbacks - def liquidate(cls, assets, funding_accounts, change_account): - """ Spend assets (utxos) supplementing with funding_accounts if fee is higher than asset value. """ - tx = cls().add_inputs([ - cls.input_class.spend(utxo) for utxo in assets - ]) - ledger = cls.ensure_all_have_same_ledger(funding_accounts, change_account) - yield ledger.reserve_outputs(assets) - try: - cost_of_change = ( - ledger.get_transaction_base_fee(tx) + - ledger.get_input_output_fee(cls.output_class.pay_pubkey_hash(COIN, NULL_HASH32)) - ) - liquidated_total = sum(utxo.amount for utxo in assets) - if liquidated_total > cost_of_change: - change_address = yield change_account.change.get_or_create_usable_address() - change_hash160 = change_account.ledger.address_to_hash160(change_address) - change_amount = liquidated_total - cost_of_change - tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) - yield tx.sign(funding_accounts) - except Exception: - yield ledger.release_outputs(assets) - raise - defer.returnValue(tx) - @staticmethod def signature_hash_type(hash_type): return hash_type @@ -425,14 +441,6 @@ class BaseTransaction: raise NotImplementedError("Don't know how to spend this output.") self._reset() - @property - def input_sum(self): - return sum(i.amount for i in self.inputs) - - @property - def output_sum(self): - return sum(o.amount for o in self.outputs) - @defer.inlineCallbacks def get_my_addresses(self, ledger): addresses = set() diff --git a/torba/coinselection.py b/torba/coinselection.py index bf3709636..440383230 100644 --- a/torba/coinselection.py +++ b/torba/coinselection.py @@ -25,7 +25,11 @@ class CoinSelector: return [] if self.target > self.available: return [] - return self.branch_and_bound() or self.single_random_draw() + return ( + self.branch_and_bound() or + self.closest_match() or + self.random_draw() + ) def branch_and_bound(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: # see bitcoin implementation for more info: @@ -85,13 +89,27 @@ class CoinSelector: return [] - def single_random_draw(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: + def closest_match(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: + """ Pick one UTXOs that is larger than the target but with the smallest change. """ + target = self.target + self.cost_of_change + smallest_change = None + best_match = None + for txo in self.txos: + if txo.effective_amount >= target: + change = txo.effective_amount - target + if smallest_change is None or change < smallest_change: + smallest_change, best_match = change, txo + return [best_match] if best_match else [] + + def random_draw(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: + """ Accumulate UTXOs at random until there is enough to cover the target. """ + target = self.target + self.cost_of_change self.random.shuffle(self.txos, self.random.random) selection = [] amount = 0 for coin in self.txos: selection.append(coin) amount += coin.effective_amount - if amount >= self.target+self.cost_of_change: + if amount >= target: return selection return [] From 1eb375ba80f4cca8efd6cb88eacb080076afbc23 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 3 Aug 2018 12:29:02 -0400 Subject: [PATCH 082/383] add tx.fee property back --- torba/basetransaction.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/torba/basetransaction.py b/torba/basetransaction.py index b74a49fdd..5b5aadde6 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -293,6 +293,10 @@ class BaseTransaction: def output_sum(self): return sum(o.amount for o in self.outputs) + @property + def fee(self): + return self.input_sum - self.output_sum + def get_base_fee(self, ledger): """ Fee for base tx excluding inputs and outputs. """ return self.base_size * ledger.fee_per_byte From f5515e5e77c599a86817d5b34384b7e4670ee27f Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 3 Aug 2018 21:26:53 -0400 Subject: [PATCH 083/383] general purpose constraints builder --- tests/unit/test_database.py | 23 ++++++++++++++++ torba/basedatabase.py | 55 +++++++++++++++++++++---------------- 2 files changed, 55 insertions(+), 23 deletions(-) create mode 100644 tests/unit/test_database.py diff --git a/tests/unit/test_database.py b/tests/unit/test_database.py new file mode 100644 index 000000000..7831f7916 --- /dev/null +++ b/tests/unit/test_database.py @@ -0,0 +1,23 @@ +from unittest import TestCase +from torba.basedatabase import constraints_to_sql + + +class TestConstraintBuilder(TestCase): + + def test_any(self): + constraints = { + 'ages__any': { + 'age__gt': 18, + 'age__lt': 38 + } + } + self.assertEqual( + constraints_to_sql(constraints, prepend_sql=''), + '(age > :ages__any_age__gt OR age < :ages__any_age__lt)' + ) + self.assertEqual( + constraints, { + 'ages__any_age__gt': 18, + 'ages__any_age__lt': 38 + } + ) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index b086f7700..a65e2e029 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -11,6 +11,34 @@ from torba.hash import TXRefImmutable log = logging.getLogger(__name__) +def constraints_to_sql(constraints, joiner=' AND ', prepend_sql=' AND ', prepend_key=''): + if not constraints: + return '' + extras = [] + for key in list(constraints): + col, op = key, '=' + if key.endswith('__not'): + col, op = key[:-len('__not')], '!=' + elif key.endswith('__lt'): + col, op = key[:-len('__lt')], '<' + elif key.endswith('__lte'): + col, op = key[:-len('__lte')], '<=' + elif key.endswith('__gt'): + col, op = key[:-len('__gt')], '>' + elif key.endswith('__like'): + col, op = key[:-len('__like')], 'LIKE' + elif key.endswith('__any'): + subconstraints = constraints.pop(key) + extras.append('({})'.format( + constraints_to_sql(subconstraints, ' OR ', '', key+'_') + )) + for subkey, val in subconstraints.items(): + constraints['{}_{}'.format(key, subkey)] = val + continue + extras.append('{} {} :{}'.format(col, op, prepend_key+key)) + return prepend_sql + joiner.join(extras) if extras else '' + + class SQLiteMixin: CREATE_TABLES_QUERY: Sequence[str] = () @@ -224,21 +252,8 @@ class BaseDatabase(SQLiteMixin): defer.returnValue((None, None, False)) def get_balance_for_account(self, account, include_reserved=False, **constraints): - extra_sql = "" - if constraints: - extras = [] - for key in constraints: - col, op = key, '=' - if key.endswith('__not'): - col, op = key[:-len('__not')], '!=' - elif key.endswith('__lte'): - col, op = key[:-len('__lte')], '<=' - elif key.endswith('__gt'): - col, op = key[:-len('__gt')], '>' - extras.append('{} {} :{}'.format(col, op, key)) - extra_sql = ' AND ' + ' AND '.join(extras) if not include_reserved: - extra_sql += ' AND is_reserved=0' + constraints['is_reserved'] = 0 values = {'account': account.public_key.address} values.update(constraints) return self.query_one_value( @@ -250,24 +265,18 @@ class BaseDatabase(SQLiteMixin): WHERE pubkey_address.account=:account AND txoid NOT IN (SELECT txoid FROM txi) - """+extra_sql, values, 0 + """+constraints_to_sql(constraints), values, 0 ) @defer.inlineCallbacks def get_utxos_for_account(self, account, **constraints): - extra_sql = "" - if constraints: - extra_sql = ' AND ' + ' AND '.join( - '{} = :{}'.format(c, c) for c in constraints - ) - values = {'account': account.public_key.address} - values.update(constraints) + constraints['account'] = account.public_key.address utxos = yield self.run_query( """ SELECT amount, script, txid, txo.position FROM txo JOIN pubkey_address ON pubkey_address.address=txo.address WHERE account=:account AND txo.is_reserved=0 AND txoid NOT IN (SELECT txoid FROM txi) - """+extra_sql, values + """+constraints_to_sql(constraints), constraints ) output_class = account.ledger.transaction_class.output_class defer.returnValue([ From 75ddf209e29020cd4ec72eaf0ed653122369d992 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 6 Aug 2018 00:15:19 -0400 Subject: [PATCH 084/383] create default account when missing and new new account.fund() to support transfer of funds between accounts --- torba/baseaccount.py | 43 +++++++++++++++++++++++++++++++++++++++- torba/basemanager.py | 8 ++++++++ torba/basetransaction.py | 5 +++++ 3 files changed, 55 insertions(+), 1 deletion(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 406a52902..ce32e7df5 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -234,7 +234,10 @@ class BaseAccount: @classmethod def from_dict(cls, ledger: 'baseledger.BaseLedger', d: dict): - if not d['encrypted'] and d['private_key']: + if not d['private_key'] and not d['public_key'] and d['seed']: + private_key = cls.get_private_key_from_seed(ledger, d['seed'], '') + public_key = private_key.public_key + elif not d['encrypted'] and d['private_key']: private_key = from_extended_key_string(ledger, d['private_key']) public_key = private_key.public_key else: @@ -316,3 +319,41 @@ class BaseAccount: def get_unspent_outputs(self, **constraints): return self.ledger.db.get_utxos_for_account(self, **constraints) + + @defer.inlineCallbacks + def fund(self, to_account, amount=None, everything=False, + outputs=1, broadcast=False, **constraints): + assert self.ledger == to_account.ledger, 'Can only transfer between accounts of the same ledger.' + tx_class = self.ledger.transaction_class + if everything: + utxos = yield self.get_unspent_outputs(**constraints) + yield self.ledger.reserve_outputs(utxos) + tx = yield tx_class.create( + inputs=[tx_class.input_class.spend(txo) for txo in utxos], + outputs=[], + funding_accounts=[self], + change_account=to_account + ) + elif amount > 0: + to_address = yield to_account.change.get_or_create_usable_address() + to_hash160 = to_account.ledger.address_to_hash160(to_address) + tx = yield tx_class.create( + inputs=[], + outputs=[ + tx_class.output_class.pay_pubkey_hash(amount//outputs, to_hash160) + for _ in range(outputs) + ], + funding_accounts=[self], + change_account=self + ) + else: + raise ValueError('An amount is required.') + + if broadcast: + yield self.ledger.broadcast(tx) + else: + yield self.ledger.release_outputs( + [txi.txo_ref.txo for txi in tx.inputs] + ) + + defer.returnValue(tx) diff --git a/torba/basemanager.py b/torba/basemanager.py index 7c18a16ef..7ad728066 100644 --- a/torba/basemanager.py +++ b/torba/basemanager.py @@ -1,3 +1,4 @@ +import logging from typing import Type, MutableSequence, MutableMapping from twisted.internet import defer @@ -5,6 +6,8 @@ from torba.baseledger import BaseLedger, LedgerRegistry from torba.wallet import Wallet, WalletStorage from torba.constants import COIN +log = logging.getLogger(__name__) + class BaseWalletManager: @@ -22,6 +25,11 @@ class BaseWalletManager: for wallet_path in config.get('wallets', []): wallet_storage = WalletStorage(wallet_path) wallet = Wallet.from_storage(wallet_storage, manager) + if wallet.default_account is None: + ledger = manager.get_or_create_ledger('lbc_mainnet') + log.info('Wallet at %s is empty, generating a default account.', wallet_path) + wallet.generate_account(ledger) + wallet.save() manager.wallets.append(wallet) return manager diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 5b5aadde6..7302cb3d9 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -197,6 +197,11 @@ class BaseOutput(InputOutput): def id(self): return self.ref.id + def get_address(self, ledger): + return ledger.hash160_to_address( + self.script.values['pubkey_hash'] + ) + def get_estimator(self, ledger): return self.estimator_class(ledger, self) From e996717b600c9bf0b1de5be91e0ad5fcfdc0a83e Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 6 Aug 2018 00:26:46 -0400 Subject: [PATCH 085/383] oops, basemanager shouldnt create default accounts, moved that into lbrynet manager --- torba/basemanager.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/torba/basemanager.py b/torba/basemanager.py index 7ad728066..87422dcf5 100644 --- a/torba/basemanager.py +++ b/torba/basemanager.py @@ -25,11 +25,6 @@ class BaseWalletManager: for wallet_path in config.get('wallets', []): wallet_storage = WalletStorage(wallet_path) wallet = Wallet.from_storage(wallet_storage, manager) - if wallet.default_account is None: - ledger = manager.get_or_create_ledger('lbc_mainnet') - log.info('Wallet at %s is empty, generating a default account.', wallet_path) - wallet.generate_account(ledger) - wallet.save() manager.wallets.append(wallet) return manager From d4107600a5882fd9d8ccd13a0d3694c96d2d7c05 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 6 Aug 2018 02:52:52 -0400 Subject: [PATCH 086/383] from_dict() now also handles from_seed() --- tests/unit/test_account.py | 73 +++++++++++++++++++--------------- tests/unit/test_transaction.py | 24 ++++++----- tests/unit/test_wallet.py | 8 ++-- torba/baseaccount.py | 51 ++++++++++++------------ 4 files changed, 84 insertions(+), 72 deletions(-) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index 47266fef6..3399d6cce 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -92,29 +92,35 @@ class TestHierarchicalDeterministicAccount(unittest.TestCase): @defer.inlineCallbacks def test_generate_account_from_seed(self): - account = self.ledger.account_class.from_seed( - self.ledger, - "carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" - "sent", "torba", {'name': 'deterministic-chain', 'receiving_gap': 3, 'change_gap': 2} + account = self.ledger.account_class.from_dict( + self.ledger, { + "seed": "carbon smart garage balance margin twelve chest sword " + "toast envelope bottom stomach absent", + "address_generator": { + 'name': 'deterministic-chain', + 'receiving': {'gap': 3, 'maximum_uses_per_address': 1}, + 'change': {'gap': 2, 'maximum_uses_per_address': 1} + } + } ) self.assertEqual( account.private_key.extended_key_string(), - 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - '6yz3jMbycrLrRMpeAJxR8qDg8' + 'xprv9s21ZrQH143K3TsAz5efNV8K93g3Ms3FXcjaWB9fVUsMwAoE3ZT4vYymkp5BxK' + 'Kfnpz8J6sHDFriX1SnpvjNkzcks8XBnxjGLS83BTyfpna' ) self.assertEqual( account.public_key.extended_key_string(), - 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' - 'iW44g14WF52fYC5J483wqQ5ZP' + 'xpub661MyMwAqRbcFwwe67Bfjd53h5WXmKm6tqfBJZZH3pQLoy8Nb6mKUMJFc7UbpV' + 'NzmwFPN2evn3YHnig1pkKVYcvCV8owTd2yAcEkJfCX53g' ) address = yield account.receiving.ensure_address_gap() - self.assertEqual(address[0], '1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') + self.assertEqual(address[0], '1CDLuMfwmPqJiNk5C2Bvew6tpgjAGgUk8J') - private_key = yield self.ledger.get_private_key_for_address('1PmX9T3sCiDysNtWszJa44SkKcpGc2NaXP') + private_key = yield self.ledger.get_private_key_for_address('1CDLuMfwmPqJiNk5C2Bvew6tpgjAGgUk8J') self.assertEqual( private_key.extended_key_string(), - 'xprv9xNEfQ296VTRaEUDZ8oKq74xw2U6kpj486vFUB4K1wT9U25GX4UwuzFgJN1YuRrqkQ5TTwCpkYnjNpSoH' - 'SBaEigNHPkoeYbuPMRo6mRUjxg' + 'xprv9xV7rhbg6M4yWrdTeLorz3Q1GrQb4aQzzGWboP3du7W7UUztzNTUrEYTnDfz7o' + 'ptBygDxXYRppyiuenJpoBTgYP2C26E1Ah5FEALM24CsWi' ) invalid_key = yield self.ledger.get_private_key_for_address('BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX') @@ -122,7 +128,7 @@ class TestHierarchicalDeterministicAccount(unittest.TestCase): self.assertEqual( hexlify(private_key.wif()), - b'1cc27be89ad47ef932562af80e95085eb0ab2ae3e5c019b1369b8b05ff2e94512f01' + b'1c01ae1e4c7d89e39f6d3aa7792c097a30ca7d40be249b6de52c81ec8cf9aab48b01' ) @defer.inlineCallbacks @@ -134,11 +140,11 @@ class TestHierarchicalDeterministicAccount(unittest.TestCase): "h absent", 'encrypted': False, 'private_key': - 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - '6yz3jMbycrLrRMpeAJxR8qDg8', + 'xprv9s21ZrQH143K3TsAz5efNV8K93g3Ms3FXcjaWB9fVUsMwAoE3ZT4vYymkp' + '5BxKKfnpz8J6sHDFriX1SnpvjNkzcks8XBnxjGLS83BTyfpna', 'public_key': - 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' - 'iW44g14WF52fYC5J483wqQ5ZP', + 'xpub661MyMwAqRbcFwwe67Bfjd53h5WXmKm6tqfBJZZH3pQLoy8Nb6mKUMJFc7' + 'UbpVNzmwFPN2evn3YHnig1pkKVYcvCV8owTd2yAcEkJfCX53g', 'address_generator': { 'name': 'deterministic-chain', 'receiving': {'gap': 5, 'maximum_uses_per_address': 2}, @@ -244,20 +250,23 @@ class TestSingleKeyAccount(unittest.TestCase): @defer.inlineCallbacks def test_generate_account_from_seed(self): - account = self.ledger.account_class.from_seed( - self.ledger, - "carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" - "sent", "torba", {'name': 'single-address'} + account = self.ledger.account_class.from_dict( + self.ledger, { + "seed": + "carbon smart garage balance margin twelve chest sword toas" + "t envelope bottom stomach absent", + 'address_generator': {'name': 'single-address'} + } ) self.assertEqual( account.private_key.extended_key_string(), - 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - '6yz3jMbycrLrRMpeAJxR8qDg8' + 'xprv9s21ZrQH143K3TsAz5efNV8K93g3Ms3FXcjaWB9fVUsMwAoE3ZT4vYymkp' + '5BxKKfnpz8J6sHDFriX1SnpvjNkzcks8XBnxjGLS83BTyfpna', ) self.assertEqual( account.public_key.extended_key_string(), - 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' - 'iW44g14WF52fYC5J483wqQ5ZP' + 'xpub661MyMwAqRbcFwwe67Bfjd53h5WXmKm6tqfBJZZH3pQLoy8Nb6mKUMJFc7' + 'UbpVNzmwFPN2evn3YHnig1pkKVYcvCV8owTd2yAcEkJfCX53g', ) address = yield account.receiving.ensure_address_gap() self.assertEqual(address[0], account.public_key.address) @@ -265,8 +274,8 @@ class TestSingleKeyAccount(unittest.TestCase): private_key = yield self.ledger.get_private_key_for_address(address[0]) self.assertEqual( private_key.extended_key_string(), - 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - '6yz3jMbycrLrRMpeAJxR8qDg8' + 'xprv9s21ZrQH143K3TsAz5efNV8K93g3Ms3FXcjaWB9fVUsMwAoE3ZT4vYymkp' + '5BxKKfnpz8J6sHDFriX1SnpvjNkzcks8XBnxjGLS83BTyfpna', ) invalid_key = yield self.ledger.get_private_key_for_address('BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX') @@ -274,7 +283,7 @@ class TestSingleKeyAccount(unittest.TestCase): self.assertEqual( hexlify(private_key.wif()), - b'1c2423f3dc6087d9683f73a684935abc0ccd8bc26370588f56653128c6a6f0bf7c01' + b'1c92caa0ef99bfd5e2ceb73b66da8cd726a9370be8c368d448a322f3c5b23aaab901' ) @defer.inlineCallbacks @@ -286,11 +295,11 @@ class TestSingleKeyAccount(unittest.TestCase): "h absent", 'encrypted': False, 'private_key': - 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - '6yz3jMbycrLrRMpeAJxR8qDg8', + 'xprv9s21ZrQH143K3TsAz5efNV8K93g3Ms3FXcjaWB9fVUsMwAoE3ZT4vYymkp' + '5BxKKfnpz8J6sHDFriX1SnpvjNkzcks8XBnxjGLS83BTyfpna', 'public_key': - 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' - 'iW44g14WF52fYC5J483wqQ5ZP', + 'xpub661MyMwAqRbcFwwe67Bfjd53h5WXmKm6tqfBJZZH3pQLoy8Nb6mKUMJFc7' + 'UbpVNzmwFPN2evn3YHnig1pkKVYcvCV8owTd2yAcEkJfCX53g', 'address_generator': {'name': 'single-address'} } diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index 61b6b4187..a0722cbfd 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -141,10 +141,12 @@ class TestTransactionSigning(unittest.TestCase): @defer.inlineCallbacks def test_sign(self): - account = self.ledger.account_class.from_seed( - self.ledger, - u"carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" - u"sent", u"torba", {} + account = self.ledger.account_class.from_dict( + self.ledger, { + "seed": "carbon smart garage balance margin twelve chest sword " + "toast envelope bottom stomach absent" + + } ) yield account.ensure_address_gap() @@ -160,10 +162,11 @@ class TestTransactionSigning(unittest.TestCase): yield tx.sign([account]) + print(hexlify(tx.inputs[0].script.values['signature'])) self.assertEqual( hexlify(tx.inputs[0].script.values['signature']), - b'304402203d463519290d06891e461ea5256c56097ccdad53379b1bb4e51ec5abc6e9fd02022034ed15b9' - b'd7c678716c4aa7c0fd26c688e8f9db8075838f2839ab55d551b62c0a01' + b'304402205a1df8cd5d2d2fa5934b756883d6c07e4f83e1350c740992d47a12422' + b'226aaa202200098ac8675827aea2b0d6f0e49566143a95d523e311d342172cd99e2021e47cb01' ) @@ -173,10 +176,11 @@ class TransactionIOBalancing(unittest.TestCase): def setUp(self): self.ledger = ledger_class({'db': ledger_class.database_class(':memory:')}) yield self.ledger.db.start() - self.account = self.ledger.account_class.from_seed( - self.ledger, - u"carbon smart garage balance margin twelve chest sword toast envelope bottom stomach ab" - u"sent", u"torba", {} + self.account = self.ledger.account_class.from_dict( + self.ledger, { + "seed": "carbon smart garage balance margin twelve chest sword " + "toast envelope bottom stomach absent" + } ) addresses = yield self.account.ensure_address_gap() diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index 31a9cb8ab..9f825834f 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -39,11 +39,11 @@ class TestWalletCreation(unittest.TestCase): "h absent", 'encrypted': False, 'private_key': - 'xprv9s21ZrQH143K2dyhK7SevfRG72bYDRNv25yKPWWm6dqApNxm1Zb1m5gGcBWYfbsPjTr2v5joit8Af2Zp5P' - '6yz3jMbycrLrRMpeAJxR8qDg8', + 'xprv9s21ZrQH143K3TsAz5efNV8K93g3Ms3FXcjaWB9fVUsMwAoE3Z' + 'T4vYymkp5BxKKfnpz8J6sHDFriX1SnpvjNkzcks8XBnxjGLS83BTyfpna', 'public_key': - 'xpub661MyMwAqRbcF84AR8yfHoMzf4S2ct6mPJtvBtvNeyN9hBHuZ6uGJszkTSn5fQUCdz3XU17eBzFeAUwV6f' - 'iW44g14WF52fYC5J483wqQ5ZP', + 'xpub661MyMwAqRbcFwwe67Bfjd53h5WXmKm6tqfBJZZH3pQLoy8Nb6' + 'mKUMJFc7UbpVNzmwFPN2evn3YHnig1pkKVYcvCV8owTd2yAcEkJfCX53g', 'address_generator': { 'name': 'deterministic-chain', 'receiving': {'gap': 17, 'maximum_uses_per_address': 3}, diff --git a/torba/baseaccount.py b/torba/baseaccount.py index ce32e7df5..783530cfc 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -211,20 +211,12 @@ class BaseAccount: ledger.add_account(self) @classmethod - def generate(cls, ledger: 'baseledger.BaseLedger', password: str, address_generator: dict = None): - seed = cls.mnemonic_class().make_seed() - return cls.from_seed(ledger, seed, password, address_generator or {}) - - @classmethod - def from_seed(cls, ledger: 'baseledger.BaseLedger', seed: str, password: str, address_generator: dict): - private_key = cls.get_private_key_from_seed(ledger, seed, password) - return cls( - ledger=ledger, name='Account #{}'.format(private_key.public_key.address), - seed=seed, encrypted=False, - private_key=private_key, - public_key=private_key.public_key, - address_generator=address_generator - ) + def generate(cls, ledger: 'baseledger.BaseLedger', name: str = None, address_generator: dict = None): + return cls.from_dict(ledger, { + 'name': name, + 'seed': cls.mnemonic_class().make_seed(), + 'address_generator': address_generator or {} + }) @classmethod def get_private_key_from_seed(cls, ledger: 'baseledger.BaseLedger', seed: str, password: str): @@ -234,23 +226,30 @@ class BaseAccount: @classmethod def from_dict(cls, ledger: 'baseledger.BaseLedger', d: dict): - if not d['private_key'] and not d['public_key'] and d['seed']: - private_key = cls.get_private_key_from_seed(ledger, d['seed'], '') - public_key = private_key.public_key - elif not d['encrypted'] and d['private_key']: - private_key = from_extended_key_string(ledger, d['private_key']) - public_key = private_key.public_key - else: - private_key = d['private_key'] + seed = d.get('seed', '') + private_key = d.get('private_key', '') + public_key = None + encrypted = d.get('encrypted', False) + if not encrypted: + if seed: + private_key = cls.get_private_key_from_seed(ledger, seed, '') + public_key = private_key.public_key + elif private_key: + private_key = from_extended_key_string(ledger, private_key) + public_key = private_key.public_key + if public_key is None: public_key = from_extended_key_string(ledger, d['public_key']) + name = d.get('name') + if not name: + name = 'Account #{}'.format(public_key.address) return cls( ledger=ledger, - name=d['name'], - seed=d['seed'], - encrypted=d['encrypted'], + name=name, + seed=seed, + encrypted=encrypted, private_key=private_key, public_key=public_key, - address_generator=d['address_generator'] + address_generator=d.get('address_generator', {}) ) def to_dict(self): From e2537e43b59fe4f699ee26d9fa13794fbadb516c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 7 Aug 2018 21:31:29 -0400 Subject: [PATCH 087/383] gave accounts reference to wallet so that they can save themselves after being modified --- tests/unit/test_account.py | 14 ++++++++------ tests/unit/test_ledger.py | 3 ++- tests/unit/test_transaction.py | 5 +++-- torba/baseaccount.py | 11 +++++++---- torba/wallet.py | 23 ++++++++++------------- 5 files changed, 30 insertions(+), 26 deletions(-) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index 3399d6cce..61d62a35e 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -4,6 +4,7 @@ from twisted.internet import defer from torba.coin.bitcoinsegwit import MainNetLedger from torba.baseaccount import HierarchicalDeterministic, SingleKey +from torba.wallet import Wallet class TestHierarchicalDeterministicAccount(unittest.TestCase): @@ -12,7 +13,7 @@ class TestHierarchicalDeterministicAccount(unittest.TestCase): def setUp(self): self.ledger = MainNetLedger({'db': MainNetLedger.database_class(':memory:')}) yield self.ledger.db.start() - self.account = self.ledger.account_class.generate(self.ledger, u"torba") + self.account = self.ledger.account_class.generate(self.ledger, Wallet(), "torba") @defer.inlineCallbacks def test_generate_account(self): @@ -93,7 +94,7 @@ class TestHierarchicalDeterministicAccount(unittest.TestCase): @defer.inlineCallbacks def test_generate_account_from_seed(self): account = self.ledger.account_class.from_dict( - self.ledger, { + self.ledger, Wallet(), { "seed": "carbon smart garage balance margin twelve chest sword " "toast envelope bottom stomach absent", "address_generator": { @@ -152,7 +153,7 @@ class TestHierarchicalDeterministicAccount(unittest.TestCase): } } - account = self.ledger.account_class.from_dict(self.ledger, account_data) + account = self.ledger.account_class.from_dict(self.ledger, Wallet(), account_data) yield account.ensure_address_gap() @@ -172,7 +173,8 @@ class TestSingleKeyAccount(unittest.TestCase): def setUp(self): self.ledger = MainNetLedger({'db': MainNetLedger.database_class(':memory:')}) yield self.ledger.db.start() - self.account = self.ledger.account_class.generate(self.ledger, u"torba", {'name': 'single-address'}) + self.account = self.ledger.account_class.generate( + self.ledger, Wallet(), "torba", {'name': 'single-address'}) @defer.inlineCallbacks def test_generate_account(self): @@ -251,7 +253,7 @@ class TestSingleKeyAccount(unittest.TestCase): @defer.inlineCallbacks def test_generate_account_from_seed(self): account = self.ledger.account_class.from_dict( - self.ledger, { + self.ledger, Wallet(), { "seed": "carbon smart garage balance margin twelve chest sword toas" "t envelope bottom stomach absent", @@ -303,7 +305,7 @@ class TestSingleKeyAccount(unittest.TestCase): 'address_generator': {'name': 'single-address'} } - account = self.ledger.account_class.from_dict(self.ledger, account_data) + account = self.ledger.account_class.from_dict(self.ledger, Wallet(), account_data) yield account.ensure_address_gap() diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index 6a6aff21b..170753f73 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -3,6 +3,7 @@ from twisted.trial import unittest from twisted.internet import defer from torba.coin.bitcoinsegwit import MainNetLedger +from torba.wallet import Wallet from .test_transaction import get_transaction, get_output @@ -63,7 +64,7 @@ class TestSynchronization(LedgerTestCase): @defer.inlineCallbacks def test_update_history(self): - account = self.ledger.account_class.generate(self.ledger, u"torba") + account = self.ledger.account_class.generate(self.ledger, Wallet(), "torba") address = yield account.receiving.get_or_create_usable_address() address_details = yield self.ledger.db.get_address(address) self.assertEqual(address_details['history'], None) diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index a0722cbfd..003055137 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -4,6 +4,7 @@ from twisted.trial import unittest from twisted.internet import defer from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class +from torba.wallet import Wallet from torba.constants import CENT, COIN @@ -142,7 +143,7 @@ class TestTransactionSigning(unittest.TestCase): @defer.inlineCallbacks def test_sign(self): account = self.ledger.account_class.from_dict( - self.ledger, { + self.ledger, Wallet(), { "seed": "carbon smart garage balance margin twelve chest sword " "toast envelope bottom stomach absent" @@ -177,7 +178,7 @@ class TransactionIOBalancing(unittest.TestCase): self.ledger = ledger_class({'db': ledger_class.database_class(':memory:')}) yield self.ledger.db.start() self.account = self.ledger.account_class.from_dict( - self.ledger, { + self.ledger, Wallet(), { "seed": "carbon smart garage balance margin twelve chest sword " "toast envelope bottom stomach absent" } diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 783530cfc..f91cc8d6e 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -195,10 +195,11 @@ class BaseAccount: HierarchicalDeterministic.name: HierarchicalDeterministic, } - def __init__(self, ledger: 'baseledger.BaseLedger', name: str, seed: str, encrypted: bool, + def __init__(self, ledger: 'baseledger.BaseLedger', wallet, name: str, seed: str, encrypted: bool, private_key: PrivateKey, public_key: PubKey, address_generator: dict ) -> None: self.ledger = ledger + self.wallet = wallet self.name = name self.seed = seed self.encrypted = encrypted @@ -209,10 +210,11 @@ class BaseAccount: self.receiving, self.change = self.address_generator.from_dict(self, address_generator) self.address_managers = {self.receiving, self.change} ledger.add_account(self) + wallet.add_account(self) @classmethod - def generate(cls, ledger: 'baseledger.BaseLedger', name: str = None, address_generator: dict = None): - return cls.from_dict(ledger, { + def generate(cls, ledger: 'baseledger.BaseLedger', wallet, name: str = None, address_generator: dict = None): + return cls.from_dict(ledger, wallet, { 'name': name, 'seed': cls.mnemonic_class().make_seed(), 'address_generator': address_generator or {} @@ -225,7 +227,7 @@ class BaseAccount: ) @classmethod - def from_dict(cls, ledger: 'baseledger.BaseLedger', d: dict): + def from_dict(cls, ledger: 'baseledger.BaseLedger', wallet, d: dict): seed = d.get('seed', '') private_key = d.get('private_key', '') public_key = None @@ -244,6 +246,7 @@ class BaseAccount: name = 'Account #{}'.format(public_key.address) return cls( ledger=ledger, + wallet=wallet, name=name, seed=seed, encrypted=encrypted, diff --git a/torba/wallet.py b/torba/wallet.py index 4e5afbd8d..fd4cb2407 100644 --- a/torba/wallet.py +++ b/torba/wallet.py @@ -23,27 +23,24 @@ class Wallet: self.accounts = accounts or [] self.storage = storage or WalletStorage() - def generate_account(self, ledger: 'baseledger.BaseLedger') -> 'baseaccount.BaseAccount': - account = ledger.account_class.generate(ledger, u'torba', {}) + def add_account(self, account): self.accounts.append(account) - return account + + def generate_account(self, ledger: 'baseledger.BaseLedger') -> 'baseaccount.BaseAccount': + return ledger.account_class.generate(ledger, self) @classmethod def from_storage(cls, storage: 'WalletStorage', manager: 'basemanager.BaseWalletManager') -> 'Wallet': json_dict = storage.read() - - accounts = [] + wallet = cls( + name=json_dict.get('name', 'Wallet'), + storage=storage + ) account_dicts: Sequence[dict] = json_dict.get('accounts', []) for account_dict in account_dicts: ledger = manager.get_or_create_ledger(account_dict['ledger']) - account = ledger.account_class.from_dict(ledger, account_dict) - accounts.append(account) - - return cls( - name=json_dict.get('name', 'Wallet'), - accounts=accounts, - storage=storage - ) + ledger.account_class.from_dict(ledger, wallet, account_dict) + return wallet def to_dict(self): return { From f8c1790558dfa3fabee5c68e8a5fb581e5a78019 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 7 Aug 2018 21:36:44 -0400 Subject: [PATCH 088/383] pylint and added type info --- torba/baseaccount.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index f91cc8d6e..ff68c1d49 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -8,6 +8,7 @@ from torba.hash import double_sha256, aes_encrypt, aes_decrypt if typing.TYPE_CHECKING: from torba import baseledger + from torba import wallet class AddressManager: @@ -195,9 +196,9 @@ class BaseAccount: HierarchicalDeterministic.name: HierarchicalDeterministic, } - def __init__(self, ledger: 'baseledger.BaseLedger', wallet, name: str, seed: str, encrypted: bool, - private_key: PrivateKey, public_key: PubKey, address_generator: dict - ) -> None: + def __init__(self, ledger: 'baseledger.BaseLedger', wallet: 'wallet.Wallet', name: str, + seed: str, encrypted: bool, private_key: PrivateKey, public_key: PubKey, + address_generator: dict) -> None: self.ledger = ledger self.wallet = wallet self.name = name @@ -213,7 +214,8 @@ class BaseAccount: wallet.add_account(self) @classmethod - def generate(cls, ledger: 'baseledger.BaseLedger', wallet, name: str = None, address_generator: dict = None): + def generate(cls, ledger: 'baseledger.BaseLedger', wallet: 'wallet.Wallet', + name: str = None, address_generator: dict = None): return cls.from_dict(ledger, wallet, { 'name': name, 'seed': cls.mnemonic_class().make_seed(), @@ -227,7 +229,7 @@ class BaseAccount: ) @classmethod - def from_dict(cls, ledger: 'baseledger.BaseLedger', wallet, d: dict): + def from_dict(cls, ledger: 'baseledger.BaseLedger', wallet: 'wallet.Wallet', d: dict): seed = d.get('seed', '') private_key = d.get('private_key', '') public_key = None From 5b28e77ab50080f37288b2b483fab79b8d1a5091 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 7 Aug 2018 21:47:30 -0400 Subject: [PATCH 089/383] name conflict --- torba/baseaccount.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index ff68c1d49..ca30b1c8d 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -8,7 +8,7 @@ from torba.hash import double_sha256, aes_encrypt, aes_decrypt if typing.TYPE_CHECKING: from torba import baseledger - from torba import wallet + from torba import wallet as basewallet class AddressManager: @@ -196,7 +196,7 @@ class BaseAccount: HierarchicalDeterministic.name: HierarchicalDeterministic, } - def __init__(self, ledger: 'baseledger.BaseLedger', wallet: 'wallet.Wallet', name: str, + def __init__(self, ledger: 'baseledger.BaseLedger', wallet: 'basewallet.Wallet', name: str, seed: str, encrypted: bool, private_key: PrivateKey, public_key: PubKey, address_generator: dict) -> None: self.ledger = ledger @@ -214,7 +214,7 @@ class BaseAccount: wallet.add_account(self) @classmethod - def generate(cls, ledger: 'baseledger.BaseLedger', wallet: 'wallet.Wallet', + def generate(cls, ledger: 'baseledger.BaseLedger', wallet: 'basewallet.Wallet', name: str = None, address_generator: dict = None): return cls.from_dict(ledger, wallet, { 'name': name, @@ -229,7 +229,7 @@ class BaseAccount: ) @classmethod - def from_dict(cls, ledger: 'baseledger.BaseLedger', wallet: 'wallet.Wallet', d: dict): + def from_dict(cls, ledger: 'baseledger.BaseLedger', wallet: 'basewallet.Wallet', d: dict): seed = d.get('seed', '') private_key = d.get('private_key', '') public_key = None From 1a5654d50b241f4ccc8114ef1e183131e294f940 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 15 Aug 2018 17:26:09 -0400 Subject: [PATCH 090/383] Seed version --- torba/mnemonic.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/mnemonic.py b/torba/mnemonic.py index 3cabcf6cb..3d8272844 100644 --- a/torba/mnemonic.py +++ b/torba/mnemonic.py @@ -161,5 +161,5 @@ class Mnemonic: def is_new_seed(seed, prefix): seed = normalize_text(seed) - seed_hash = hexlify(hmac_sha512(b"seed version", seed.encode('utf8'))) + seed_hash = hexlify(hmac_sha512(b"Seed version", seed.encode('utf8'))) return seed_hash.startswith(prefix) From 133a86cd89f08029c64e4290ba023fb7902d7c43 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 16 Aug 2018 00:43:38 -0400 Subject: [PATCH 091/383] blockchain reorg handling and overall header refactor --- .../test_blockchain_reorganization.py | 17 + tests/unit/test_headers.py | 108 +++++ tests/unit/test_ledger.py | 121 ++++-- tests/unit/test_utils.py | 60 +++ torba/basedatabase.py | 4 +- torba/baseheader.py | 374 ++++++++---------- torba/baseledger.py | 107 +++-- torba/coin/bitcoinsegwit.py | 62 ++- torba/hash.py | 8 - torba/util.py | 79 +++- tox.ini | 3 +- 11 files changed, 634 insertions(+), 309 deletions(-) create mode 100644 tests/integration/test_blockchain_reorganization.py create mode 100644 tests/unit/test_headers.py create mode 100644 tests/unit/test_utils.py diff --git a/tests/integration/test_blockchain_reorganization.py b/tests/integration/test_blockchain_reorganization.py new file mode 100644 index 000000000..f61d31f7c --- /dev/null +++ b/tests/integration/test_blockchain_reorganization.py @@ -0,0 +1,17 @@ +from orchstr8.testcase import IntegrationTestCase + + +class BlockchainReorganizationTests(IntegrationTestCase): + + VERBOSE = True + + async def test(self): + self.assertEqual(self.ledger.headers.height, 200) + + await self.blockchain.generate(1) + await self.on_header(201) + self.assertEqual(self.ledger.headers.height, 201) + + await self.blockchain.invalidateblock(self.ledger.headers.hash(201).decode()) + await self.blockchain.generate(2) + await self.on_header(203) diff --git a/tests/unit/test_headers.py b/tests/unit/test_headers.py new file mode 100644 index 000000000..00f628c16 --- /dev/null +++ b/tests/unit/test_headers.py @@ -0,0 +1,108 @@ +import os +from urllib.request import Request, urlopen + +from twisted.trial import unittest +from twisted.internet import defer + +from torba.coin.bitcoinsegwit import MainHeaders + + +def block_bytes(blocks): + return blocks * MainHeaders.header_size + + +class BitcoinHeadersTestCase(unittest.TestCase): + + # Download headers instead of storing them in git. + HEADER_URL = 'http://headers.electrum.org/blockchain_headers' + HEADER_FILE = 'bitcoin_headers' + HEADER_BYTES = block_bytes(32260) # 2.6MB + RETARGET_BLOCK = 32256 # difficulty: 1 -> 1.18 + + def setUp(self): + self.maxDiff = None + self.header_file_name = os.path.join(os.path.dirname(__file__), self.HEADER_FILE) + if not os.path.exists(self.header_file_name): + req = Request(self.HEADER_URL) + req.add_header('Range', 'bytes=0-{}'.format(self.HEADER_BYTES-1)) + with urlopen(req) as response, open(self.header_file_name, 'wb') as header_file: + header_file.write(response.read()) + if os.path.getsize(self.header_file_name) != self.HEADER_BYTES: + os.remove(self.header_file_name) + raise Exception("Downloaded headers for testing are not the correct number of bytes.") + + def get_bytes(self, upto: int = -1, after: int = 0) -> bytes: + with open(self.header_file_name, 'rb') as headers: + headers.seek(after, os.SEEK_SET) + return headers.read(upto) + + def get_headers(self, upto: int = -1): + h = MainHeaders(':memory:') + h.io.write(self.get_bytes(upto)) + return h + + +class BasicHeadersTests(BitcoinHeadersTestCase): + + def test_serialization(self): + h = self.get_headers() + self.assertEqual(h[0], { + 'bits': 486604799, + 'block_height': 0, + 'merkle_root': b'4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b', + 'nonce': 2083236893, + 'prev_block_hash': b'0000000000000000000000000000000000000000000000000000000000000000', + 'timestamp': 1231006505, + 'version': 1 + }) + self.assertEqual(h[self.RETARGET_BLOCK-1], { + 'bits': 486604799, + 'block_height': 32255, + 'merkle_root': b'89b4f223789e40b5b475af6483bb05bceda54059e17d2053334b358f6bb310ac', + 'nonce': 312762301, + 'prev_block_hash': b'000000006baebaa74cecde6c6787c26ee0a616a3c333261bff36653babdac149', + 'timestamp': 1262152739, + 'version': 1 + }) + self.assertEqual(h[self.RETARGET_BLOCK], { + 'bits': 486594666, + 'block_height': 32256, + 'merkle_root': b'64b5e5f5a262f47af443a0120609206a3305877693edfe03e994f20a024ab627', + 'nonce': 121087187, + 'prev_block_hash': b'00000000984f962134a7291e3693075ae03e521f0ee33378ec30a334d860034b', + 'timestamp': 1262153464, + 'version': 1 + }) + self.assertEqual(h[self.RETARGET_BLOCK+1], { + 'bits': 486594666, + 'block_height': 32257, + 'merkle_root': b'4d1488981f08b3037878193297dbac701a2054e0f803d4424fe6a4d763d62334', + 'nonce': 274675219, + 'prev_block_hash': b'000000004f2886a170adb7204cb0c7a824217dd24d11a74423d564c4e0904967', + 'timestamp': 1262154352, + 'version': 1 + }) + self.assertEqual( + h.serialize(h[0]), + h.get_raw_header(0) + ) + self.assertEqual( + h.serialize(h[self.RETARGET_BLOCK]), + h.get_raw_header(self.RETARGET_BLOCK) + ) + + @defer.inlineCallbacks + def test_connect_from_genesis_to_3000_past_first_chunk_at_2016(self): + headers = MainHeaders(':memory:') + self.assertEqual(headers.height, -1) + yield headers.connect(0, self.get_bytes(block_bytes(3001))) + self.assertEqual(headers.height, 3000) + + @defer.inlineCallbacks + def test_connect_9_blocks_passing_a_retarget_at_32256(self): + retarget = block_bytes(self.RETARGET_BLOCK-5) + headers = self.get_headers(upto=retarget) + remainder = self.get_bytes(after=retarget) + self.assertEqual(headers.height, 32250) + yield headers.connect(len(headers), remainder) + self.assertEqual(headers.height, 32259) diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index 170753f73..7a8baa5f6 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -1,11 +1,12 @@ +import os from binascii import hexlify -from twisted.trial import unittest from twisted.internet import defer from torba.coin.bitcoinsegwit import MainNetLedger from torba.wallet import Wallet from .test_transaction import get_transaction, get_output +from .test_headers import BitcoinHeadersTestCase, block_bytes class MockNetwork: @@ -30,34 +31,40 @@ class MockNetwork: return defer.succeed(self.transaction[tx_hash]) -class MockHeaders: - def __init__(self, ledger): - self.ledger = ledger - self.height = 1 - - def __len__(self): - return self.height - - def __getitem__(self, height): - return {'merkle_root': 'abcd04'} - - -class MainNetTestLedger(MainNetLedger): - headers_class = MockHeaders - network_name = 'unittest' - - def __init__(self): - super().__init__({'db': MainNetLedger.database_class(':memory:')}) - - -class LedgerTestCase(unittest.TestCase): +class LedgerTestCase(BitcoinHeadersTestCase): def setUp(self): - self.ledger = MainNetTestLedger() - return self.ledger.db.start() + super().setUp() + self.ledger = MainNetLedger({ + 'db': MainNetLedger.database_class(':memory:'), + 'headers': MainNetLedger.headers_class(':memory:') + }) + return self.ledger.db.open() def tearDown(self): - return self.ledger.db.stop() + super().tearDown() + return self.ledger.db.close() + + def make_header(self, **kwargs): + header = { + 'bits': 486604799, + 'block_height': 0, + 'merkle_root': b'4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b', + 'nonce': 2083236893, + 'prev_block_hash': b'0000000000000000000000000000000000000000000000000000000000000000', + 'timestamp': 1231006505, + 'version': 1 + } + header.update(kwargs) + header['merkle_root'] = header['merkle_root'].ljust(64, b'a') + header['prev_block_hash'] = header['prev_block_hash'].ljust(64, b'0') + return self.ledger.headers.serialize(header) + + def add_header(self, **kwargs): + serialized = self.make_header(**kwargs) + self.ledger.headers.io.seek(0, os.SEEK_END) + self.ledger.headers.io.write(serialized) + self.ledger.headers._size = None class TestSynchronization(LedgerTestCase): @@ -69,11 +76,14 @@ class TestSynchronization(LedgerTestCase): address_details = yield self.ledger.db.get_address(address) self.assertEqual(address_details['history'], None) - self.ledger.headers.height = 3 + self.add_header(block_height=0, merkle_root=b'abcd04') + self.add_header(block_height=1, merkle_root=b'abcd04') + self.add_header(block_height=2, merkle_root=b'abcd04') + self.add_header(block_height=3, merkle_root=b'abcd04') self.ledger.network = MockNetwork([ - {'tx_hash': 'abcd01', 'height': 1}, - {'tx_hash': 'abcd02', 'height': 2}, - {'tx_hash': 'abcd03', 'height': 3}, + {'tx_hash': 'abcd01', 'height': 0}, + {'tx_hash': 'abcd02', 'height': 1}, + {'tx_hash': 'abcd03', 'height': 2}, ], { 'abcd01': hexlify(get_transaction(get_output(1)).raw), 'abcd02': hexlify(get_transaction(get_output(2)).raw), @@ -84,7 +94,7 @@ class TestSynchronization(LedgerTestCase): self.assertEqual(self.ledger.network.get_transaction_called, ['abcd01', 'abcd02', 'abcd03']) address_details = yield self.ledger.db.get_address(address) - self.assertEqual(address_details['history'], 'abcd01:1:abcd02:2:abcd03:3:') + self.assertEqual(address_details['history'], 'abcd01:0:abcd02:1:abcd03:2:') self.ledger.network.get_history_called = [] self.ledger.network.get_transaction_called = [] @@ -92,7 +102,7 @@ class TestSynchronization(LedgerTestCase): self.assertEqual(self.ledger.network.get_history_called, [address]) self.assertEqual(self.ledger.network.get_transaction_called, []) - self.ledger.network.history.append({'tx_hash': 'abcd04', 'height': 4}) + self.ledger.network.history.append({'tx_hash': 'abcd04', 'height': 3}) self.ledger.network.transaction['abcd04'] = hexlify(get_transaction(get_output(4)).raw) self.ledger.network.get_history_called = [] self.ledger.network.get_transaction_called = [] @@ -100,4 +110,51 @@ class TestSynchronization(LedgerTestCase): self.assertEqual(self.ledger.network.get_history_called, [address]) self.assertEqual(self.ledger.network.get_transaction_called, ['abcd04']) address_details = yield self.ledger.db.get_address(address) - self.assertEqual(address_details['history'], 'abcd01:1:abcd02:2:abcd03:3:abcd04:4:') + self.assertEqual(address_details['history'], 'abcd01:0:abcd02:1:abcd03:2:abcd04:3:') + + +class MocHeaderNetwork: + def __init__(self, responses): + self.responses = responses + + def get_headers(self, height, blocks): + return self.responses[height] + + +class BlockchainReorganizationTests(LedgerTestCase): + + @defer.inlineCallbacks + def test_1_block_reorganization(self): + self.ledger.network = MocHeaderNetwork({ + 20: {'height': 20, 'count': 5, 'hex': hexlify( + self.get_bytes(after=block_bytes(20), upto=block_bytes(5)) + )}, + 25: {'height': 25, 'count': 0, 'hex': b''} + }) + headers = self.ledger.headers + yield headers.connect(0, self.get_bytes(upto=block_bytes(20))) + self.add_header(block_height=len(headers)) + self.assertEqual(headers.height, 20) + yield self.ledger.receive_header([{ + 'height': 21, 'hex': hexlify(self.make_header(block_height=21)) + }]) + + @defer.inlineCallbacks + def test_3_block_reorganization(self): + self.ledger.network = MocHeaderNetwork({ + 20: {'height': 20, 'count': 5, 'hex': hexlify( + self.get_bytes(after=block_bytes(20), upto=block_bytes(5)) + )}, + 21: {'height': 21, 'count': 1, 'hex': hexlify(self.make_header(block_height=21))}, + 22: {'height': 22, 'count': 1, 'hex': hexlify(self.make_header(block_height=22))}, + 25: {'height': 25, 'count': 0, 'hex': b''} + }) + headers = self.ledger.headers + yield headers.connect(0, self.get_bytes(upto=block_bytes(20))) + self.add_header(block_height=len(headers)) + self.add_header(block_height=len(headers)) + self.add_header(block_height=len(headers)) + self.assertEqual(headers.height, 22) + yield self.ledger.receive_header(({ + 'height': 23, 'hex': hexlify(self.make_header(block_height=23)) + },)) diff --git a/tests/unit/test_utils.py b/tests/unit/test_utils.py new file mode 100644 index 000000000..565f11bed --- /dev/null +++ b/tests/unit/test_utils.py @@ -0,0 +1,60 @@ +import unittest + +from torba.util import ArithUint256 + + +class TestArithUint256(unittest.TestCase): + + def test(self): + # https://github.com/bitcoin/bitcoin/blob/master/src/test/arith_uint256_tests.cpp + + from_compact = ArithUint256.from_compact + eq = self.assertEqual + + eq(from_compact(0).value, 0) + eq(from_compact(0x00123456).value, 0) + eq(from_compact(0x01003456).value, 0) + eq(from_compact(0x02000056).value, 0) + eq(from_compact(0x03000000).value, 0) + eq(from_compact(0x04000000).value, 0) + eq(from_compact(0x00923456).value, 0) + eq(from_compact(0x01803456).value, 0) + eq(from_compact(0x02800056).value, 0) + eq(from_compact(0x03800000).value, 0) + eq(from_compact(0x04800000).value, 0) + + # Make sure that we don't generate compacts with the 0x00800000 bit set + uint = ArithUint256(0x80) + eq(uint.compact, 0x02008000) + + uint = from_compact(0x01123456) + eq(uint.value, 0x12) + eq(uint.compact, 0x01120000) + + uint = from_compact(0x01fedcba) + eq(uint.value, 0x7e) + eq(uint.negative, 0x01fe0000) + + uint = from_compact(0x02123456) + eq(uint.value, 0x1234) + eq(uint.compact, 0x02123400) + + uint = from_compact(0x03123456) + eq(uint.value, 0x123456) + eq(uint.compact, 0x03123456) + + uint = from_compact(0x04123456) + eq(uint.value, 0x12345600) + eq(uint.compact, 0x04123456) + + uint = from_compact(0x04923456) + eq(uint.value, 0x12345600) + eq(uint.negative, 0x04923456) + + uint = from_compact(0x05009234) + eq(uint.value, 0x92340000) + eq(uint.compact, 0x05009234) + + uint = from_compact(0x20123456) + eq(uint.value, 0x1234560000000000000000000000000000000000000000000000000000000000) + eq(uint.compact, 0x20123456) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index a65e2e029..6f0572553 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -47,7 +47,7 @@ class SQLiteMixin: self._db_path = path self.db: adbapi.ConnectionPool = None - def start(self): + def open(self): log.info("connecting to database: %s", self._db_path) self.db = adbapi.ConnectionPool( 'sqlite3', self._db_path, cp_min=1, cp_max=1, check_same_thread=False @@ -56,7 +56,7 @@ class SQLiteMixin: lambda t: t.executescript(self.CREATE_TABLES_QUERY) ) - def stop(self): + def close(self): self.db.close() return defer.succeed(True) diff --git a/torba/baseheader.py b/torba/baseheader.py index e28fde892..04ca677df 100644 --- a/torba/baseheader.py +++ b/torba/baseheader.py @@ -1,255 +1,195 @@ import os -import struct import logging -import typing -from binascii import unhexlify +from io import BytesIO +from typing import Optional, Iterator, Tuple +from binascii import hexlify from twisted.internet import threads, defer from torba.stream import StreamController -from torba.util import int_to_hex, rev_hex, hash_encode -from torba.hash import double_sha256, pow_hash -if typing.TYPE_CHECKING: - from torba import baseledger +from torba.util import ArithUint256 +from torba.hash import double_sha256 log = logging.getLogger(__name__) +class InvalidHeader(Exception): + + def __init__(self, height, message): + super().__init__(message) + self.message = message + self.height = height + + class BaseHeaders: - header_size = 80 - verify_bits_to_target = True + header_size: int + chunk_size: int - def __init__(self, ledger: 'baseledger.BaseLedger') -> None: - self.ledger = ledger + max_target: int + genesis_hash: bytes + target_timespan: int + + validate_difficulty: bool = True + + def __init__(self, path) -> None: + if path == ':memory:': + self.io = BytesIO() + self.path = path self._size = None self._on_change_controller = StreamController() self.on_changed = self._on_change_controller.stream + self._header_connect_lock = defer.DeferredLock() - @property - def path(self): - return os.path.join(self.ledger.path, 'headers') + def open(self): + if self.path != ':memory:': + self.io = open(self.path, 'a+b') + return defer.succeed(True) - def touch(self): - if not os.path.exists(self.path): - with open(self.path, 'wb'): - pass + def close(self): + self.io.close() + return defer.succeed(True) - @property - def height(self): - return len(self)-1 + @staticmethod + def serialize(header: dict) -> bytes: + raise NotImplementedError - def hash(self, height=None): - if height is None: - height = self.height - header = self[height] - return self._hash_header(header) + @staticmethod + def deserialize(height, header): + raise NotImplementedError - def sync_read_length(self): - return os.path.getsize(self.path) // self.header_size + def get_next_chunk_target(self, chunk: int) -> ArithUint256: + return ArithUint256(self.max_target) - def sync_read_header(self, height): - if 0 <= height < len(self): - with open(self.path, 'rb') as f: - f.seek(height * self.header_size) - return f.read(self.header_size) + def get_next_block_target(self, chunk_target: ArithUint256, previous: Optional[dict], + current: Optional[dict]) -> ArithUint256: + return chunk_target - def __len__(self): + def __len__(self) -> int: if self._size is None: - self._size = self.sync_read_length() + self._size = self.io.seek(0, os.SEEK_END) // self.header_size return self._size - def __getitem__(self, height): + def __bool__(self): + return True + + def __getitem__(self, height) -> dict: assert not isinstance(height, slice), \ "Slicing of header chain has not been implemented yet." - header = self.sync_read_header(height) - return self._deserialize(height, header) + return self.deserialize(height, self.get_raw_header(height)) + + def get_raw_header(self, height) -> bytes: + self.io.seek(height * self.header_size, os.SEEK_SET) + return self.io.read(self.header_size) + + @property + def height(self) -> int: + return len(self)-1 + + def hash(self, height=None) -> bytes: + return self.hash_header( + self.get_raw_header(height or self.height) + ) + + @staticmethod + def hash_header(header: bytes) -> bytes: + if header is None: + return b'0' * 64 + return hexlify(double_sha256(header)[::-1]) @defer.inlineCallbacks - def connect(self, start, headers): - yield threads.deferToThread(self._sync_connect, start, headers) + def connect(self, start: int, headers: bytes): + added = 0 + bail = False + yield self._header_connect_lock.acquire() + try: + for height, chunk in self._iterate_chunks(start, headers): + try: + # validate_chunk() is CPU bound on large chunks + yield threads.deferToThread(self.validate_chunk, height, chunk) + except InvalidHeader as e: + bail = True + chunk = chunk[:(height-e.height)*self.header_size] + written = 0 + if chunk: + self.io.seek(height * self.header_size, os.SEEK_SET) + written = self.io.write(chunk) // self.header_size + self.io.truncate() + # .seek()/.write()/.truncate() might also .flush() when needed + # the goal here is mainly to ensure we're definitely flush()'ing + yield threads.deferToThread(self.io.flush) + self._size = None + self._on_change_controller.add(written) + added += written + if bail: + break + finally: + self._header_connect_lock.release() + defer.returnValue(added) - def _sync_connect(self, start, headers): - previous_header = None - for header in self._iterate_headers(start, headers): - height = header['block_height'] - if previous_header is None and height > 0: - previous_header = self[height-1] - self._verify_header(height, header, previous_header) - previous_header = header + def validate_chunk(self, height, chunk): + previous_hash, previous_header, previous_previous_header = None, None, None + if height > 0: + previous_header = self[height-1] + previous_hash = self.hash(height-1) + if height > 1: + previous_previous_header = self[height-2] + chunk_target = self.get_next_chunk_target(height // 2016 - 1) + for current_hash, current_header in self._iterate_headers(height, chunk): + block_target = self.get_next_block_target(chunk_target, previous_previous_header, previous_header) + self.validate_header(height, current_hash, current_header, previous_hash, block_target) + previous_previous_header = previous_header + previous_header = current_header + previous_hash = current_hash - with open(self.path, 'r+b') as f: - f.seek(start * self.header_size) - f.write(headers) - f.truncate() + def validate_header(self, height: int, current_hash: bytes, + header: dict, previous_hash: bytes, target: ArithUint256): - _old_size = self._size - self._size = self.sync_read_length() - change = self._size - _old_size - log.info( - '%s: added %s header blocks, final height %s', - self.ledger.get_id(), change, self.height - ) - self._on_change_controller.add(change) + if previous_hash is None: + if self.genesis_hash is not None and self.genesis_hash != current_hash: + raise InvalidHeader( + height, "genesis header doesn't match: {} vs expected {}".format( + current_hash.decode(), self.genesis_hash.decode()) + ) + return - def _iterate_headers(self, height, headers): + if header['prev_block_hash'] != previous_hash: + raise InvalidHeader( + height, "previous hash mismatch: {} vs expected {}".format( + header['prev_block_hash'].decode(), previous_hash.decode()) + ) + + if self.validate_difficulty: + + if header['bits'] != target.compact: + raise InvalidHeader( + height, "bits mismatch: {} vs expected {}".format( + header['bits'], target.compact) + ) + + proof_of_work = self.get_proof_of_work(current_hash) + if proof_of_work > target: + raise InvalidHeader( + height, "insufficient proof of work: {} vs target {}".format( + proof_of_work.value, target.value) + ) + + @staticmethod + def get_proof_of_work(header_hash: bytes) -> ArithUint256: + return ArithUint256(int(b'0x' + header_hash, 16)) + + def _iterate_chunks(self, height: int, headers: bytes) -> Iterator[Tuple[int, bytes]]: + assert len(headers) % self.header_size == 0 + start = 0 + end = (self.chunk_size - height % self.chunk_size) * self.header_size + while start < end: + yield height + (start // self.header_size), headers[start:end] + start = end + end = min(len(headers), end + self.chunk_size * self.header_size) + + def _iterate_headers(self, height: int, headers: bytes) -> Iterator[Tuple[bytes, dict]]: assert len(headers) % self.header_size == 0 for idx in range(len(headers) // self.header_size): start, end = idx * self.header_size, (idx + 1) * self.header_size header = headers[start:end] - yield self._deserialize(height+idx, header) - - def _verify_header(self, height, header, previous_header): - previous_hash = self._hash_header(previous_header) - assert previous_hash == header['prev_block_hash'], \ - "prev hash mismatch: {} vs {}".format(previous_hash, header['prev_block_hash']) - - bits, _ = self._calculate_next_work_required(height, previous_header, header) - assert bits == header['bits'], \ - "bits mismatch: {} vs {} (hash: {})".format( - bits, header['bits'], self._hash_header(header)) - - # TODO: FIX ME!!! - #_pow_hash = self._pow_hash_header(header) - #assert int(b'0x' + _pow_hash, 16) <= target, \ - # "insufficient proof of work: {} vs target {}".format( - # int(b'0x' + _pow_hash, 16), target) - - @staticmethod - def _serialize(header): - return b''.join([ - int_to_hex(header['version'], 4), - rev_hex(header['prev_block_hash']), - rev_hex(header['merkle_root']), - int_to_hex(int(header['timestamp']), 4), - int_to_hex(int(header['bits']), 4), - int_to_hex(int(header['nonce']), 4) - ]) - - @staticmethod - def _deserialize(height, header): - version, = struct.unpack('> 24) & 0xff - assert 0x03 <= bits_n <= 0x1d, \ - "First part of bits should be in [0x03, 0x1d], but it was {}".format(hex(bits_n)) - bits_base = bits & 0xffffff - assert 0x8000 <= bits_base <= 0x7fffff, \ - "Second part of bits should be in [0x8000, 0x7fffff] but it was {}".format(bits_base) - - # new target - retarget_timespan = self.ledger.target_timespan - n_actual_timespan = last['timestamp'] - first['timestamp'] - - n_modulated_timespan = retarget_timespan + (n_actual_timespan - retarget_timespan) // 8 - - n_min_timespan = retarget_timespan - (retarget_timespan // 8) - n_max_timespan = retarget_timespan + (retarget_timespan // 2) - - # Limit adjustment step - if n_modulated_timespan < n_min_timespan: - n_modulated_timespan = n_min_timespan - elif n_modulated_timespan > n_max_timespan: - n_modulated_timespan = n_max_timespan - - # Retarget - bn_pow_limit = _ArithUint256(self.ledger.max_target) - bn_new = _ArithUint256.set_compact(last['bits']) - bn_new *= n_modulated_timespan - bn_new //= n_modulated_timespan - if bn_new > bn_pow_limit: - bn_new = bn_pow_limit - - return bn_new.get_compact(), bn_new._value - - -class _ArithUint256: - """ See: lbrycrd/src/arith_uint256.cpp """ - - def __init__(self, value): - self._value = value - - def __str__(self): - return hex(self._value) - - @staticmethod - def from_compact(n_compact): - """Convert a compact representation into its value""" - n_size = n_compact >> 24 - # the lower 23 bits - n_word = n_compact & 0x007fffff - if n_size <= 3: - return n_word >> 8 * (3 - n_size) - else: - return n_word << 8 * (n_size - 3) - - @classmethod - def set_compact(cls, n_compact): - return cls(cls.from_compact(n_compact)) - - def bits(self): - """Returns the position of the highest bit set plus one.""" - bits = bin(self._value)[2:] - for i, d in enumerate(bits): - if d: - return (len(bits) - i) + 1 - return 0 - - def get_low64(self): - return self._value & 0xffffffffffffffff - - def get_compact(self): - """Convert a value into its compact representation""" - n_size = (self.bits() + 7) // 8 - if n_size <= 3: - n_compact = self.get_low64() << 8 * (3 - n_size) - else: - n = _ArithUint256(self._value >> 8 * (n_size - 3)) - n_compact = n.get_low64() - # The 0x00800000 bit denotes the sign. - # Thus, if it is already set, divide the mantissa by 256 and increase the exponent. - if n_compact & 0x00800000: - n_compact >>= 8 - n_size += 1 - assert (n_compact & ~0x007fffff) == 0 - assert n_size < 256 - n_compact |= n_size << 24 - return n_compact - - def __mul__(self, x): - # Take the mod because we are limited to an unsigned 256 bit number - return _ArithUint256((self._value * x) % 2 ** 256) - - def __ifloordiv__(self, x): - self._value = (self._value // x) - return self - - def __gt__(self, x): - return self._value > x._value + yield self.hash_header(header), self.deserialize(height+idx, header) diff --git a/torba/baseledger.py b/torba/baseledger.py index 3cbbf0b72..24c7ad295 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -8,10 +8,10 @@ from collections import namedtuple from twisted.internet import defer from torba import baseaccount -from torba import basedatabase -from torba import baseheader from torba import basenetwork from torba import basetransaction +from torba.basedatabase import BaseDatabase +from torba.baseheader import BaseHeaders, InvalidHeader from torba.coinselection import CoinSelector from torba.constants import COIN, NULL_HASH32 from torba.stream import StreamController @@ -50,13 +50,13 @@ class BaseLedger(metaclass=LedgerRegistry): symbol: str network_name: str + database_class = BaseDatabase account_class = baseaccount.BaseAccount - database_class = basedatabase.BaseDatabase - headers_class = baseheader.BaseHeaders network_class = basenetwork.BaseNetwork transaction_class = basetransaction.BaseTransaction - secret_prefix = None + headers_class: Type[BaseHeaders] + pubkey_address_prefix: bytes script_address_prefix: bytes extended_public_key_prefix: bytes @@ -66,14 +66,16 @@ class BaseLedger(metaclass=LedgerRegistry): def __init__(self, config=None): self.config = config or {} - self.db = self.config.get('db') or self.database_class( + self.db: BaseDatabase = self.config.get('db') or self.database_class( os.path.join(self.path, "blockchain.db") - ) # type: basedatabase.BaseDatabase + ) + self.headers: BaseHeaders = self.config.get('headers') or self.headers_class( + os.path.join(self.path, "headers") + ) self.network = self.config.get('network') or self.network_class(self) - self.network.on_header.listen(self.process_header) - self.network.on_status.listen(self.process_status) + self.network.on_header.listen(self.receive_header) + self.network.on_status.listen(self.receive_status) self.accounts = [] - self.headers = self.config.get('headers') or self.headers_class(self) self.fee_per_byte: int = self.config.get('fee_per_byte', self.default_fee_per_byte) self._on_transaction_controller = StreamController() @@ -87,6 +89,12 @@ class BaseLedger(metaclass=LedgerRegistry): self._on_header_controller = StreamController() self.on_header = self._on_header_controller.stream + self.on_header.listen( + lambda change: log.info( + '%s: added %s header blocks, final height %s', + self.get_id(), change, self.headers.height + ) + ) self._transaction_processing_locks = {} self._utxo_reservation_lock = defer.DeferredLock() @@ -209,11 +217,13 @@ class BaseLedger(metaclass=LedgerRegistry): def start(self): if not os.path.exists(self.path): os.mkdir(self.path) - yield self.db.start() + yield defer.gatherResults([ + self.db.open(), + self.headers.open() + ]) first_connection = self.network.on_connected.first self.network.start() yield first_connection - self.headers.touch() yield self.update_headers() yield self.network.subscribe_headers() yield self.update_accounts() @@ -221,30 +231,69 @@ class BaseLedger(metaclass=LedgerRegistry): @defer.inlineCallbacks def stop(self): yield self.network.stop() - yield self.db.stop() + yield self.db.close() + yield self.headers.close() @defer.inlineCallbacks - def update_headers(self): + def update_headers(self, height=None, headers=None, count=1, subscription_update=False): + rewound = 0 while True: - height_sought = len(self.headers) - headers = yield self.network.get_headers(height_sought, 2000) - if headers['count'] <= 0: - break - yield self.headers.connect(height_sought, unhexlify(headers['hex'])) - self._on_header_controller.add(self.headers.height) + + height = len(self.headers) if height is None else height + if headers is None: + header_response = yield self.network.get_headers(height, 2001) + count = header_response['count'] + headers = header_response['hex'] + + if count <= 0: + return + + added = yield self.headers.connect(height, unhexlify(headers)) + if added > 0: + self._on_header_controller.add(added) + + if subscription_update and added == count: + # subscription updates are for latest header already + # so we don't need to check if there are newer / more + return + + if added == 0: + # headers were invalid, start rewinding + height -= 1 + rewound += 1 + log.warning("Experiencing Blockchain Reorganization: Undoing header.") + else: + # added all headers, see if there are more + height += added + + if height < 0: + raise IndexError( + "Blockchain reorganization rewound all the way back to genesis hash. " + "Something is very wrong. Maybe you are on the wrong blockchain?" + ) + + if rewound >= 50: + raise IndexError( + "Blockchain reorganization dropped {} headers. This is highly unusual. " + "Will not continue to attempt reorganizing." + .format(rewound) + ) + + headers = None + + # if we made it this far and this was a subscription_update + # it means something was wrong and now we're doing a more + # robust sync, turn off subscription update shortcut + subscription_update = False @defer.inlineCallbacks - def process_header(self, response): + def receive_header(self, response): yield self._header_processing_lock.acquire() try: header = response[0] - if header['height'] == len(self.headers): - # New header from network directly connects after the last local header. - yield self.headers.connect(len(self.headers), unhexlify(header['hex'])) - self._on_header_controller.add(self.headers.height) - elif header['height'] > len(self.headers): - # New header is several heights ahead of local, do download instead. - yield self.update_headers() + yield self.update_headers( + height=header['height'], headers=header['hex'], subscription_update=True + ) finally: self._header_processing_lock.release() @@ -338,7 +387,7 @@ class BaseLedger(metaclass=LedgerRegistry): yield self.update_history(address) @defer.inlineCallbacks - def process_status(self, response): + def receive_status(self, response): address, remote_status = response local_status = yield self.get_local_status(address) if local_status != remote_status: diff --git a/torba/coin/bitcoinsegwit.py b/torba/coin/bitcoinsegwit.py index fa293e072..89109de99 100644 --- a/torba/coin/bitcoinsegwit.py +++ b/torba/coin/bitcoinsegwit.py @@ -6,15 +6,60 @@ __node_url__ = ( ) __electrumx__ = 'electrumx.lib.coins.BitcoinSegwitRegtest' -from binascii import unhexlify +import struct +from binascii import hexlify, unhexlify from torba.baseledger import BaseLedger -from torba.baseheader import BaseHeaders +from torba.baseheader import BaseHeaders, ArithUint256 + + +class MainHeaders(BaseHeaders): + header_size = 80 + chunk_size = 2016 + max_target = 0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff + genesis_hash = b'000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f' + target_timespan = 14 * 24 * 60 * 60 + + @staticmethod + def serialize(header: dict) -> bytes: + return b''.join([ + struct.pack(' ArithUint256: + if chunk == -1: + return ArithUint256(self.max_target) + previous = self[chunk * 2016] + current = self[chunk * 2016 + 2015] + actual_timespan = current['timestamp'] - previous['timestamp'] + actual_timespan = max(actual_timespan, int(self.target_timespan / 4)) + actual_timespan = min(actual_timespan, self.target_timespan * 4) + target = ArithUint256.from_compact(current['bits']) + new_target = min(ArithUint256(self.max_target), (target * actual_timespan) / self.target_timespan) + return new_target class MainNetLedger(BaseLedger): name = 'BitcoinSegwit' symbol = 'BTC' network_name = 'mainnet' + headers_class = MainHeaders pubkey_address_prefix = bytes((0,)) script_address_prefix = bytes((5,)) @@ -24,20 +69,17 @@ class MainNetLedger(BaseLedger): default_fee_per_byte = 50 -class UnverifiedHeaders(BaseHeaders): - verify_bits_to_target = False +class UnverifiedHeaders(MainHeaders): + max_target = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + genesis_hash = None + validate_difficulty = False class RegTestLedger(MainNetLedger): - headers_class = UnverifiedHeaders network_name = 'regtest' + headers_class = UnverifiedHeaders pubkey_address_prefix = bytes((111,)) script_address_prefix = bytes((196,)) extended_public_key_prefix = unhexlify('043587cf') extended_private_key_prefix = unhexlify('04358394') - - max_target = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - genesis_hash = '0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206' - genesis_bits = 0x207fffff - target_timespan = 1 diff --git a/torba/hash.py b/torba/hash.py index cf8f2f047..eea757a6a 100644 --- a/torba/hash.py +++ b/torba/hash.py @@ -79,14 +79,6 @@ def ripemd160(x): return h.digest() -def pow_hash(x): - h = sha512(double_sha256(x)) - return double_sha256( - ripemd160(h[:len(h) // 2]) + - ripemd160(h[len(h) // 2:]) - ) - - def double_sha256(x): """ SHA-256 of SHA-256, as used extensively in bitcoin. """ return sha256(sha256(x)) diff --git a/torba/util.py b/torba/util.py index 00ee6ba4d..5a61d550f 100644 --- a/torba/util.py +++ b/torba/util.py @@ -45,19 +45,78 @@ def int_to_bytes(value): return unhexlify(('0' * (len(s) % 2) + s).zfill(length * 2)) -def rev_hex(s): - return hexlify(unhexlify(s)[::-1]) +class ArithUint256: + # https://github.com/bitcoin/bitcoin/blob/master/src/arith_uint256.cpp + __slots__ = '_value', '_compact' -def int_to_hex(i, length=1): - s = hex(i)[2:].rstrip('L') - s = "0" * (2 * length - len(s)) + s - return rev_hex(s) + def __init__(self, value: int) -> None: + self._value = value + self._compact = None + @classmethod + def from_compact(cls, compact) -> 'ArithUint256': + size = compact >> 24 + word = compact & 0x007fffff + if size <= 3: + return cls(word >> 8 * (3 - size)) + else: + return cls(word << 8 * (size - 3)) -def hex_to_int(x): - return int(b'0x' + hexlify(x[::-1]), 16) + @property + def value(self) -> int: + return self._value + @property + def compact(self) -> int: + if self._compact is None: + self._compact = self._calculate_compact() + return self._compact -def hash_encode(x): - return hexlify(x[::-1]) + @property + def negative(self) -> int: + return self._calculate_compact(negative=True) + + @property + def bits(self) -> int: + """ Returns the position of the highest bit set plus one. """ + bn = bin(self._value)[2:] + for i, d in enumerate(bn): + if d: + return (len(bn) - i) + 1 + return 0 + + @property + def low64(self) -> int: + return self._value & 0xffffffffffffffff + + def _calculate_compact(self, negative=False) -> int: + size = (self.bits + 7) // 8 + if size <= 3: + compact = self.low64 << 8 * (3 - size) + else: + compact = ArithUint256(self._value >> 8 * (size - 3)).low64 + # The 0x00800000 bit denotes the sign. + # Thus, if it is already set, divide the mantissa by 256 and increase the exponent. + if compact & 0x00800000: + compact >>= 8 + size += 1 + assert (compact & ~0x007fffff) == 0 + assert size < 256 + compact |= size << 24 + if negative and compact & 0x007fffff: + compact |= 0x00800000 + return compact + + def __mul__(self, x): + # Take the mod because we are limited to an unsigned 256 bit number + return ArithUint256((self._value * x) % 2 ** 256) + + def __truediv__(self, x): + return ArithUint256(int(self._value / x)) + + def __gt__(self, other): + return self._value > other + + def __lt__(self, other): + return self._value < other diff --git a/tox.ini b/tox.ini index 1eb951d74..8eb3120ed 100644 --- a/tox.ini +++ b/tox.ini @@ -19,4 +19,5 @@ setenv = commands = unit: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial unit integration: orchstr8 download - integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration + integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_transactions + integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_blockchain_reorganization From df251def26671e469d61baf4133a5d76906987a5 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 16 Aug 2018 00:56:46 -0400 Subject: [PATCH 092/383] pylint and mypy fixes --- setup.cfg | 3 ++- torba/baseheader.py | 7 ++++--- torba/baseledger.py | 2 +- torba/coin/bitcoincash.py | 7 ++----- torba/coin/bitcoinsegwit.py | 3 ++- torba/util.py | 10 +++++----- 6 files changed, 16 insertions(+), 16 deletions(-) diff --git a/setup.cfg b/setup.cfg index 66c7c22cf..1cb422611 100644 --- a/setup.cfg +++ b/setup.cfg @@ -27,4 +27,5 @@ disable= too-many-arguments, too-many-public-methods, too-many-instance-attributes, - protected-access + protected-access, + unused-argument diff --git a/torba/baseheader.py b/torba/baseheader.py index 04ca677df..442407c84 100644 --- a/torba/baseheader.py +++ b/torba/baseheader.py @@ -27,7 +27,7 @@ class BaseHeaders: chunk_size: int max_target: int - genesis_hash: bytes + genesis_hash: Optional[bytes] target_timespan: int validate_difficulty: bool = True @@ -36,7 +36,7 @@ class BaseHeaders: if path == ':memory:': self.io = BytesIO() self.path = path - self._size = None + self._size: Optional[int] = None self._on_change_controller = StreamController() self.on_changed = self._on_change_controller.stream self._header_connect_lock = defer.DeferredLock() @@ -61,7 +61,8 @@ class BaseHeaders: def get_next_chunk_target(self, chunk: int) -> ArithUint256: return ArithUint256(self.max_target) - def get_next_block_target(self, chunk_target: ArithUint256, previous: Optional[dict], + @staticmethod + def get_next_block_target(chunk_target: ArithUint256, previous: Optional[dict], current: Optional[dict]) -> ArithUint256: return chunk_target diff --git a/torba/baseledger.py b/torba/baseledger.py index 24c7ad295..bde70f59c 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -11,7 +11,7 @@ from torba import baseaccount from torba import basenetwork from torba import basetransaction from torba.basedatabase import BaseDatabase -from torba.baseheader import BaseHeaders, InvalidHeader +from torba.baseheader import BaseHeaders from torba.coinselection import CoinSelector from torba.constants import COIN, NULL_HASH32 from torba.stream import StreamController diff --git a/torba/coin/bitcoincash.py b/torba/coin/bitcoincash.py index 6678af616..77e991217 100644 --- a/torba/coin/bitcoincash.py +++ b/torba/coin/bitcoincash.py @@ -8,8 +8,8 @@ __electrumx__ = 'electrumx.lib.coins.BitcoinCashRegtest' from binascii import unhexlify from torba.baseledger import BaseLedger -from torba.baseheader import BaseHeaders from torba.basetransaction import BaseTransaction +from .bitcoinsegwit import MainHeaders, UnverifiedHeaders class Transaction(BaseTransaction): @@ -23,6 +23,7 @@ class MainNetLedger(BaseLedger): symbol = 'BCH' network_name = 'mainnet' + headers_class = MainHeaders transaction_class = Transaction pubkey_address_prefix = bytes((0,)) @@ -33,10 +34,6 @@ class MainNetLedger(BaseLedger): default_fee_per_byte = 50 -class UnverifiedHeaders(BaseHeaders): - verify_bits_to_target = False - - class RegTestLedger(MainNetLedger): headers_class = UnverifiedHeaders network_name = 'regtest' diff --git a/torba/coin/bitcoinsegwit.py b/torba/coin/bitcoinsegwit.py index 89109de99..bae056eb3 100644 --- a/torba/coin/bitcoinsegwit.py +++ b/torba/coin/bitcoinsegwit.py @@ -7,6 +7,7 @@ __node_url__ = ( __electrumx__ = 'electrumx.lib.coins.BitcoinSegwitRegtest' import struct +from typing import Optional from binascii import hexlify, unhexlify from torba.baseledger import BaseLedger from torba.baseheader import BaseHeaders, ArithUint256 @@ -16,7 +17,7 @@ class MainHeaders(BaseHeaders): header_size = 80 chunk_size = 2016 max_target = 0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff - genesis_hash = b'000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f' + genesis_hash: Optional[bytes] = b'000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f' target_timespan = 14 * 24 * 60 * 60 @staticmethod diff --git a/torba/util.py b/torba/util.py index 5a61d550f..8ae838027 100644 --- a/torba/util.py +++ b/torba/util.py @@ -1,5 +1,5 @@ from binascii import unhexlify, hexlify -from typing import TypeVar, Sequence +from typing import TypeVar, Sequence, Optional T = TypeVar('T') @@ -52,7 +52,7 @@ class ArithUint256: def __init__(self, value: int) -> None: self._value = value - self._compact = None + self._compact: Optional[int] = None @classmethod def from_compact(cls, compact) -> 'ArithUint256': @@ -80,10 +80,10 @@ class ArithUint256: @property def bits(self) -> int: """ Returns the position of the highest bit set plus one. """ - bn = bin(self._value)[2:] - for i, d in enumerate(bn): + bits = bin(self._value)[2:] + for i, d in enumerate(bits): if d: - return (len(bn) - i) + 1 + return (len(bits) - i) + 1 return 0 @property From ac2fe3476a39689d4c7812fc35eebd245823f85a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 16 Aug 2018 01:03:18 -0400 Subject: [PATCH 093/383] fixed unit tests in test_transaction.py --- tests/unit/test_transaction.py | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index 003055137..2ffb5b022 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -32,7 +32,10 @@ def get_transaction(txo=None): class TestSizeAndFeeEstimation(unittest.TestCase): def setUp(self): - self.ledger = ledger_class({'db': ledger_class.database_class(':memory:')}) + self.ledger = ledger_class({ + 'db': ledger_class.database_class(':memory:'), + 'headers': ledger_class.headers_class(':memory:'), + }) def test_output_size_and_fee(self): txo = get_output() @@ -137,8 +140,11 @@ class TestTransactionSerialization(unittest.TestCase): class TestTransactionSigning(unittest.TestCase): def setUp(self): - self.ledger = ledger_class({'db': ledger_class.database_class(':memory:')}) - return self.ledger.db.start() + self.ledger = ledger_class({ + 'db': ledger_class.database_class(':memory:'), + 'headers': ledger_class.headers_class(':memory:'), + }) + return self.ledger.db.open() @defer.inlineCallbacks def test_sign(self): @@ -175,8 +181,11 @@ class TransactionIOBalancing(unittest.TestCase): @defer.inlineCallbacks def setUp(self): - self.ledger = ledger_class({'db': ledger_class.database_class(':memory:')}) - yield self.ledger.db.start() + self.ledger = ledger_class({ + 'db': ledger_class.database_class(':memory:'), + 'headers': ledger_class.headers_class(':memory:'), + }) + yield self.ledger.db.open() self.account = self.ledger.account_class.from_dict( self.ledger, Wallet(), { "seed": "carbon smart garage balance margin twelve chest sword " From 95a22831aa0d726f7051202cd17f2cfb3012a9c7 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 16 Aug 2018 01:11:03 -0400 Subject: [PATCH 094/383] unit test fixes --- tests/unit/test_account.py | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index 61d62a35e..cbd3bc271 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -2,7 +2,7 @@ from binascii import hexlify from twisted.trial import unittest from twisted.internet import defer -from torba.coin.bitcoinsegwit import MainNetLedger +from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class from torba.baseaccount import HierarchicalDeterministic, SingleKey from torba.wallet import Wallet @@ -11,8 +11,11 @@ class TestHierarchicalDeterministicAccount(unittest.TestCase): @defer.inlineCallbacks def setUp(self): - self.ledger = MainNetLedger({'db': MainNetLedger.database_class(':memory:')}) - yield self.ledger.db.start() + self.ledger = ledger_class({ + 'db': ledger_class.database_class(':memory:'), + 'headers': ledger_class.headers_class(':memory:'), + }) + yield self.ledger.db.open() self.account = self.ledger.account_class.generate(self.ledger, Wallet(), "torba") @defer.inlineCallbacks @@ -171,8 +174,11 @@ class TestSingleKeyAccount(unittest.TestCase): @defer.inlineCallbacks def setUp(self): - self.ledger = MainNetLedger({'db': MainNetLedger.database_class(':memory:')}) - yield self.ledger.db.start() + self.ledger = ledger_class({ + 'db': ledger_class.database_class(':memory:'), + 'headers': ledger_class.headers_class(':memory:'), + }) + yield self.ledger.db.open() self.account = self.ledger.account_class.generate( self.ledger, Wallet(), "torba", {'name': 'single-address'}) From e7dcd9216bf4a14a3ff50d4a9ef552b18b8796ee Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 16 Aug 2018 01:21:45 -0400 Subject: [PATCH 095/383] fixing tests --- tests/unit/test_bip32.py | 12 +++++++++--- tests/unit/test_coinselection.py | 9 ++++++--- 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/tests/unit/test_bip32.py b/tests/unit/test_bip32.py index 2854da74b..5bd9fc407 100644 --- a/tests/unit/test_bip32.py +++ b/tests/unit/test_bip32.py @@ -1,7 +1,7 @@ from binascii import unhexlify from twisted.trial import unittest from torba.bip32 import PubKey, PrivateKey, from_extended_key_string -from torba.coin.bitcoinsegwit import MainNetLedger +from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class class BIP32Tests(unittest.TestCase): @@ -40,7 +40,10 @@ class BIP32Tests(unittest.TestCase): with self.assertRaisesRegex(ValueError, 'private key must be 32 bytes'): PrivateKey(None, b'abcd', b'abcd'*8, 0, 255) private_key = PrivateKey( - MainNetLedger({'db': True}), + ledger_class({ + 'db': ledger_class.database_class(':memory:'), + 'headers': ledger_class.headers_class(':memory:'), + }), unhexlify('2423f3dc6087d9683f73a684935abc0ccd8bc26370588f56653128c6a6f0bf7c'), b'abcd'*8, 0, 1 ) @@ -57,7 +60,10 @@ class BIP32Tests(unittest.TestCase): self.assertIsInstance(private_key.child(PrivateKey.HARDENED), PrivateKey) def test_from_extended_keys(self): - ledger = MainNetLedger({'db': True}) + ledger = ledger_class({ + 'db': ledger_class.database_class(':memory:'), + 'headers': ledger_class.headers_class(':memory:'), + }) self.assertIsInstance( from_extended_key_string( ledger, diff --git a/tests/unit/test_coinselection.py b/tests/unit/test_coinselection.py index a8d11880f..b3b577ce8 100644 --- a/tests/unit/test_coinselection.py +++ b/tests/unit/test_coinselection.py @@ -1,7 +1,7 @@ from twisted.trial import unittest from types import GeneratorType -from torba.coin.bitcoinsegwit import MainNetLedger +from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class from torba.coinselection import CoinSelector, MAXIMUM_TRIES from torba.constants import CENT @@ -19,8 +19,11 @@ def search(*args, **kwargs): class BaseSelectionTestCase(unittest.TestCase): def setUp(self): - self.ledger = MainNetLedger({'db': MainNetLedger.database_class(':memory:')}) - return self.ledger.db.start() + self.ledger = ledger_class({ + 'db': ledger_class.database_class(':memory:'), + 'headers': ledger_class.headers_class(':memory:'), + }) + return self.ledger.db.open() def estimates(self, *args): txos = args[0] if isinstance(args[0], (GeneratorType, list)) else args From dabedc17d0bf146743e70480357f81a8053ca127 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 16 Aug 2018 21:41:22 -0400 Subject: [PATCH 096/383] improvements to reorg support --- tests/unit/test_headers.py | 9 ++++-- torba/basedatabase.py | 6 ++++ torba/baseheader.py | 6 +--- torba/baseledger.py | 64 ++++++++++++++++++++++++++------------ 4 files changed, 57 insertions(+), 28 deletions(-) diff --git a/tests/unit/test_headers.py b/tests/unit/test_headers.py index 00f628c16..92654bde5 100644 --- a/tests/unit/test_headers.py +++ b/tests/unit/test_headers.py @@ -27,9 +27,12 @@ class BitcoinHeadersTestCase(unittest.TestCase): req.add_header('Range', 'bytes=0-{}'.format(self.HEADER_BYTES-1)) with urlopen(req) as response, open(self.header_file_name, 'wb') as header_file: header_file.write(response.read()) - if os.path.getsize(self.header_file_name) != self.HEADER_BYTES: - os.remove(self.header_file_name) - raise Exception("Downloaded headers for testing are not the correct number of bytes.") + if os.path.getsize(self.header_file_name) != self.HEADER_BYTES: + os.remove(self.header_file_name) + raise Exception( + "Downloaded headers for testing are not the correct number of bytes. " + "They were deleted. Try running the tests again." + ) def get_bytes(self, upto: int = -1, after: int = 0) -> bytes: with open(self.header_file_name, 'rb') as headers: diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 6f0572553..7af731f12 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -241,6 +241,12 @@ class BaseDatabase(SQLiteMixin): def release_outputs(self, txos): return self.reserve_outputs(txos, is_reserved=False) + def rewind_blockchain(self, above_height): + # TODO: + # 1. delete transactions above_height + # 2. update address histories removing deleted TXs + return defer.succeed(True) + @defer.inlineCallbacks def get_transaction(self, txid): result = yield self.run_query( diff --git a/torba/baseheader.py b/torba/baseheader.py index 442407c84..75be3c52e 100644 --- a/torba/baseheader.py +++ b/torba/baseheader.py @@ -6,7 +6,6 @@ from binascii import hexlify from twisted.internet import threads, defer -from torba.stream import StreamController from torba.util import ArithUint256 from torba.hash import double_sha256 @@ -37,8 +36,6 @@ class BaseHeaders: self.io = BytesIO() self.path = path self._size: Optional[int] = None - self._on_change_controller = StreamController() - self.on_changed = self._on_change_controller.stream self._header_connect_lock = defer.DeferredLock() def open(self): @@ -106,7 +103,7 @@ class BaseHeaders: try: for height, chunk in self._iterate_chunks(start, headers): try: - # validate_chunk() is CPU bound on large chunks + # validate_chunk() is CPU bound and reads previous chunks from file system yield threads.deferToThread(self.validate_chunk, height, chunk) except InvalidHeader as e: bail = True @@ -120,7 +117,6 @@ class BaseHeaders: # the goal here is mainly to ensure we're definitely flush()'ing yield threads.deferToThread(self.io.flush) self._size = None - self._on_change_controller.add(written) added += written if bail: break diff --git a/torba/baseledger.py b/torba/baseledger.py index bde70f59c..560c9842d 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -44,6 +44,10 @@ class TransactionEvent(namedtuple('TransactionEvent', ('address', 'tx', 'height' pass +class BlockHeightEvent(namedtuple('BlockHeightEvent', ('height', 'change'))): + pass + + class BaseLedger(metaclass=LedgerRegistry): name: str @@ -235,36 +239,54 @@ class BaseLedger(metaclass=LedgerRegistry): yield self.headers.close() @defer.inlineCallbacks - def update_headers(self, height=None, headers=None, count=1, subscription_update=False): + def update_headers(self, height=None, headers=None, subscription_update=False): rewound = 0 while True: - height = len(self.headers) if height is None else height - if headers is None: + if height is None or height > len(self.headers): + # sometimes header subscription updates are for a header in the future + # which can't be connected, so we do a normal header sync instead + height = len(self.headers) + headers = None + subscription_update = False + + if not headers: header_response = yield self.network.get_headers(height, 2001) - count = header_response['count'] headers = header_response['hex'] - if count <= 0: + if not headers: + # Nothing to do, network thinks we're already at the latest height. return added = yield self.headers.connect(height, unhexlify(headers)) if added > 0: - self._on_header_controller.add(added) + height += added + self._on_header_controller.add( + BlockHeightEvent(self.headers.height, added)) - if subscription_update and added == count: - # subscription updates are for latest header already - # so we don't need to check if there are newer / more - return + if rewound > 0: + # we started rewinding blocks and apparently found + # a new chain + rewound = 0 + yield self.db.rewind_blockchain(height) - if added == 0: - # headers were invalid, start rewinding + if subscription_update: + # subscription updates are for latest header already + # so we don't need to check if there are newer / more + # on another loop of update_headers(), just return instead + return + + elif added == 0: + # we had headers to connect but none got connected, probably a reorganization height -= 1 rewound += 1 - log.warning("Experiencing Blockchain Reorganization: Undoing header.") + log.warning( + "Blockchain Reorganization: attempting rewind to height {} from starting height {}" + .format(height, height+rewound) + ) + else: - # added all headers, see if there are more - height += added + raise IndexError("headers.connect() returned negative number ({})".format(added)) if height < 0: raise IndexError( @@ -272,17 +294,19 @@ class BaseLedger(metaclass=LedgerRegistry): "Something is very wrong. Maybe you are on the wrong blockchain?" ) - if rewound >= 50: + if rewound >= 100: raise IndexError( "Blockchain reorganization dropped {} headers. This is highly unusual. " - "Will not continue to attempt reorganizing." - .format(rewound) + "Will not continue to attempt reorganizing. Please, delete the ledger " + "synchronization directory inside your wallet directory (folder: '{}') and " + "restart the program to synchronize from scratch." + .format(rewound, self.get_id()) ) - headers = None + headers = None # ready to download some more headers # if we made it this far and this was a subscription_update - # it means something was wrong and now we're doing a more + # it means something went wrong and now we're doing a more # robust sync, turn off subscription update shortcut subscription_update = False From c961dd609a785d80e1b50466838bc1e9312b22f9 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 16 Aug 2018 21:46:02 -0400 Subject: [PATCH 097/383] pylint fixes --- torba/basedatabase.py | 2 +- torba/baseledger.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 7af731f12..92c90fb9d 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -241,7 +241,7 @@ class BaseDatabase(SQLiteMixin): def release_outputs(self, txos): return self.reserve_outputs(txos, is_reserved=False) - def rewind_blockchain(self, above_height): + def rewind_blockchain(self, above_height): # pylint: disable=no-self-use # TODO: # 1. delete transactions above_height # 2. update address histories removing deleted TXs diff --git a/torba/baseledger.py b/torba/baseledger.py index 560c9842d..dd6bad5ec 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -281,8 +281,8 @@ class BaseLedger(metaclass=LedgerRegistry): height -= 1 rewound += 1 log.warning( - "Blockchain Reorganization: attempting rewind to height {} from starting height {}" - .format(height, height+rewound) + "Blockchain Reorganization: attempting rewind to height %s from starting height %s", + height, height+rewound ) else: From 9a2e9d68e7f7b7781aa101ad61fdbbbdf59f06fb Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 20 Aug 2018 22:04:22 -0400 Subject: [PATCH 098/383] + PUSH_INTEGER --- tests/unit/test_script.py | 8 ++++---- torba/basescript.py | 13 ++++++++++++- 2 files changed, 16 insertions(+), 5 deletions(-) diff --git a/tests/unit/test_script.py b/tests/unit/test_script.py index ddb2073d4..1bb832123 100644 --- a/tests/unit/test_script.py +++ b/tests/unit/test_script.py @@ -3,7 +3,7 @@ from twisted.trial import unittest from torba.bcd_data_stream import BCDataStream from torba.basescript import Template, ParseError, tokenize, push_data -from torba.basescript import PUSH_SINGLE, PUSH_MANY, OP_HASH160, OP_EQUAL +from torba.basescript import PUSH_SINGLE, PUSH_INTEGER, PUSH_MANY, OP_HASH160, OP_EQUAL from torba.basescript import BaseInputScript, BaseOutputScript @@ -32,11 +32,11 @@ class TestScriptTemplates(unittest.TestCase): } ) self.assertEqual(parse( - (PUSH_SINGLE('first'), PUSH_SINGLE('last')), - (b'Satoshi', b'Nakamoto') + (PUSH_SINGLE('first'), PUSH_INTEGER('rating')), + (b'Satoshi', (1000).to_bytes(2, 'little')) ), { 'first': b'Satoshi', - 'last': b'Nakamoto' + 'rating': 1000, } ) self.assertEqual(parse( diff --git a/torba/basescript.py b/torba/basescript.py index da3527477..0addac877 100644 --- a/torba/basescript.py +++ b/torba/basescript.py @@ -10,6 +10,7 @@ from torba.util import subclass_tuple OP_0 = 0x00 OP_1 = 0x51 OP_16 = 0x60 +OP_VERIFY = 0x69 OP_DUP = 0x76 OP_HASH160 = 0xa9 OP_EQUALVERIFY = 0x88 @@ -31,6 +32,9 @@ PUSH_DATA_OP = namedtuple('PUSH_DATA_OP', 'name') # opcode for variable length strings # pylint: disable=invalid-name PUSH_SINGLE = subclass_tuple('PUSH_SINGLE', PUSH_DATA_OP) +# opcode for variable size integers +# pylint: disable=invalid-name +PUSH_INTEGER = subclass_tuple('PUSH_INTEGER', PUSH_DATA_OP) # opcode for variable number of variable length strings # pylint: disable=invalid-name PUSH_MANY = subclass_tuple('PUSH_MANY', PUSH_DATA_OP) @@ -155,7 +159,7 @@ class Parser: token = self.tokens[self.token_index] opcode = self.opcodes[self.opcode_index] if isinstance(token, DataToken): - if isinstance(opcode, (PUSH_SINGLE, PUSH_SUBSCRIPT)): + if isinstance(opcode, (PUSH_SINGLE, PUSH_INTEGER, PUSH_SUBSCRIPT)): self.push_single(opcode, token.value) elif isinstance(opcode, PUSH_MANY): self.consume_many_non_greedy() @@ -232,6 +236,8 @@ class Parser: def push_single(self, opcode, value): if isinstance(opcode, PUSH_SINGLE): self.values[opcode.name] = value + elif isinstance(opcode, PUSH_INTEGER): + self.values[opcode.name] = int.from_bytes(value, 'little') elif isinstance(opcode, PUSH_SUBSCRIPT): self.values[opcode.name] = Script.from_source_with_template(value, opcode.template) else: @@ -255,6 +261,11 @@ class Template: if isinstance(opcode, PUSH_SINGLE): data = values[opcode.name] source.write_many(push_data(data)) + elif isinstance(opcode, PUSH_INTEGER): + data = values[opcode.name] + source.write_many(push_data( + data.to_bytes((data.bit_length() + 7) // 8, byteorder='little') + )) elif isinstance(opcode, PUSH_SUBSCRIPT): data = values[opcode.name] source.write_many(push_data(data.source)) From a27f89157ec8fc5ab6542b276a7f610be7e653ef Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 23 Aug 2018 02:53:14 -0400 Subject: [PATCH 099/383] fixed bug where txis were duplicated in the database --- torba/basedatabase.py | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 92c90fb9d..126d53d4e 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -200,9 +200,9 @@ class BaseDatabase(SQLiteMixin): 'height': height, 'is_verified': is_verified }, 'txid = ?', (tx.id,))) - existing_txos = list(map(itemgetter(0), self.execute( + existing_txos = [r[0] for r in self.execute( t, "SELECT position FROM txo WHERE txid = ?", (tx.id,) - ).fetchall())) + ).fetchall()] for txo in tx.outputs: if txo.position in existing_txos: @@ -213,13 +213,23 @@ class BaseDatabase(SQLiteMixin): # TODO: implement script hash payments print('Database.save_transaction_io: pay script hash is not implemented!') - spent_txoids = [txi[0] for txi in self.execute( - t, "SELECT txoid FROM txi WHERE txid = ? AND address = ?", (tx.id, address) + # lookup the address associated with each TXI (via its TXO) + txoids = [txi.txo_ref.id for txi in tx.inputs] + txoid_place_holders = ','.join(['?']*len(txoids)) + txoid_to_address = {r[0]: r[1] for r in self.execute( + t, "SELECT txoid, address FROM txo WHERE txoid in ({})".format(txoid_place_holders), txoids + ).fetchall()} + + # list of TXIs that have already been added + existing_txis = [r[0] for r in self.execute( + t, "SELECT txoid FROM txi WHERE txid = ?", (tx.id,) ).fetchall()] for txi in tx.inputs: txoid = txi.txo_ref.id - if txoid not in spent_txoids: + new_txi = txoid not in existing_txis + address_matches = txoid_to_address.get(txoid) == address + if new_txi and address_matches: self.execute(t, *self._insert_sql("txi", { 'txid': tx.id, 'txoid': txoid, From 026bcd4d4d069545f4fe233082a2e056409526b4 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 23 Aug 2018 02:56:25 -0400 Subject: [PATCH 100/383] pylint fix --- torba/basedatabase.py | 1 - 1 file changed, 1 deletion(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 126d53d4e..d86be74d3 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -1,6 +1,5 @@ import logging from typing import Tuple, List, Sequence -from operator import itemgetter import sqlite3 from twisted.internet import defer From 00cf8131ecb2d78d5c9b85bfa8cd8fec309b1f9a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 24 Aug 2018 17:02:15 -0400 Subject: [PATCH 101/383] removed excessive white space around logo --- README.md | 2 +- torba.png | Bin 10917 -> 10730 bytes 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 37bd6d1cb..ff0f03dc7 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,3 @@ -# Torba Torba [![Build Status](https://travis-ci.org/lbryio/torba.svg?branch=master)](https://travis-ci.org/lbryio/torba) [![Test Coverage](https://codecov.io/gh/lbryio/torba/branch/master/graph/badge.svg)](https://codecov.io/gh/lbryio/torba) +# Torba Torba [![Build Status](https://travis-ci.org/lbryio/torba.svg?branch=master)](https://travis-ci.org/lbryio/torba) [![Test Coverage](https://codecov.io/gh/lbryio/torba/branch/master/graph/badge.svg)](https://codecov.io/gh/lbryio/torba) A new wallet library to help bitcoin based projects build fast, correct and scalable crypto currency wallets in Python. diff --git a/torba.png b/torba.png index 4a525d661fef2c793b0589adf733331d0bf8b687..2e06e8e16d43021823145a51251631a7a124c32a 100644 GIT binary patch literal 10730 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 R3J#P)Fy>Y#D^C#O{ttcSuyX(a From 9e556945127b7710551e083da723954da5ea38cd Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 30 Aug 2018 11:50:11 -0400 Subject: [PATCH 102/383] + get_detailed_accounts --- torba/baseaccount.py | 49 ++++++++++++++++++++++++++++++------------- torba/basedatabase.py | 40 ++++++++++++++++++++++++++--------- torba/baseledger.py | 5 +---- torba/basemanager.py | 23 ++++++++------------ 4 files changed, 75 insertions(+), 42 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index ca30b1c8d..e7f020b2f 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -5,6 +5,7 @@ from twisted.internet import defer from torba.mnemonic import Mnemonic from torba.bip32 import PrivateKey, PubKey, from_extended_key_string from torba.hash import double_sha256, aes_encrypt, aes_decrypt +from torba.constants import COIN if typing.TYPE_CHECKING: from torba import baseledger @@ -65,15 +66,15 @@ class AddressManager: @defer.inlineCallbacks def get_addresses(self, limit: int = None, only_usable: bool = False) -> defer.Deferred: records = yield self.get_address_records(limit=limit, only_usable=only_usable) - defer.returnValue([r['address'] for r in records]) + return [r['address'] for r in records] @defer.inlineCallbacks def get_or_create_usable_address(self) -> defer.Deferred: addresses = yield self.get_addresses(limit=1, only_usable=True) if addresses: - defer.returnValue(addresses[0]) + return addresses[0] addresses = yield self.ensure_address_gap() - defer.returnValue(addresses[0]) + return addresses[0] class HierarchicalDeterministic(AddressManager): @@ -109,7 +110,7 @@ class HierarchicalDeterministic(AddressManager): yield self.db.add_keys( self.account, self.chain_number, new_keys ) - defer.returnValue([key[1].address for key in new_keys]) + return [key[1].address for key in new_keys] @defer.inlineCallbacks def get_max_gap(self) -> defer.Deferred: @@ -122,7 +123,7 @@ class HierarchicalDeterministic(AddressManager): else: max_gap = max(max_gap, current_gap) current_gap = 0 - defer.returnValue(max_gap) + return max_gap @defer.inlineCallbacks def ensure_address_gap(self) -> defer.Deferred: @@ -136,12 +137,12 @@ class HierarchicalDeterministic(AddressManager): break if existing_gap == self.gap: - defer.returnValue([]) + return [] start = addresses[0]['position']+1 if addresses else 0 end = start + (self.gap - existing_gap) new_keys = yield self.generate_keys(start, end-1) - defer.returnValue(new_keys) + return new_keys def get_address_records(self, limit: int = None, only_usable: bool = False): return self._query_addresses( @@ -179,8 +180,8 @@ class SingleKey(AddressManager): yield self.db.add_keys( self.account, self.chain_number, [(0, self.public_key)] ) - defer.returnValue([self.public_key.address]) - defer.returnValue([]) + return [self.public_key.address] + return [] def get_address_records(self, limit: int = None, only_usable: bool = False) -> defer.Deferred: return self._query_addresses() @@ -201,6 +202,7 @@ class BaseAccount: address_generator: dict) -> None: self.ledger = ledger self.wallet = wallet + self.id = public_key.address self.name = name self.seed = seed self.encrypted = encrypted @@ -271,6 +273,22 @@ class BaseAccount: 'address_generator': self.address_generator.to_dict(self.receiving, self.change) } + @defer.inlineCallbacks + def get_details(self, show_seed=False, **kwargs): + satoshis = yield self.get_balance(**kwargs) + details = { + 'id': self.id, + 'name': self.name, + 'coins': round(satoshis/COIN, 2), + 'satoshis': satoshis, + 'encrypted': self.encrypted, + 'public_key': self.public_key.extended_key_string(), + 'address_generator': self.address_generator.to_dict(self.receiving, self.change) + } + if show_seed: + details['seed'] = self.seed + return details + def decrypt(self, password): assert self.encrypted, "Key is not encrypted." secret = double_sha256(password) @@ -291,12 +309,12 @@ class BaseAccount: for address_manager in self.address_managers: new_addresses = yield address_manager.ensure_address_gap() addresses.extend(new_addresses) - defer.returnValue(addresses) + return addresses @defer.inlineCallbacks def get_addresses(self, limit: int = None, max_used_times: int = None) -> defer.Deferred: records = yield self.get_address_records(limit, max_used_times) - defer.returnValue([r['address'] for r in records]) + return [r['address'] for r in records] def get_address_records(self, limit: int = None, max_used_times: int = None) -> defer.Deferred: return self.ledger.db.get_addresses(self, None, limit, max_used_times) @@ -316,14 +334,17 @@ class BaseAccount: def get_max_gap(self): change_gap = yield self.change.get_max_gap() receiving_gap = yield self.receiving.get_max_gap() - defer.returnValue({ + return { 'max_change_gap': change_gap, 'max_receiving_gap': receiving_gap, - }) + } def get_unspent_outputs(self, **constraints): return self.ledger.db.get_utxos_for_account(self, **constraints) + def get_inputs_outputs(self, **constraints): + return self.ledger.db.get_txios_for_account(self, **constraints) + @defer.inlineCallbacks def fund(self, to_account, amount=None, everything=False, outputs=1, broadcast=False, **constraints): @@ -360,4 +381,4 @@ class BaseAccount: [txi.txo_ref.txo for txi in tx.inputs] ) - defer.returnValue(tx) + return tx diff --git a/torba/basedatabase.py b/torba/basedatabase.py index d86be74d3..8e4463631 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -86,25 +86,25 @@ class SQLiteMixin: def query_one_value(self, query, params=None, default=None): result = yield self.run_query(query, params) if result: - defer.returnValue(result[0][0] or default) + return result[0][0] or default else: - defer.returnValue(default) + return default @defer.inlineCallbacks def query_dict_value_list(self, query, fields, params=None): result = yield self.run_query(query.format(', '.join(fields)), params) if result: - defer.returnValue([dict(zip(fields, r)) for r in result]) + return [dict(zip(fields, r)) for r in result] else: - defer.returnValue([]) + return [] @defer.inlineCallbacks def query_dict_value(self, query, fields, params=None, default=None): result = yield self.query_dict_value_list(query, fields, params) if result: - defer.returnValue(result[0]) + return result[0] else: - defer.returnValue(default) + return default @staticmethod def execute(t, sql, values): @@ -262,9 +262,9 @@ class BaseDatabase(SQLiteMixin): "SELECT raw, height, is_verified FROM tx WHERE txid = ?", (txid,) ) if result: - defer.returnValue(result[0]) + return result[0] else: - defer.returnValue((None, None, False)) + return None, None, False def get_balance_for_account(self, account, include_reserved=False, **constraints): if not include_reserved: @@ -294,14 +294,34 @@ class BaseDatabase(SQLiteMixin): """+constraints_to_sql(constraints), constraints ) output_class = account.ledger.transaction_class.output_class - defer.returnValue([ + return [ output_class( values[0], output_class.script_class(values[1]), TXRefImmutable.from_id(values[2]), position=values[3] ) for values in utxos - ]) + ] + + @defer.inlineCallbacks + def get_txios_for_account(self, account, **constraints): + constraints['account'] = account.public_key.address + utxos = yield self.run_query( + """ + SELECT amount, script, txid, txo.position + FROM txo JOIN pubkey_address ON pubkey_address.address=txo.address + WHERE account=:account AND txo.is_reserved=0 AND txoid NOT IN (SELECT txoid FROM txi) + """+constraints_to_sql(constraints), constraints + ) + output_class = account.ledger.transaction_class.output_class + return [ + output_class( + values[0], + output_class.script_class(values[1]), + TXRefImmutable.from_id(values[2]), + position=values[3] + ) for values in utxos + ] def add_keys(self, account, chain, keys): sql = ( diff --git a/torba/baseledger.py b/torba/baseledger.py index dd6bad5ec..a498072da 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -129,11 +129,8 @@ class BaseLedger(metaclass=LedgerRegistry): def path(self): return os.path.join(self.config['data_path'], self.get_id()) - @defer.inlineCallbacks - def add_account(self, account: baseaccount.BaseAccount) -> defer.Deferred: + def add_account(self, account: baseaccount.BaseAccount): self.accounts.append(account) - if self.network.is_connected: - yield self.update_account(account) @defer.inlineCallbacks def get_transaction(self, txhash): diff --git a/torba/basemanager.py b/torba/basemanager.py index 87422dcf5..198e7ae9c 100644 --- a/torba/basemanager.py +++ b/torba/basemanager.py @@ -43,20 +43,15 @@ class BaseWalletManager: return wallet @defer.inlineCallbacks - def get_balances(self, confirmations=6): - balances = {} - for i, ledger in enumerate(self.ledgers.values()): - ledger_balances = balances[ledger.get_id()] = [] - for j, account in enumerate(ledger.accounts): - satoshis = yield account.get_balance(confirmations) - ledger_balances.append({ - 'account': account.name, - 'coins': round(satoshis/COIN, 2), - 'satoshis': satoshis, - 'is_default_account': i == j == 0, - 'id': account.public_key.address - }) - defer.returnValue(balances) + def get_detailed_accounts(self, confirmations=6, show_seed=False): + ledgers = {} + for i, account in enumerate(self.accounts): + details = yield account.get_details(confirmations=confirmations, show_seed=True) + details['is_default_account'] = i == 0 + ledger_id = account.ledger.get_id() + ledgers.setdefault(ledger_id, []) + ledgers[ledger_id].append(details) + return ledgers @property def default_wallet(self): From b102afd68a2ab363c2b7ca18df085df27a82a49d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 30 Aug 2018 12:46:51 -0400 Subject: [PATCH 103/383] - extraneous constants import --- torba/basemanager.py | 1 - 1 file changed, 1 deletion(-) diff --git a/torba/basemanager.py b/torba/basemanager.py index 198e7ae9c..40e2acafa 100644 --- a/torba/basemanager.py +++ b/torba/basemanager.py @@ -4,7 +4,6 @@ from twisted.internet import defer from torba.baseledger import BaseLedger, LedgerRegistry from torba.wallet import Wallet, WalletStorage -from torba.constants import COIN log = logging.getLogger(__name__) From 91d95bd42e3930476a85a7514ca9cb334777ae52 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 30 Aug 2018 14:40:44 -0400 Subject: [PATCH 104/383] have to explicitly subscribe accounts --- tests/integration/test_transactions.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 5eb29284b..207a29f6d 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -9,6 +9,8 @@ class BasicTransactionTests(IntegrationTestCase): async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) + yield self.ledger.update_account(account1) + yield self.ledger.update_account(account2) self.assertEqual(await self.get_balance(account1), 0) self.assertEqual(await self.get_balance(account2), 0) From 57abad21811357fa388efededfe46048cdecf117 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 30 Aug 2018 15:06:10 -0400 Subject: [PATCH 105/383] removed unnecessary address subscribe call in integration tests --- tests/integration/test_transactions.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 207a29f6d..b9173b1c6 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -9,7 +9,6 @@ class BasicTransactionTests(IntegrationTestCase): async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) - yield self.ledger.update_account(account1) yield self.ledger.update_account(account2) self.assertEqual(await self.get_balance(account1), 0) From 873437e6a99506e5263b82072b50200d87e582b3 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Fri, 31 Aug 2018 11:31:59 -0300 Subject: [PATCH 106/383] check for None on height to allow for genesis --- torba/baseheader.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/baseheader.py b/torba/baseheader.py index 75be3c52e..a4b451919 100644 --- a/torba/baseheader.py +++ b/torba/baseheader.py @@ -86,7 +86,7 @@ class BaseHeaders: def hash(self, height=None) -> bytes: return self.hash_header( - self.get_raw_header(height or self.height) + self.get_raw_header(height if height is not None else self.height) ) @staticmethod From 94b920ab2a8fcecc166b7fb525c8d4f15b16e331 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Mon, 17 Sep 2018 15:32:16 -0300 Subject: [PATCH 107/383] fix reconnect --- torba/basenetwork.py | 1 + 1 file changed, 1 insertion(+) diff --git a/torba/basenetwork.py b/torba/basenetwork.py index c1f3926d9..81085422f 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -138,6 +138,7 @@ class BaseNetwork: @defer.inlineCallbacks def start(self): + self.running = True for server in cycle(self.config['default_servers']): connection_string = 'tcp:{}:{}'.format(*server) endpoint = clientFromString(reactor, connection_string) From eedc9bf9edf12683afb48aab519bdcfa708f8e9d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 17 Sep 2018 22:37:00 -0400 Subject: [PATCH 108/383] store mnemonic words in python files instead of txt, this avoids packaging issues --- setup.py | 3 - torba/mnemonic.py | 39 +- torba/words/__init__.py | 0 torba/words/chinese_simplified.py | 2050 ++++++++++++++++++++++++++++ torba/words/chinese_simplified.txt | 2048 --------------------------- torba/words/english.py | 2050 ++++++++++++++++++++++++++++ torba/words/english.txt | 2048 --------------------------- torba/words/japanese.py | 2050 ++++++++++++++++++++++++++++ torba/words/japanese.txt | 2048 --------------------------- torba/words/portuguese.py | 1628 ++++++++++++++++++++++ torba/words/portuguese.txt | 1654 ---------------------- torba/words/spanish.py | 2050 ++++++++++++++++++++++++++++ torba/words/spanish.txt | 2048 --------------------------- 13 files changed, 9843 insertions(+), 9873 deletions(-) create mode 100644 torba/words/__init__.py create mode 100644 torba/words/chinese_simplified.py delete mode 100644 torba/words/chinese_simplified.txt create mode 100644 torba/words/english.py delete mode 100644 torba/words/english.txt create mode 100644 torba/words/japanese.py delete mode 100644 torba/words/japanese.txt create mode 100644 torba/words/portuguese.py delete mode 100644 torba/words/portuguese.txt create mode 100644 torba/words/spanish.py delete mode 100644 torba/words/spanish.txt diff --git a/setup.py b/setup.py index 4e1b7b954..49fca8b3b 100644 --- a/setup.py +++ b/setup.py @@ -1,5 +1,3 @@ -import os -import re from setuptools import setup, find_packages import torba @@ -26,7 +24,6 @@ setup( 'Topic :: Utilities', ), packages=find_packages(exclude=('tests',)), - include_package_data=True, python_requires='>=3.6', install_requires=( 'twisted', diff --git a/torba/mnemonic.py b/torba/mnemonic.py index 3d8272844..789221367 100644 --- a/torba/mnemonic.py +++ b/torba/mnemonic.py @@ -1,11 +1,10 @@ # Copyright (C) 2014 Thomas Voegtlin # Copyright (C) 2018 LBRY Inc. -import os -import io import hmac import math import hashlib +import importlib import unicodedata import string from binascii import hexlify @@ -77,28 +76,20 @@ def normalize_text(seed): return seed -def load_words(filename): - path = os.path.join(os.path.dirname(__file__), 'words', filename) - with io.open(path, 'r', encoding='utf-8') as f: - s = f.read().strip() - s = unicodedata.normalize('NFKD', s) - lines = s.split('\n') - words = [] - for line in lines: - line = line.split('#')[0] - line = line.strip(' \r') - assert ' ' not in line - if line: - words.append(line) - return words +def load_words(language_name): + language_module = importlib.import_module('torba.words.'+language_name) + return list(map( + lambda s: unicodedata.normalize('NFKD', s), + language_module.words + )) -FILE_NAMES = { - 'en': 'english.txt', - 'es': 'spanish.txt', - 'ja': 'japanese.txt', - 'pt': 'portuguese.txt', - 'zh': 'chinese_simplified.txt' +LANGUAGE_NAMES = { + 'en': 'english', + 'es': 'spanish', + 'ja': 'japanese', + 'pt': 'portuguese', + 'zh': 'chinese_simplified' } @@ -107,8 +98,8 @@ class Mnemonic: # Mnemonic phrase uses a hash based checksum, instead of a words-dependent checksum def __init__(self, lang='en'): - filename = FILE_NAMES.get(lang, 'english.txt') - self.words = load_words(filename) + language_name = LANGUAGE_NAMES.get(lang, 'english') + self.words = load_words(language_name) @staticmethod def mnemonic_to_seed(mnemonic, passphrase=u''): diff --git a/torba/words/__init__.py b/torba/words/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/torba/words/chinese_simplified.py b/torba/words/chinese_simplified.py new file mode 100644 index 000000000..3b6e70013 --- /dev/null +++ b/torba/words/chinese_simplified.py @@ -0,0 +1,2050 @@ +words = [ +'的', +'一', +'是', +'在', +'不', +'了', +'有', +'和', +'人', +'这', +'中', +'大', +'为', +'上', +'个', +'国', +'我', +'以', +'要', +'他', +'时', +'来', +'用', +'们', +'生', +'到', +'作', +'地', +'于', +'出', +'就', +'分', +'对', +'成', +'会', +'可', +'主', +'发', +'年', +'动', +'同', +'工', +'也', +'能', +'下', +'过', +'子', +'说', +'产', +'种', +'面', +'而', +'方', +'后', +'多', +'定', +'行', +'学', +'法', +'所', +'民', +'得', +'经', +'十', +'三', +'之', +'进', +'着', +'等', +'部', +'度', +'家', +'电', +'力', +'里', +'如', +'水', +'化', +'高', +'自', +'二', +'理', +'起', +'小', +'物', +'现', +'实', +'加', +'量', +'都', +'两', +'体', +'制', +'机', +'当', +'使', +'点', +'从', +'业', +'本', +'去', +'把', +'性', +'好', +'应', +'开', +'它', +'合', +'还', +'因', +'由', +'其', +'些', +'然', +'前', +'外', +'天', +'政', +'四', +'日', +'那', +'社', +'义', +'事', +'平', +'形', +'相', +'全', +'表', +'间', +'样', +'与', +'关', +'各', +'重', +'新', +'线', +'内', +'数', +'正', +'心', +'反', +'你', +'明', +'看', +'原', +'又', +'么', +'利', +'比', +'或', +'但', +'质', +'气', +'第', +'向', +'道', +'命', +'此', +'变', +'条', +'只', +'没', +'结', +'解', +'问', +'意', +'建', +'月', +'公', +'无', +'系', +'军', +'很', +'情', +'者', +'最', +'立', +'代', +'想', +'已', +'通', +'并', +'提', +'直', +'题', +'党', +'程', +'展', +'五', +'果', +'料', +'象', +'员', +'革', +'位', +'入', +'常', +'文', +'总', +'次', +'品', +'式', +'活', +'设', +'及', +'管', +'特', +'件', +'长', +'求', +'老', +'头', +'基', +'资', +'边', +'流', +'路', +'级', +'少', +'图', +'山', +'统', +'接', +'知', +'较', +'将', +'组', +'见', +'计', +'别', +'她', +'手', +'角', +'期', +'根', +'论', +'运', +'农', +'指', +'几', +'九', +'区', +'强', +'放', +'决', +'西', +'被', +'干', +'做', +'必', +'战', +'先', +'回', +'则', +'任', +'取', +'据', +'处', +'队', +'南', +'给', +'色', +'光', +'门', +'即', +'保', +'治', +'北', +'造', +'百', +'规', +'热', +'领', +'七', +'海', +'口', +'东', +'导', +'器', +'压', +'志', +'世', +'金', +'增', +'争', +'济', +'阶', +'油', +'思', +'术', +'极', +'交', +'受', +'联', +'什', +'认', +'六', +'共', +'权', +'收', +'证', +'改', +'清', +'美', +'再', +'采', +'转', +'更', +'单', +'风', +'切', +'打', +'白', +'教', +'速', +'花', +'带', +'安', +'场', +'身', +'车', +'例', +'真', +'务', +'具', +'万', +'每', +'目', +'至', +'达', +'走', +'积', +'示', +'议', +'声', +'报', +'斗', +'完', +'类', +'八', +'离', +'华', +'名', +'确', +'才', +'科', +'张', +'信', +'马', +'节', +'话', +'米', +'整', +'空', +'元', +'况', +'今', +'集', +'温', +'传', +'土', +'许', +'步', +'群', +'广', +'石', +'记', +'需', +'段', +'研', +'界', +'拉', +'林', +'律', +'叫', +'且', +'究', +'观', +'越', +'织', +'装', +'影', +'算', +'低', +'持', +'音', +'众', +'书', +'布', +'复', +'容', +'儿', +'须', +'际', +'商', +'非', +'验', +'连', +'断', +'深', +'难', +'近', +'矿', +'千', +'周', +'委', +'素', +'技', +'备', +'半', +'办', +'青', +'省', +'列', +'习', +'响', +'约', +'支', +'般', +'史', +'感', +'劳', +'便', +'团', +'往', +'酸', +'历', +'市', +'克', +'何', +'除', +'消', +'构', +'府', +'称', +'太', +'准', +'精', +'值', +'号', +'率', +'族', +'维', +'划', +'选', +'标', +'写', +'存', +'候', +'毛', +'亲', +'快', +'效', +'斯', +'院', +'查', +'江', +'型', +'眼', +'王', +'按', +'格', +'养', +'易', +'置', +'派', +'层', +'片', +'始', +'却', +'专', +'状', +'育', +'厂', +'京', +'识', +'适', +'属', +'圆', +'包', +'火', +'住', +'调', +'满', +'县', +'局', +'照', +'参', +'红', +'细', +'引', +'听', +'该', +'铁', +'价', +'严', +'首', +'底', +'液', +'官', +'德', +'随', +'病', +'苏', +'失', +'尔', +'死', +'讲', +'配', +'女', +'黄', +'推', +'显', +'谈', +'罪', +'神', +'艺', +'呢', +'席', +'含', +'企', +'望', +'密', +'批', +'营', +'项', +'防', +'举', +'球', +'英', +'氧', +'势', +'告', +'李', +'台', +'落', +'木', +'帮', +'轮', +'破', +'亚', +'师', +'围', +'注', +'远', +'字', +'材', +'排', +'供', +'河', +'态', +'封', +'另', +'施', +'减', +'树', +'溶', +'怎', +'止', +'案', +'言', +'士', +'均', +'武', +'固', +'叶', +'鱼', +'波', +'视', +'仅', +'费', +'紧', +'爱', +'左', +'章', +'早', +'朝', +'害', +'续', +'轻', +'服', +'试', +'食', +'充', +'兵', +'源', +'判', +'护', +'司', +'足', +'某', +'练', +'差', +'致', +'板', +'田', +'降', +'黑', +'犯', +'负', +'击', +'范', +'继', +'兴', +'似', +'余', +'坚', +'曲', +'输', +'修', +'故', +'城', +'夫', +'够', +'送', +'笔', +'船', +'占', +'右', +'财', +'吃', +'富', +'春', +'职', +'觉', +'汉', +'画', +'功', +'巴', +'跟', +'虽', +'杂', +'飞', +'检', +'吸', +'助', +'升', +'阳', +'互', +'初', +'创', +'抗', +'考', +'投', +'坏', +'策', +'古', +'径', +'换', +'未', +'跑', +'留', +'钢', +'曾', +'端', +'责', +'站', +'简', +'述', +'钱', +'副', +'尽', +'帝', +'射', +'草', +'冲', +'承', +'独', +'令', +'限', +'阿', +'宣', +'环', +'双', +'请', +'超', +'微', +'让', +'控', +'州', +'良', +'轴', +'找', +'否', +'纪', +'益', +'依', +'优', +'顶', +'础', +'载', +'倒', +'房', +'突', +'坐', +'粉', +'敌', +'略', +'客', +'袁', +'冷', +'胜', +'绝', +'析', +'块', +'剂', +'测', +'丝', +'协', +'诉', +'念', +'陈', +'仍', +'罗', +'盐', +'友', +'洋', +'错', +'苦', +'夜', +'刑', +'移', +'频', +'逐', +'靠', +'混', +'母', +'短', +'皮', +'终', +'聚', +'汽', +'村', +'云', +'哪', +'既', +'距', +'卫', +'停', +'烈', +'央', +'察', +'烧', +'迅', +'境', +'若', +'印', +'洲', +'刻', +'括', +'激', +'孔', +'搞', +'甚', +'室', +'待', +'核', +'校', +'散', +'侵', +'吧', +'甲', +'游', +'久', +'菜', +'味', +'旧', +'模', +'湖', +'货', +'损', +'预', +'阻', +'毫', +'普', +'稳', +'乙', +'妈', +'植', +'息', +'扩', +'银', +'语', +'挥', +'酒', +'守', +'拿', +'序', +'纸', +'医', +'缺', +'雨', +'吗', +'针', +'刘', +'啊', +'急', +'唱', +'误', +'训', +'愿', +'审', +'附', +'获', +'茶', +'鲜', +'粮', +'斤', +'孩', +'脱', +'硫', +'肥', +'善', +'龙', +'演', +'父', +'渐', +'血', +'欢', +'械', +'掌', +'歌', +'沙', +'刚', +'攻', +'谓', +'盾', +'讨', +'晚', +'粒', +'乱', +'燃', +'矛', +'乎', +'杀', +'药', +'宁', +'鲁', +'贵', +'钟', +'煤', +'读', +'班', +'伯', +'香', +'介', +'迫', +'句', +'丰', +'培', +'握', +'兰', +'担', +'弦', +'蛋', +'沉', +'假', +'穿', +'执', +'答', +'乐', +'谁', +'顺', +'烟', +'缩', +'征', +'脸', +'喜', +'松', +'脚', +'困', +'异', +'免', +'背', +'星', +'福', +'买', +'染', +'井', +'概', +'慢', +'怕', +'磁', +'倍', +'祖', +'皇', +'促', +'静', +'补', +'评', +'翻', +'肉', +'践', +'尼', +'衣', +'宽', +'扬', +'棉', +'希', +'伤', +'操', +'垂', +'秋', +'宜', +'氢', +'套', +'督', +'振', +'架', +'亮', +'末', +'宪', +'庆', +'编', +'牛', +'触', +'映', +'雷', +'销', +'诗', +'座', +'居', +'抓', +'裂', +'胞', +'呼', +'娘', +'景', +'威', +'绿', +'晶', +'厚', +'盟', +'衡', +'鸡', +'孙', +'延', +'危', +'胶', +'屋', +'乡', +'临', +'陆', +'顾', +'掉', +'呀', +'灯', +'岁', +'措', +'束', +'耐', +'剧', +'玉', +'赵', +'跳', +'哥', +'季', +'课', +'凯', +'胡', +'额', +'款', +'绍', +'卷', +'齐', +'伟', +'蒸', +'殖', +'永', +'宗', +'苗', +'川', +'炉', +'岩', +'弱', +'零', +'杨', +'奏', +'沿', +'露', +'杆', +'探', +'滑', +'镇', +'饭', +'浓', +'航', +'怀', +'赶', +'库', +'夺', +'伊', +'灵', +'税', +'途', +'灭', +'赛', +'归', +'召', +'鼓', +'播', +'盘', +'裁', +'险', +'康', +'唯', +'录', +'菌', +'纯', +'借', +'糖', +'盖', +'横', +'符', +'私', +'努', +'堂', +'域', +'枪', +'润', +'幅', +'哈', +'竟', +'熟', +'虫', +'泽', +'脑', +'壤', +'碳', +'欧', +'遍', +'侧', +'寨', +'敢', +'彻', +'虑', +'斜', +'薄', +'庭', +'纳', +'弹', +'饲', +'伸', +'折', +'麦', +'湿', +'暗', +'荷', +'瓦', +'塞', +'床', +'筑', +'恶', +'户', +'访', +'塔', +'奇', +'透', +'梁', +'刀', +'旋', +'迹', +'卡', +'氯', +'遇', +'份', +'毒', +'泥', +'退', +'洗', +'摆', +'灰', +'彩', +'卖', +'耗', +'夏', +'择', +'忙', +'铜', +'献', +'硬', +'予', +'繁', +'圈', +'雪', +'函', +'亦', +'抽', +'篇', +'阵', +'阴', +'丁', +'尺', +'追', +'堆', +'雄', +'迎', +'泛', +'爸', +'楼', +'避', +'谋', +'吨', +'野', +'猪', +'旗', +'累', +'偏', +'典', +'馆', +'索', +'秦', +'脂', +'潮', +'爷', +'豆', +'忽', +'托', +'惊', +'塑', +'遗', +'愈', +'朱', +'替', +'纤', +'粗', +'倾', +'尚', +'痛', +'楚', +'谢', +'奋', +'购', +'磨', +'君', +'池', +'旁', +'碎', +'骨', +'监', +'捕', +'弟', +'暴', +'割', +'贯', +'殊', +'释', +'词', +'亡', +'壁', +'顿', +'宝', +'午', +'尘', +'闻', +'揭', +'炮', +'残', +'冬', +'桥', +'妇', +'警', +'综', +'招', +'吴', +'付', +'浮', +'遭', +'徐', +'您', +'摇', +'谷', +'赞', +'箱', +'隔', +'订', +'男', +'吹', +'园', +'纷', +'唐', +'败', +'宋', +'玻', +'巨', +'耕', +'坦', +'荣', +'闭', +'湾', +'键', +'凡', +'驻', +'锅', +'救', +'恩', +'剥', +'凝', +'碱', +'齿', +'截', +'炼', +'麻', +'纺', +'禁', +'废', +'盛', +'版', +'缓', +'净', +'睛', +'昌', +'婚', +'涉', +'筒', +'嘴', +'插', +'岸', +'朗', +'庄', +'街', +'藏', +'姑', +'贸', +'腐', +'奴', +'啦', +'惯', +'乘', +'伙', +'恢', +'匀', +'纱', +'扎', +'辩', +'耳', +'彪', +'臣', +'亿', +'璃', +'抵', +'脉', +'秀', +'萨', +'俄', +'网', +'舞', +'店', +'喷', +'纵', +'寸', +'汗', +'挂', +'洪', +'贺', +'闪', +'柬', +'爆', +'烯', +'津', +'稻', +'墙', +'软', +'勇', +'像', +'滚', +'厘', +'蒙', +'芳', +'肯', +'坡', +'柱', +'荡', +'腿', +'仪', +'旅', +'尾', +'轧', +'冰', +'贡', +'登', +'黎', +'削', +'钻', +'勒', +'逃', +'障', +'氨', +'郭', +'峰', +'币', +'港', +'伏', +'轨', +'亩', +'毕', +'擦', +'莫', +'刺', +'浪', +'秘', +'援', +'株', +'健', +'售', +'股', +'岛', +'甘', +'泡', +'睡', +'童', +'铸', +'汤', +'阀', +'休', +'汇', +'舍', +'牧', +'绕', +'炸', +'哲', +'磷', +'绩', +'朋', +'淡', +'尖', +'启', +'陷', +'柴', +'呈', +'徒', +'颜', +'泪', +'稍', +'忘', +'泵', +'蓝', +'拖', +'洞', +'授', +'镜', +'辛', +'壮', +'锋', +'贫', +'虚', +'弯', +'摩', +'泰', +'幼', +'廷', +'尊', +'窗', +'纲', +'弄', +'隶', +'疑', +'氏', +'宫', +'姐', +'震', +'瑞', +'怪', +'尤', +'琴', +'循', +'描', +'膜', +'违', +'夹', +'腰', +'缘', +'珠', +'穷', +'森', +'枝', +'竹', +'沟', +'催', +'绳', +'忆', +'邦', +'剩', +'幸', +'浆', +'栏', +'拥', +'牙', +'贮', +'礼', +'滤', +'钠', +'纹', +'罢', +'拍', +'咱', +'喊', +'袖', +'埃', +'勤', +'罚', +'焦', +'潜', +'伍', +'墨', +'欲', +'缝', +'姓', +'刊', +'饱', +'仿', +'奖', +'铝', +'鬼', +'丽', +'跨', +'默', +'挖', +'链', +'扫', +'喝', +'袋', +'炭', +'污', +'幕', +'诸', +'弧', +'励', +'梅', +'奶', +'洁', +'灾', +'舟', +'鉴', +'苯', +'讼', +'抱', +'毁', +'懂', +'寒', +'智', +'埔', +'寄', +'届', +'跃', +'渡', +'挑', +'丹', +'艰', +'贝', +'碰', +'拔', +'爹', +'戴', +'码', +'梦', +'芽', +'熔', +'赤', +'渔', +'哭', +'敬', +'颗', +'奔', +'铅', +'仲', +'虎', +'稀', +'妹', +'乏', +'珍', +'申', +'桌', +'遵', +'允', +'隆', +'螺', +'仓', +'魏', +'锐', +'晓', +'氮', +'兼', +'隐', +'碍', +'赫', +'拨', +'忠', +'肃', +'缸', +'牵', +'抢', +'博', +'巧', +'壳', +'兄', +'杜', +'讯', +'诚', +'碧', +'祥', +'柯', +'页', +'巡', +'矩', +'悲', +'灌', +'龄', +'伦', +'票', +'寻', +'桂', +'铺', +'圣', +'恐', +'恰', +'郑', +'趣', +'抬', +'荒', +'腾', +'贴', +'柔', +'滴', +'猛', +'阔', +'辆', +'妻', +'填', +'撤', +'储', +'签', +'闹', +'扰', +'紫', +'砂', +'递', +'戏', +'吊', +'陶', +'伐', +'喂', +'疗', +'瓶', +'婆', +'抚', +'臂', +'摸', +'忍', +'虾', +'蜡', +'邻', +'胸', +'巩', +'挤', +'偶', +'弃', +'槽', +'劲', +'乳', +'邓', +'吉', +'仁', +'烂', +'砖', +'租', +'乌', +'舰', +'伴', +'瓜', +'浅', +'丙', +'暂', +'燥', +'橡', +'柳', +'迷', +'暖', +'牌', +'秧', +'胆', +'详', +'簧', +'踏', +'瓷', +'谱', +'呆', +'宾', +'糊', +'洛', +'辉', +'愤', +'竞', +'隙', +'怒', +'粘', +'乃', +'绪', +'肩', +'籍', +'敏', +'涂', +'熙', +'皆', +'侦', +'悬', +'掘', +'享', +'纠', +'醒', +'狂', +'锁', +'淀', +'恨', +'牲', +'霸', +'爬', +'赏', +'逆', +'玩', +'陵', +'祝', +'秒', +'浙', +'貌', +'役', +'彼', +'悉', +'鸭', +'趋', +'凤', +'晨', +'畜', +'辈', +'秩', +'卵', +'署', +'梯', +'炎', +'滩', +'棋', +'驱', +'筛', +'峡', +'冒', +'啥', +'寿', +'译', +'浸', +'泉', +'帽', +'迟', +'硅', +'疆', +'贷', +'漏', +'稿', +'冠', +'嫩', +'胁', +'芯', +'牢', +'叛', +'蚀', +'奥', +'鸣', +'岭', +'羊', +'凭', +'串', +'塘', +'绘', +'酵', +'融', +'盆', +'锡', +'庙', +'筹', +'冻', +'辅', +'摄', +'袭', +'筋', +'拒', +'僚', +'旱', +'钾', +'鸟', +'漆', +'沈', +'眉', +'疏', +'添', +'棒', +'穗', +'硝', +'韩', +'逼', +'扭', +'侨', +'凉', +'挺', +'碗', +'栽', +'炒', +'杯', +'患', +'馏', +'劝', +'豪', +'辽', +'勃', +'鸿', +'旦', +'吏', +'拜', +'狗', +'埋', +'辊', +'掩', +'饮', +'搬', +'骂', +'辞', +'勾', +'扣', +'估', +'蒋', +'绒', +'雾', +'丈', +'朵', +'姆', +'拟', +'宇', +'辑', +'陕', +'雕', +'偿', +'蓄', +'崇', +'剪', +'倡', +'厅', +'咬', +'驶', +'薯', +'刷', +'斥', +'番', +'赋', +'奉', +'佛', +'浇', +'漫', +'曼', +'扇', +'钙', +'桃', +'扶', +'仔', +'返', +'俗', +'亏', +'腔', +'鞋', +'棱', +'覆', +'框', +'悄', +'叔', +'撞', +'骗', +'勘', +'旺', +'沸', +'孤', +'吐', +'孟', +'渠', +'屈', +'疾', +'妙', +'惜', +'仰', +'狠', +'胀', +'谐', +'抛', +'霉', +'桑', +'岗', +'嘛', +'衰', +'盗', +'渗', +'脏', +'赖', +'涌', +'甜', +'曹', +'阅', +'肌', +'哩', +'厉', +'烃', +'纬', +'毅', +'昨', +'伪', +'症', +'煮', +'叹', +'钉', +'搭', +'茎', +'笼', +'酷', +'偷', +'弓', +'锥', +'恒', +'杰', +'坑', +'鼻', +'翼', +'纶', +'叙', +'狱', +'逮', +'罐', +'络', +'棚', +'抑', +'膨', +'蔬', +'寺', +'骤', +'穆', +'冶', +'枯', +'册', +'尸', +'凸', +'绅', +'坯', +'牺', +'焰', +'轰', +'欣', +'晋', +'瘦', +'御', +'锭', +'锦', +'丧', +'旬', +'锻', +'垄', +'搜', +'扑', +'邀', +'亭', +'酯', +'迈', +'舒', +'脆', +'酶', +'闲', +'忧', +'酚', +'顽', +'羽', +'涨', +'卸', +'仗', +'陪', +'辟', +'惩', +'杭', +'姚', +'肚', +'捉', +'飘', +'漂', +'昆', +'欺', +'吾', +'郎', +'烷', +'汁', +'呵', +'饰', +'萧', +'雅', +'邮', +'迁', +'燕', +'撒', +'姻', +'赴', +'宴', +'烦', +'债', +'帐', +'斑', +'铃', +'旨', +'醇', +'董', +'饼', +'雏', +'姿', +'拌', +'傅', +'腹', +'妥', +'揉', +'贤', +'拆', +'歪', +'葡', +'胺', +'丢', +'浩', +'徽', +'昂', +'垫', +'挡', +'览', +'贪', +'慰', +'缴', +'汪', +'慌', +'冯', +'诺', +'姜', +'谊', +'凶', +'劣', +'诬', +'耀', +'昏', +'躺', +'盈', +'骑', +'乔', +'溪', +'丛', +'卢', +'抹', +'闷', +'咨', +'刮', +'驾', +'缆', +'悟', +'摘', +'铒', +'掷', +'颇', +'幻', +'柄', +'惠', +'惨', +'佳', +'仇', +'腊', +'窝', +'涤', +'剑', +'瞧', +'堡', +'泼', +'葱', +'罩', +'霍', +'捞', +'胎', +'苍', +'滨', +'俩', +'捅', +'湘', +'砍', +'霞', +'邵', +'萄', +'疯', +'淮', +'遂', +'熊', +'粪', +'烘', +'宿', +'档', +'戈', +'驳', +'嫂', +'裕', +'徙', +'箭', +'捐', +'肠', +'撑', +'晒', +'辨', +'殿', +'莲', +'摊', +'搅', +'酱', +'屏', +'疫', +'哀', +'蔡', +'堵', +'沫', +'皱', +'畅', +'叠', +'阁', +'莱', +'敲', +'辖', +'钩', +'痕', +'坝', +'巷', +'饿', +'祸', +'丘', +'玄', +'溜', +'曰', +'逻', +'彭', +'尝', +'卿', +'妨', +'艇', +'吞', +'韦', +'怨', +'矮', +'歇' +] diff --git a/torba/words/chinese_simplified.txt b/torba/words/chinese_simplified.txt deleted file mode 100644 index b90f1ed85..000000000 --- a/torba/words/chinese_simplified.txt +++ /dev/null @@ -1,2048 +0,0 @@ -的 -一 -是 -在 -不 -了 -有 -和 -人 -这 -中 -大 -为 -上 -个 -国 -我 -以 -要 -他 -时 -来 -用 -们 -生 -到 -作 -地 -于 -出 -就 -分 -对 -成 -会 -可 -主 -发 -年 -动 -同 -工 -也 -能 -下 -过 -子 -说 -产 -种 -面 -而 -方 -后 -多 -定 -行 -学 -法 -所 -民 -得 -经 -十 -三 -之 -进 -着 -等 -部 -度 -家 -电 -力 -里 -如 -水 -化 -高 -自 -二 -理 -起 -小 -物 -现 -实 -加 -量 -都 -两 -体 -制 -机 -当 -使 -点 -从 -业 -本 -去 -把 -性 -好 -应 -开 -它 -合 -还 -因 -由 -其 -些 -然 -前 -外 -天 -政 -四 -日 -那 -社 -义 -事 -平 -形 -相 -全 -表 -间 -样 -与 -关 -各 -重 -新 -线 -内 -数 -正 -心 -反 -你 -明 -看 -原 -又 -么 -利 -比 -或 -但 -质 -气 -第 -向 -道 -命 -此 -变 -条 -只 -没 -结 -解 -问 -意 -建 -月 -公 -无 -系 -军 -很 -情 -者 -最 -立 -代 -想 -已 -通 -并 -提 -直 -题 -党 -程 -展 -五 -果 -料 -象 -员 -革 -位 -入 -常 -文 -总 -次 -品 -式 -活 -设 -及 -管 -特 -件 -长 -求 -老 -头 -基 -资 -边 -流 -路 -级 -少 -图 -山 -统 -接 -知 -较 -将 -组 -见 -计 -别 -她 -手 -角 -期 -根 -论 -运 -农 -指 -几 -九 -区 -强 -放 -决 -西 -被 -干 -做 -必 -战 -先 -回 -则 -任 -取 -据 -处 -队 -南 -给 -色 -光 -门 -即 -保 -治 -北 -造 -百 -规 -热 -领 -七 -海 -口 -东 -导 -器 -压 -志 -世 -金 -增 -争 -济 -阶 -油 -思 -术 -极 -交 -受 -联 -什 -认 -六 -共 -权 -收 -证 -改 -清 -美 -再 -采 -转 -更 -单 -风 -切 -打 -白 -教 -速 -花 -带 -安 -场 -身 -车 -例 -真 -务 -具 -万 -每 -目 -至 -达 -走 -积 -示 -议 -声 -报 -斗 -完 -类 -八 -离 -华 -名 -确 -才 -科 -张 -信 -马 -节 -话 -米 -整 -空 -元 -况 -今 -集 -温 -传 -土 -许 -步 -群 -广 -石 -记 -需 -段 -研 -界 -拉 -林 -律 -叫 -且 -究 -观 -越 -织 -装 -影 -算 -低 -持 -音 -众 -书 -布 -复 -容 -儿 -须 -际 -商 -非 -验 -连 -断 -深 -难 -近 -矿 -千 -周 -委 -素 -技 -备 -半 -办 -青 -省 -列 -习 -响 -约 -支 -般 -史 -感 -劳 -便 -团 -往 -酸 -历 -市 -克 -何 -除 -消 -构 -府 -称 -太 -准 -精 -值 -号 -率 -族 -维 -划 -选 -标 -写 -存 -候 -毛 -亲 -快 -效 -斯 -院 -查 -江 -型 -眼 -王 -按 -格 -养 -易 -置 -派 -层 -片 -始 -却 -专 -状 -育 -厂 -京 -识 -适 -属 -圆 -包 -火 -住 -调 -满 -县 -局 -照 -参 -红 -细 -引 -听 -该 -铁 -价 -严 -首 -底 -液 -官 -德 -随 -病 -苏 -失 -尔 -死 -讲 -配 -女 -黄 -推 -显 -谈 -罪 -神 -艺 -呢 -席 -含 -企 -望 -密 -批 -营 -项 -防 -举 -球 -英 -氧 -势 -告 -李 -台 -落 -木 -帮 -轮 -破 -亚 -师 -围 -注 -远 -字 -材 -排 -供 -河 -态 -封 -另 -施 -减 -树 -溶 -怎 -止 -案 -言 -士 -均 -武 -固 -叶 -鱼 -波 -视 -仅 -费 -紧 -爱 -左 -章 -早 -朝 -害 -续 -轻 -服 -试 -食 -充 -兵 -源 -判 -护 -司 -足 -某 -练 -差 -致 -板 -田 -降 -黑 -犯 -负 -击 -范 -继 -兴 -似 -余 -坚 -曲 -输 -修 -故 -城 -夫 -够 -送 -笔 -船 -占 -右 -财 -吃 -富 -春 -职 -觉 -汉 -画 -功 -巴 -跟 -虽 -杂 -飞 -检 -吸 -助 -升 -阳 -互 -初 -创 -抗 -考 -投 -坏 -策 -古 -径 -换 -未 -跑 -留 -钢 -曾 -端 -责 -站 -简 -述 -钱 -副 -尽 -帝 -射 -草 -冲 -承 -独 -令 -限 -阿 -宣 -环 -双 -请 -超 -微 -让 -控 -州 -良 -轴 -找 -否 -纪 -益 -依 -优 -顶 -础 -载 -倒 -房 -突 -坐 -粉 -敌 -略 -客 -袁 -冷 -胜 -绝 -析 -块 -剂 -测 -丝 -协 -诉 -念 -陈 -仍 -罗 -盐 -友 -洋 -错 -苦 -夜 -刑 -移 -频 -逐 -靠 -混 -母 -短 -皮 -终 -聚 -汽 -村 -云 -哪 -既 -距 -卫 -停 -烈 -央 -察 -烧 -迅 -境 -若 -印 -洲 -刻 -括 -激 -孔 -搞 -甚 -室 -待 -核 -校 -散 -侵 -吧 -甲 -游 -久 -菜 -味 -旧 -模 -湖 -货 -损 -预 -阻 -毫 -普 -稳 -乙 -妈 -植 -息 -扩 -银 -语 -挥 -酒 -守 -拿 -序 -纸 -医 -缺 -雨 -吗 -针 -刘 -啊 -急 -唱 -误 -训 -愿 -审 -附 -获 -茶 -鲜 -粮 -斤 -孩 -脱 -硫 -肥 -善 -龙 -演 -父 -渐 -血 -欢 -械 -掌 -歌 -沙 -刚 -攻 -谓 -盾 -讨 -晚 -粒 -乱 -燃 -矛 -乎 -杀 -药 -宁 -鲁 -贵 -钟 -煤 -读 -班 -伯 -香 -介 -迫 -句 -丰 -培 -握 -兰 -担 -弦 -蛋 -沉 -假 -穿 -执 -答 -乐 -谁 -顺 -烟 -缩 -征 -脸 -喜 -松 -脚 -困 -异 -免 -背 -星 -福 -买 -染 -井 -概 -慢 -怕 -磁 -倍 -祖 -皇 -促 -静 -补 -评 -翻 -肉 -践 -尼 -衣 -宽 -扬 -棉 -希 -伤 -操 -垂 -秋 -宜 -氢 -套 -督 -振 -架 -亮 -末 -宪 -庆 -编 -牛 -触 -映 -雷 -销 -诗 -座 -居 -抓 -裂 -胞 -呼 -娘 -景 -威 -绿 -晶 -厚 -盟 -衡 -鸡 -孙 -延 -危 -胶 -屋 -乡 -临 -陆 -顾 -掉 -呀 -灯 -岁 -措 -束 -耐 -剧 -玉 -赵 -跳 -哥 -季 -课 -凯 -胡 -额 -款 -绍 -卷 -齐 -伟 -蒸 -殖 -永 -宗 -苗 -川 -炉 -岩 -弱 -零 -杨 -奏 -沿 -露 -杆 -探 -滑 -镇 -饭 -浓 -航 -怀 -赶 -库 -夺 -伊 -灵 -税 -途 -灭 -赛 -归 -召 -鼓 -播 -盘 -裁 -险 -康 -唯 -录 -菌 -纯 -借 -糖 -盖 -横 -符 -私 -努 -堂 -域 -枪 -润 -幅 -哈 -竟 -熟 -虫 -泽 -脑 -壤 -碳 -欧 -遍 -侧 -寨 -敢 -彻 -虑 -斜 -薄 -庭 -纳 -弹 -饲 -伸 -折 -麦 -湿 -暗 -荷 -瓦 -塞 -床 -筑 -恶 -户 -访 -塔 -奇 -透 -梁 -刀 -旋 -迹 -卡 -氯 -遇 -份 -毒 -泥 -退 -洗 -摆 -灰 -彩 -卖 -耗 -夏 -择 -忙 -铜 -献 -硬 -予 -繁 -圈 -雪 -函 -亦 -抽 -篇 -阵 -阴 -丁 -尺 -追 -堆 -雄 -迎 -泛 -爸 -楼 -避 -谋 -吨 -野 -猪 -旗 -累 -偏 -典 -馆 -索 -秦 -脂 -潮 -爷 -豆 -忽 -托 -惊 -塑 -遗 -愈 -朱 -替 -纤 -粗 -倾 -尚 -痛 -楚 -谢 -奋 -购 -磨 -君 -池 -旁 -碎 -骨 -监 -捕 -弟 -暴 -割 -贯 -殊 -释 -词 -亡 -壁 -顿 -宝 -午 -尘 -闻 -揭 -炮 -残 -冬 -桥 -妇 -警 -综 -招 -吴 -付 -浮 -遭 -徐 -您 -摇 -谷 -赞 -箱 -隔 -订 -男 -吹 -园 -纷 -唐 -败 -宋 -玻 -巨 -耕 -坦 -荣 -闭 -湾 -键 -凡 -驻 -锅 -救 -恩 -剥 -凝 -碱 -齿 -截 -炼 -麻 -纺 -禁 -废 -盛 -版 -缓 -净 -睛 -昌 -婚 -涉 -筒 -嘴 -插 -岸 -朗 -庄 -街 -藏 -姑 -贸 -腐 -奴 -啦 -惯 -乘 -伙 -恢 -匀 -纱 -扎 -辩 -耳 -彪 -臣 -亿 -璃 -抵 -脉 -秀 -萨 -俄 -网 -舞 -店 -喷 -纵 -寸 -汗 -挂 -洪 -贺 -闪 -柬 -爆 -烯 -津 -稻 -墙 -软 -勇 -像 -滚 -厘 -蒙 -芳 -肯 -坡 -柱 -荡 -腿 -仪 -旅 -尾 -轧 -冰 -贡 -登 -黎 -削 -钻 -勒 -逃 -障 -氨 -郭 -峰 -币 -港 -伏 -轨 -亩 -毕 -擦 -莫 -刺 -浪 -秘 -援 -株 -健 -售 -股 -岛 -甘 -泡 -睡 -童 -铸 -汤 -阀 -休 -汇 -舍 -牧 -绕 -炸 -哲 -磷 -绩 -朋 -淡 -尖 -启 -陷 -柴 -呈 -徒 -颜 -泪 -稍 -忘 -泵 -蓝 -拖 -洞 -授 -镜 -辛 -壮 -锋 -贫 -虚 -弯 -摩 -泰 -幼 -廷 -尊 -窗 -纲 -弄 -隶 -疑 -氏 -宫 -姐 -震 -瑞 -怪 -尤 -琴 -循 -描 -膜 -违 -夹 -腰 -缘 -珠 -穷 -森 -枝 -竹 -沟 -催 -绳 -忆 -邦 -剩 -幸 -浆 -栏 -拥 -牙 -贮 -礼 -滤 -钠 -纹 -罢 -拍 -咱 -喊 -袖 -埃 -勤 -罚 -焦 -潜 -伍 -墨 -欲 -缝 -姓 -刊 -饱 -仿 -奖 -铝 -鬼 -丽 -跨 -默 -挖 -链 -扫 -喝 -袋 -炭 -污 -幕 -诸 -弧 -励 -梅 -奶 -洁 -灾 -舟 -鉴 -苯 -讼 -抱 -毁 -懂 -寒 -智 -埔 -寄 -届 -跃 -渡 -挑 -丹 -艰 -贝 -碰 -拔 -爹 -戴 -码 -梦 -芽 -熔 -赤 -渔 -哭 -敬 -颗 -奔 -铅 -仲 -虎 -稀 -妹 -乏 -珍 -申 -桌 -遵 -允 -隆 -螺 -仓 -魏 -锐 -晓 -氮 -兼 -隐 -碍 -赫 -拨 -忠 -肃 -缸 -牵 -抢 -博 -巧 -壳 -兄 -杜 -讯 -诚 -碧 -祥 -柯 -页 -巡 -矩 -悲 -灌 -龄 -伦 -票 -寻 -桂 -铺 -圣 -恐 -恰 -郑 -趣 -抬 -荒 -腾 -贴 -柔 -滴 -猛 -阔 -辆 -妻 -填 -撤 -储 -签 -闹 -扰 -紫 -砂 -递 -戏 -吊 -陶 -伐 -喂 -疗 -瓶 -婆 -抚 -臂 -摸 -忍 -虾 -蜡 -邻 -胸 -巩 -挤 -偶 -弃 -槽 -劲 -乳 -邓 -吉 -仁 -烂 -砖 -租 -乌 -舰 -伴 -瓜 -浅 -丙 -暂 -燥 -橡 -柳 -迷 -暖 -牌 -秧 -胆 -详 -簧 -踏 -瓷 -谱 -呆 -宾 -糊 -洛 -辉 -愤 -竞 -隙 -怒 -粘 -乃 -绪 -肩 -籍 -敏 -涂 -熙 -皆 -侦 -悬 -掘 -享 -纠 -醒 -狂 -锁 -淀 -恨 -牲 -霸 -爬 -赏 -逆 -玩 -陵 -祝 -秒 -浙 -貌 -役 -彼 -悉 -鸭 -趋 -凤 -晨 -畜 -辈 -秩 -卵 -署 -梯 -炎 -滩 -棋 -驱 -筛 -峡 -冒 -啥 -寿 -译 -浸 -泉 -帽 -迟 -硅 -疆 -贷 -漏 -稿 -冠 -嫩 -胁 -芯 -牢 -叛 -蚀 -奥 -鸣 -岭 -羊 -凭 -串 -塘 -绘 -酵 -融 -盆 -锡 -庙 -筹 -冻 -辅 -摄 -袭 -筋 -拒 -僚 -旱 -钾 -鸟 -漆 -沈 -眉 -疏 -添 -棒 -穗 -硝 -韩 -逼 -扭 -侨 -凉 -挺 -碗 -栽 -炒 -杯 -患 -馏 -劝 -豪 -辽 -勃 -鸿 -旦 -吏 -拜 -狗 -埋 -辊 -掩 -饮 -搬 -骂 -辞 -勾 -扣 -估 -蒋 -绒 -雾 -丈 -朵 -姆 -拟 -宇 -辑 -陕 -雕 -偿 -蓄 -崇 -剪 -倡 -厅 -咬 -驶 -薯 -刷 -斥 -番 -赋 -奉 -佛 -浇 -漫 -曼 -扇 -钙 -桃 -扶 -仔 -返 -俗 -亏 -腔 -鞋 -棱 -覆 -框 -悄 -叔 -撞 -骗 -勘 -旺 -沸 -孤 -吐 -孟 -渠 -屈 -疾 -妙 -惜 -仰 -狠 -胀 -谐 -抛 -霉 -桑 -岗 -嘛 -衰 -盗 -渗 -脏 -赖 -涌 -甜 -曹 -阅 -肌 -哩 -厉 -烃 -纬 -毅 -昨 -伪 -症 -煮 -叹 -钉 -搭 -茎 -笼 -酷 -偷 -弓 -锥 -恒 -杰 -坑 -鼻 -翼 -纶 -叙 -狱 -逮 -罐 -络 -棚 -抑 -膨 -蔬 -寺 -骤 -穆 -冶 -枯 -册 -尸 -凸 -绅 -坯 -牺 -焰 -轰 -欣 -晋 -瘦 -御 -锭 -锦 -丧 -旬 -锻 -垄 -搜 -扑 -邀 -亭 -酯 -迈 -舒 -脆 -酶 -闲 -忧 -酚 -顽 -羽 -涨 -卸 -仗 -陪 -辟 -惩 -杭 -姚 -肚 -捉 -飘 -漂 -昆 -欺 -吾 -郎 -烷 -汁 -呵 -饰 -萧 -雅 -邮 -迁 -燕 -撒 -姻 -赴 -宴 -烦 -债 -帐 -斑 -铃 -旨 -醇 -董 -饼 -雏 -姿 -拌 -傅 -腹 -妥 -揉 -贤 -拆 -歪 -葡 -胺 -丢 -浩 -徽 -昂 -垫 -挡 -览 -贪 -慰 -缴 -汪 -慌 -冯 -诺 -姜 -谊 -凶 -劣 -诬 -耀 -昏 -躺 -盈 -骑 -乔 -溪 -丛 -卢 -抹 -闷 -咨 -刮 -驾 -缆 -悟 -摘 -铒 -掷 -颇 -幻 -柄 -惠 -惨 -佳 -仇 -腊 -窝 -涤 -剑 -瞧 -堡 -泼 -葱 -罩 -霍 -捞 -胎 -苍 -滨 -俩 -捅 -湘 -砍 -霞 -邵 -萄 -疯 -淮 -遂 -熊 -粪 -烘 -宿 -档 -戈 -驳 -嫂 -裕 -徙 -箭 -捐 -肠 -撑 -晒 -辨 -殿 -莲 -摊 -搅 -酱 -屏 -疫 -哀 -蔡 -堵 -沫 -皱 -畅 -叠 -阁 -莱 -敲 -辖 -钩 -痕 -坝 -巷 -饿 -祸 -丘 -玄 -溜 -曰 -逻 -彭 -尝 -卿 -妨 -艇 -吞 -韦 -怨 -矮 -歇 diff --git a/torba/words/english.py b/torba/words/english.py new file mode 100644 index 000000000..df2eef708 --- /dev/null +++ b/torba/words/english.py @@ -0,0 +1,2050 @@ +words = [ +'abandon', +'ability', +'able', +'about', +'above', +'absent', +'absorb', +'abstract', +'absurd', +'abuse', +'access', +'accident', +'account', +'accuse', +'achieve', +'acid', +'acoustic', +'acquire', +'across', +'act', +'action', +'actor', +'actress', +'actual', +'adapt', +'add', +'addict', +'address', +'adjust', +'admit', +'adult', +'advance', +'advice', +'aerobic', +'affair', +'afford', +'afraid', +'again', +'age', +'agent', +'agree', +'ahead', +'aim', +'air', +'airport', +'aisle', +'alarm', +'album', +'alcohol', +'alert', +'alien', +'all', +'alley', +'allow', +'almost', +'alone', +'alpha', +'already', +'also', +'alter', +'always', +'amateur', +'amazing', +'among', +'amount', +'amused', +'analyst', +'anchor', +'ancient', +'anger', +'angle', +'angry', +'animal', +'ankle', +'announce', +'annual', +'another', +'answer', +'antenna', +'antique', +'anxiety', +'any', +'apart', +'apology', +'appear', +'apple', +'approve', +'april', +'arch', +'arctic', +'area', +'arena', +'argue', +'arm', +'armed', +'armor', +'army', +'around', +'arrange', +'arrest', +'arrive', +'arrow', +'art', +'artefact', +'artist', +'artwork', +'ask', +'aspect', +'assault', +'asset', +'assist', +'assume', +'asthma', +'athlete', +'atom', +'attack', +'attend', +'attitude', +'attract', +'auction', +'audit', +'august', +'aunt', +'author', +'auto', +'autumn', +'average', +'avocado', +'avoid', +'awake', +'aware', +'away', +'awesome', +'awful', +'awkward', +'axis', +'baby', +'bachelor', +'bacon', +'badge', +'bag', +'balance', +'balcony', +'ball', +'bamboo', +'banana', +'banner', +'bar', +'barely', +'bargain', +'barrel', +'base', +'basic', +'basket', +'battle', +'beach', +'bean', +'beauty', +'because', +'become', +'beef', +'before', +'begin', +'behave', +'behind', +'believe', +'below', +'belt', +'bench', +'benefit', +'best', +'betray', +'better', +'between', +'beyond', +'bicycle', +'bid', +'bike', +'bind', +'biology', +'bird', +'birth', +'bitter', +'black', +'blade', +'blame', +'blanket', +'blast', +'bleak', +'bless', +'blind', +'blood', +'blossom', +'blouse', +'blue', +'blur', +'blush', +'board', +'boat', +'body', +'boil', +'bomb', +'bone', +'bonus', +'book', +'boost', +'border', +'boring', +'borrow', +'boss', +'bottom', +'bounce', +'box', +'boy', +'bracket', +'brain', +'brand', +'brass', +'brave', +'bread', +'breeze', +'brick', +'bridge', +'brief', +'bright', +'bring', +'brisk', +'broccoli', +'broken', +'bronze', +'broom', +'brother', +'brown', +'brush', +'bubble', +'buddy', +'budget', +'buffalo', +'build', +'bulb', +'bulk', +'bullet', +'bundle', +'bunker', +'burden', +'burger', +'burst', +'bus', +'business', +'busy', +'butter', +'buyer', +'buzz', +'cabbage', +'cabin', +'cable', +'cactus', +'cage', +'cake', +'call', +'calm', +'camera', +'camp', +'can', +'canal', +'cancel', +'candy', +'cannon', +'canoe', +'canvas', +'canyon', +'capable', +'capital', +'captain', +'car', +'carbon', +'card', +'cargo', +'carpet', +'carry', +'cart', +'case', +'cash', +'casino', +'castle', +'casual', +'cat', +'catalog', +'catch', +'category', +'cattle', +'caught', +'cause', +'caution', +'cave', +'ceiling', +'celery', +'cement', +'census', +'century', +'cereal', +'certain', +'chair', +'chalk', +'champion', +'change', +'chaos', +'chapter', +'charge', +'chase', +'chat', +'cheap', +'check', +'cheese', +'chef', +'cherry', +'chest', +'chicken', +'chief', +'child', +'chimney', +'choice', +'choose', +'chronic', +'chuckle', +'chunk', +'churn', +'cigar', +'cinnamon', +'circle', +'citizen', +'city', +'civil', +'claim', +'clap', +'clarify', +'claw', +'clay', +'clean', +'clerk', +'clever', +'click', +'client', +'cliff', +'climb', +'clinic', +'clip', +'clock', +'clog', +'close', +'cloth', +'cloud', +'clown', +'club', +'clump', +'cluster', +'clutch', +'coach', +'coast', +'coconut', +'code', +'coffee', +'coil', +'coin', +'collect', +'color', +'column', +'combine', +'come', +'comfort', +'comic', +'common', +'company', +'concert', +'conduct', +'confirm', +'congress', +'connect', +'consider', +'control', +'convince', +'cook', +'cool', +'copper', +'copy', +'coral', +'core', +'corn', +'correct', +'cost', +'cotton', +'couch', +'country', +'couple', +'course', +'cousin', +'cover', +'coyote', +'crack', +'cradle', +'craft', +'cram', +'crane', +'crash', +'crater', +'crawl', +'crazy', +'cream', +'credit', +'creek', +'crew', +'cricket', +'crime', +'crisp', +'critic', +'crop', +'cross', +'crouch', +'crowd', +'crucial', +'cruel', +'cruise', +'crumble', +'crunch', +'crush', +'cry', +'crystal', +'cube', +'culture', +'cup', +'cupboard', +'curious', +'current', +'curtain', +'curve', +'cushion', +'custom', +'cute', +'cycle', +'dad', +'damage', +'damp', +'dance', +'danger', +'daring', +'dash', +'daughter', +'dawn', +'day', +'deal', +'debate', +'debris', +'decade', +'december', +'decide', +'decline', +'decorate', +'decrease', +'deer', +'defense', +'define', +'defy', +'degree', +'delay', +'deliver', +'demand', +'demise', +'denial', +'dentist', +'deny', +'depart', +'depend', +'deposit', +'depth', +'deputy', +'derive', +'describe', +'desert', +'design', +'desk', +'despair', +'destroy', +'detail', +'detect', +'develop', +'device', +'devote', +'diagram', +'dial', +'diamond', +'diary', +'dice', +'diesel', +'diet', +'differ', +'digital', +'dignity', +'dilemma', +'dinner', +'dinosaur', +'direct', +'dirt', +'disagree', +'discover', +'disease', +'dish', +'dismiss', +'disorder', +'display', +'distance', +'divert', +'divide', +'divorce', +'dizzy', +'doctor', +'document', +'dog', +'doll', +'dolphin', +'domain', +'donate', +'donkey', +'donor', +'door', +'dose', +'double', +'dove', +'draft', +'dragon', +'drama', +'drastic', +'draw', +'dream', +'dress', +'drift', +'drill', +'drink', +'drip', +'drive', +'drop', +'drum', +'dry', +'duck', +'dumb', +'dune', +'during', +'dust', +'dutch', +'duty', +'dwarf', +'dynamic', +'eager', +'eagle', +'early', +'earn', +'earth', +'easily', +'east', +'easy', +'echo', +'ecology', +'economy', +'edge', +'edit', +'educate', +'effort', +'egg', +'eight', +'either', +'elbow', +'elder', +'electric', +'elegant', +'element', +'elephant', +'elevator', +'elite', +'else', +'embark', +'embody', +'embrace', +'emerge', +'emotion', +'employ', +'empower', +'empty', +'enable', +'enact', +'end', +'endless', +'endorse', +'enemy', +'energy', +'enforce', +'engage', +'engine', +'enhance', +'enjoy', +'enlist', +'enough', +'enrich', +'enroll', +'ensure', +'enter', +'entire', +'entry', +'envelope', +'episode', +'equal', +'equip', +'era', +'erase', +'erode', +'erosion', +'error', +'erupt', +'escape', +'essay', +'essence', +'estate', +'eternal', +'ethics', +'evidence', +'evil', +'evoke', +'evolve', +'exact', +'example', +'excess', +'exchange', +'excite', +'exclude', +'excuse', +'execute', +'exercise', +'exhaust', +'exhibit', +'exile', +'exist', +'exit', +'exotic', +'expand', +'expect', +'expire', +'explain', +'expose', +'express', +'extend', +'extra', +'eye', +'eyebrow', +'fabric', +'face', +'faculty', +'fade', +'faint', +'faith', +'fall', +'false', +'fame', +'family', +'famous', +'fan', +'fancy', +'fantasy', +'farm', +'fashion', +'fat', +'fatal', +'father', +'fatigue', +'fault', +'favorite', +'feature', +'february', +'federal', +'fee', +'feed', +'feel', +'female', +'fence', +'festival', +'fetch', +'fever', +'few', +'fiber', +'fiction', +'field', +'figure', +'file', +'film', +'filter', +'final', +'find', +'fine', +'finger', +'finish', +'fire', +'firm', +'first', +'fiscal', +'fish', +'fit', +'fitness', +'fix', +'flag', +'flame', +'flash', +'flat', +'flavor', +'flee', +'flight', +'flip', +'float', +'flock', +'floor', +'flower', +'fluid', +'flush', +'fly', +'foam', +'focus', +'fog', +'foil', +'fold', +'follow', +'food', +'foot', +'force', +'forest', +'forget', +'fork', +'fortune', +'forum', +'forward', +'fossil', +'foster', +'found', +'fox', +'fragile', +'frame', +'frequent', +'fresh', +'friend', +'fringe', +'frog', +'front', +'frost', +'frown', +'frozen', +'fruit', +'fuel', +'fun', +'funny', +'furnace', +'fury', +'future', +'gadget', +'gain', +'galaxy', +'gallery', +'game', +'gap', +'garage', +'garbage', +'garden', +'garlic', +'garment', +'gas', +'gasp', +'gate', +'gather', +'gauge', +'gaze', +'general', +'genius', +'genre', +'gentle', +'genuine', +'gesture', +'ghost', +'giant', +'gift', +'giggle', +'ginger', +'giraffe', +'girl', +'give', +'glad', +'glance', +'glare', +'glass', +'glide', +'glimpse', +'globe', +'gloom', +'glory', +'glove', +'glow', +'glue', +'goat', +'goddess', +'gold', +'good', +'goose', +'gorilla', +'gospel', +'gossip', +'govern', +'gown', +'grab', +'grace', +'grain', +'grant', +'grape', +'grass', +'gravity', +'great', +'green', +'grid', +'grief', +'grit', +'grocery', +'group', +'grow', +'grunt', +'guard', +'guess', +'guide', +'guilt', +'guitar', +'gun', +'gym', +'habit', +'hair', +'half', +'hammer', +'hamster', +'hand', +'happy', +'harbor', +'hard', +'harsh', +'harvest', +'hat', +'have', +'hawk', +'hazard', +'head', +'health', +'heart', +'heavy', +'hedgehog', +'height', +'hello', +'helmet', +'help', +'hen', +'hero', +'hidden', +'high', +'hill', +'hint', +'hip', +'hire', +'history', +'hobby', +'hockey', +'hold', +'hole', +'holiday', +'hollow', +'home', +'honey', +'hood', +'hope', +'horn', +'horror', +'horse', +'hospital', +'host', +'hotel', +'hour', +'hover', +'hub', +'huge', +'human', +'humble', +'humor', +'hundred', +'hungry', +'hunt', +'hurdle', +'hurry', +'hurt', +'husband', +'hybrid', +'ice', +'icon', +'idea', +'identify', +'idle', +'ignore', +'ill', +'illegal', +'illness', +'image', +'imitate', +'immense', +'immune', +'impact', +'impose', +'improve', +'impulse', +'inch', +'include', +'income', +'increase', +'index', +'indicate', +'indoor', +'industry', +'infant', +'inflict', +'inform', +'inhale', +'inherit', +'initial', +'inject', +'injury', +'inmate', +'inner', +'innocent', +'input', +'inquiry', +'insane', +'insect', +'inside', +'inspire', +'install', +'intact', +'interest', +'into', +'invest', +'invite', +'involve', +'iron', +'island', +'isolate', +'issue', +'item', +'ivory', +'jacket', +'jaguar', +'jar', +'jazz', +'jealous', +'jeans', +'jelly', +'jewel', +'job', +'join', +'joke', +'journey', +'joy', +'judge', +'juice', +'jump', +'jungle', +'junior', +'junk', +'just', +'kangaroo', +'keen', +'keep', +'ketchup', +'key', +'kick', +'kid', +'kidney', +'kind', +'kingdom', +'kiss', +'kit', +'kitchen', +'kite', +'kitten', +'kiwi', +'knee', +'knife', +'knock', +'know', +'lab', +'label', +'labor', +'ladder', +'lady', +'lake', +'lamp', +'language', +'laptop', +'large', +'later', +'latin', +'laugh', +'laundry', +'lava', +'law', +'lawn', +'lawsuit', +'layer', +'lazy', +'leader', +'leaf', +'learn', +'leave', +'lecture', +'left', +'leg', +'legal', +'legend', +'leisure', +'lemon', +'lend', +'length', +'lens', +'leopard', +'lesson', +'letter', +'level', +'liar', +'liberty', +'library', +'license', +'life', +'lift', +'light', +'like', +'limb', +'limit', +'link', +'lion', +'liquid', +'list', +'little', +'live', +'lizard', +'load', +'loan', +'lobster', +'local', +'lock', +'logic', +'lonely', +'long', +'loop', +'lottery', +'loud', +'lounge', +'love', +'loyal', +'lucky', +'luggage', +'lumber', +'lunar', +'lunch', +'luxury', +'lyrics', +'machine', +'mad', +'magic', +'magnet', +'maid', +'mail', +'main', +'major', +'make', +'mammal', +'man', +'manage', +'mandate', +'mango', +'mansion', +'manual', +'maple', +'marble', +'march', +'margin', +'marine', +'market', +'marriage', +'mask', +'mass', +'master', +'match', +'material', +'math', +'matrix', +'matter', +'maximum', +'maze', +'meadow', +'mean', +'measure', +'meat', +'mechanic', +'medal', +'media', +'melody', +'melt', +'member', +'memory', +'mention', +'menu', +'mercy', +'merge', +'merit', +'merry', +'mesh', +'message', +'metal', +'method', +'middle', +'midnight', +'milk', +'million', +'mimic', +'mind', +'minimum', +'minor', +'minute', +'miracle', +'mirror', +'misery', +'miss', +'mistake', +'mix', +'mixed', +'mixture', +'mobile', +'model', +'modify', +'mom', +'moment', +'monitor', +'monkey', +'monster', +'month', +'moon', +'moral', +'more', +'morning', +'mosquito', +'mother', +'motion', +'motor', +'mountain', +'mouse', +'move', +'movie', +'much', +'muffin', +'mule', +'multiply', +'muscle', +'museum', +'mushroom', +'music', +'must', +'mutual', +'myself', +'mystery', +'myth', +'naive', +'name', +'napkin', +'narrow', +'nasty', +'nation', +'nature', +'near', +'neck', +'need', +'negative', +'neglect', +'neither', +'nephew', +'nerve', +'nest', +'net', +'network', +'neutral', +'never', +'news', +'next', +'nice', +'night', +'noble', +'noise', +'nominee', +'noodle', +'normal', +'north', +'nose', +'notable', +'note', +'nothing', +'notice', +'novel', +'now', +'nuclear', +'number', +'nurse', +'nut', +'oak', +'obey', +'object', +'oblige', +'obscure', +'observe', +'obtain', +'obvious', +'occur', +'ocean', +'october', +'odor', +'off', +'offer', +'office', +'often', +'oil', +'okay', +'old', +'olive', +'olympic', +'omit', +'once', +'one', +'onion', +'online', +'only', +'open', +'opera', +'opinion', +'oppose', +'option', +'orange', +'orbit', +'orchard', +'order', +'ordinary', +'organ', +'orient', +'original', +'orphan', +'ostrich', +'other', +'outdoor', +'outer', +'output', +'outside', +'oval', +'oven', +'over', +'own', +'owner', +'oxygen', +'oyster', +'ozone', +'pact', +'paddle', +'page', +'pair', +'palace', +'palm', +'panda', +'panel', +'panic', +'panther', +'paper', +'parade', +'parent', +'park', +'parrot', +'party', +'pass', +'patch', +'path', +'patient', +'patrol', +'pattern', +'pause', +'pave', +'payment', +'peace', +'peanut', +'pear', +'peasant', +'pelican', +'pen', +'penalty', +'pencil', +'people', +'pepper', +'perfect', +'permit', +'person', +'pet', +'phone', +'photo', +'phrase', +'physical', +'piano', +'picnic', +'picture', +'piece', +'pig', +'pigeon', +'pill', +'pilot', +'pink', +'pioneer', +'pipe', +'pistol', +'pitch', +'pizza', +'place', +'planet', +'plastic', +'plate', +'play', +'please', +'pledge', +'pluck', +'plug', +'plunge', +'poem', +'poet', +'point', +'polar', +'pole', +'police', +'pond', +'pony', +'pool', +'popular', +'portion', +'position', +'possible', +'post', +'potato', +'pottery', +'poverty', +'powder', +'power', +'practice', +'praise', +'predict', +'prefer', +'prepare', +'present', +'pretty', +'prevent', +'price', +'pride', +'primary', +'print', +'priority', +'prison', +'private', +'prize', +'problem', +'process', +'produce', +'profit', +'program', +'project', +'promote', +'proof', +'property', +'prosper', +'protect', +'proud', +'provide', +'public', +'pudding', +'pull', +'pulp', +'pulse', +'pumpkin', +'punch', +'pupil', +'puppy', +'purchase', +'purity', +'purpose', +'purse', +'push', +'put', +'puzzle', +'pyramid', +'quality', +'quantum', +'quarter', +'question', +'quick', +'quit', +'quiz', +'quote', +'rabbit', +'raccoon', +'race', +'rack', +'radar', +'radio', +'rail', +'rain', +'raise', +'rally', +'ramp', +'ranch', +'random', +'range', +'rapid', +'rare', +'rate', +'rather', +'raven', +'raw', +'razor', +'ready', +'real', +'reason', +'rebel', +'rebuild', +'recall', +'receive', +'recipe', +'record', +'recycle', +'reduce', +'reflect', +'reform', +'refuse', +'region', +'regret', +'regular', +'reject', +'relax', +'release', +'relief', +'rely', +'remain', +'remember', +'remind', +'remove', +'render', +'renew', +'rent', +'reopen', +'repair', +'repeat', +'replace', +'report', +'require', +'rescue', +'resemble', +'resist', +'resource', +'response', +'result', +'retire', +'retreat', +'return', +'reunion', +'reveal', +'review', +'reward', +'rhythm', +'rib', +'ribbon', +'rice', +'rich', +'ride', +'ridge', +'rifle', +'right', +'rigid', +'ring', +'riot', +'ripple', +'risk', +'ritual', +'rival', +'river', +'road', +'roast', +'robot', +'robust', +'rocket', +'romance', +'roof', +'rookie', +'room', +'rose', +'rotate', +'rough', +'round', +'route', +'royal', +'rubber', +'rude', +'rug', +'rule', +'run', +'runway', +'rural', +'sad', +'saddle', +'sadness', +'safe', +'sail', +'salad', +'salmon', +'salon', +'salt', +'salute', +'same', +'sample', +'sand', +'satisfy', +'satoshi', +'sauce', +'sausage', +'save', +'say', +'scale', +'scan', +'scare', +'scatter', +'scene', +'scheme', +'school', +'science', +'scissors', +'scorpion', +'scout', +'scrap', +'screen', +'script', +'scrub', +'sea', +'search', +'season', +'seat', +'second', +'secret', +'section', +'security', +'seed', +'seek', +'segment', +'select', +'sell', +'seminar', +'senior', +'sense', +'sentence', +'series', +'service', +'session', +'settle', +'setup', +'seven', +'shadow', +'shaft', +'shallow', +'share', +'shed', +'shell', +'sheriff', +'shield', +'shift', +'shine', +'ship', +'shiver', +'shock', +'shoe', +'shoot', +'shop', +'short', +'shoulder', +'shove', +'shrimp', +'shrug', +'shuffle', +'shy', +'sibling', +'sick', +'side', +'siege', +'sight', +'sign', +'silent', +'silk', +'silly', +'silver', +'similar', +'simple', +'since', +'sing', +'siren', +'sister', +'situate', +'six', +'size', +'skate', +'sketch', +'ski', +'skill', +'skin', +'skirt', +'skull', +'slab', +'slam', +'sleep', +'slender', +'slice', +'slide', +'slight', +'slim', +'slogan', +'slot', +'slow', +'slush', +'small', +'smart', +'smile', +'smoke', +'smooth', +'snack', +'snake', +'snap', +'sniff', +'snow', +'soap', +'soccer', +'social', +'sock', +'soda', +'soft', +'solar', +'soldier', +'solid', +'solution', +'solve', +'someone', +'song', +'soon', +'sorry', +'sort', +'soul', +'sound', +'soup', +'source', +'south', +'space', +'spare', +'spatial', +'spawn', +'speak', +'special', +'speed', +'spell', +'spend', +'sphere', +'spice', +'spider', +'spike', +'spin', +'spirit', +'split', +'spoil', +'sponsor', +'spoon', +'sport', +'spot', +'spray', +'spread', +'spring', +'spy', +'square', +'squeeze', +'squirrel', +'stable', +'stadium', +'staff', +'stage', +'stairs', +'stamp', +'stand', +'start', +'state', +'stay', +'steak', +'steel', +'stem', +'step', +'stereo', +'stick', +'still', +'sting', +'stock', +'stomach', +'stone', +'stool', +'story', +'stove', +'strategy', +'street', +'strike', +'strong', +'struggle', +'student', +'stuff', +'stumble', +'style', +'subject', +'submit', +'subway', +'success', +'such', +'sudden', +'suffer', +'sugar', +'suggest', +'suit', +'summer', +'sun', +'sunny', +'sunset', +'super', +'supply', +'supreme', +'sure', +'surface', +'surge', +'surprise', +'surround', +'survey', +'suspect', +'sustain', +'swallow', +'swamp', +'swap', +'swarm', +'swear', +'sweet', +'swift', +'swim', +'swing', +'switch', +'sword', +'symbol', +'symptom', +'syrup', +'system', +'table', +'tackle', +'tag', +'tail', +'talent', +'talk', +'tank', +'tape', +'target', +'task', +'taste', +'tattoo', +'taxi', +'teach', +'team', +'tell', +'ten', +'tenant', +'tennis', +'tent', +'term', +'test', +'text', +'thank', +'that', +'theme', +'then', +'theory', +'there', +'they', +'thing', +'this', +'thought', +'three', +'thrive', +'throw', +'thumb', +'thunder', +'ticket', +'tide', +'tiger', +'tilt', +'timber', +'time', +'tiny', +'tip', +'tired', +'tissue', +'title', +'toast', +'tobacco', +'today', +'toddler', +'toe', +'together', +'toilet', +'token', +'tomato', +'tomorrow', +'tone', +'tongue', +'tonight', +'tool', +'tooth', +'top', +'topic', +'topple', +'torch', +'tornado', +'tortoise', +'toss', +'total', +'tourist', +'toward', +'tower', +'town', +'toy', +'track', +'trade', +'traffic', +'tragic', +'train', +'transfer', +'trap', +'trash', +'travel', +'tray', +'treat', +'tree', +'trend', +'trial', +'tribe', +'trick', +'trigger', +'trim', +'trip', +'trophy', +'trouble', +'truck', +'true', +'truly', +'trumpet', +'trust', +'truth', +'try', +'tube', +'tuition', +'tumble', +'tuna', +'tunnel', +'turkey', +'turn', +'turtle', +'twelve', +'twenty', +'twice', +'twin', +'twist', +'two', +'type', +'typical', +'ugly', +'umbrella', +'unable', +'unaware', +'uncle', +'uncover', +'under', +'undo', +'unfair', +'unfold', +'unhappy', +'uniform', +'unique', +'unit', +'universe', +'unknown', +'unlock', +'until', +'unusual', +'unveil', +'update', +'upgrade', +'uphold', +'upon', +'upper', +'upset', +'urban', +'urge', +'usage', +'use', +'used', +'useful', +'useless', +'usual', +'utility', +'vacant', +'vacuum', +'vague', +'valid', +'valley', +'valve', +'van', +'vanish', +'vapor', +'various', +'vast', +'vault', +'vehicle', +'velvet', +'vendor', +'venture', +'venue', +'verb', +'verify', +'version', +'very', +'vessel', +'veteran', +'viable', +'vibrant', +'vicious', +'victory', +'video', +'view', +'village', +'vintage', +'violin', +'virtual', +'virus', +'visa', +'visit', +'visual', +'vital', +'vivid', +'vocal', +'voice', +'void', +'volcano', +'volume', +'vote', +'voyage', +'wage', +'wagon', +'wait', +'walk', +'wall', +'walnut', +'want', +'warfare', +'warm', +'warrior', +'wash', +'wasp', +'waste', +'water', +'wave', +'way', +'wealth', +'weapon', +'wear', +'weasel', +'weather', +'web', +'wedding', +'weekend', +'weird', +'welcome', +'west', +'wet', +'whale', +'what', +'wheat', +'wheel', +'when', +'where', +'whip', +'whisper', +'wide', +'width', +'wife', +'wild', +'will', +'win', +'window', +'wine', +'wing', +'wink', +'winner', +'winter', +'wire', +'wisdom', +'wise', +'wish', +'witness', +'wolf', +'woman', +'wonder', +'wood', +'wool', +'word', +'work', +'world', +'worry', +'worth', +'wrap', +'wreck', +'wrestle', +'wrist', +'write', +'wrong', +'yard', +'year', +'yellow', +'you', +'young', +'youth', +'zebra', +'zero', +'zone', +'zoo' +] diff --git a/torba/words/english.txt b/torba/words/english.txt deleted file mode 100644 index 942040ed5..000000000 --- a/torba/words/english.txt +++ /dev/null @@ -1,2048 +0,0 @@ -abandon -ability -able -about -above -absent -absorb -abstract -absurd -abuse -access -accident -account -accuse -achieve -acid -acoustic -acquire -across -act -action -actor -actress -actual -adapt -add -addict -address -adjust -admit -adult -advance -advice -aerobic -affair -afford -afraid -again -age -agent -agree -ahead -aim -air -airport -aisle -alarm -album -alcohol -alert -alien -all -alley -allow -almost -alone -alpha -already -also -alter -always -amateur -amazing -among -amount -amused -analyst -anchor -ancient -anger -angle -angry -animal -ankle -announce -annual -another -answer -antenna -antique -anxiety -any -apart -apology -appear -apple -approve -april -arch -arctic -area -arena -argue -arm -armed -armor -army -around -arrange -arrest -arrive -arrow -art -artefact -artist -artwork -ask -aspect -assault -asset -assist -assume -asthma -athlete -atom -attack -attend -attitude -attract -auction -audit -august -aunt -author -auto -autumn -average -avocado -avoid -awake -aware -away -awesome -awful -awkward -axis -baby -bachelor -bacon -badge -bag -balance -balcony -ball -bamboo -banana -banner -bar -barely -bargain -barrel -base -basic -basket -battle -beach -bean -beauty -because -become -beef -before -begin -behave -behind -believe -below -belt -bench -benefit -best -betray -better -between -beyond -bicycle -bid -bike -bind -biology -bird -birth -bitter -black -blade -blame -blanket -blast -bleak -bless -blind -blood -blossom -blouse -blue -blur -blush -board -boat -body -boil -bomb -bone -bonus -book -boost -border -boring -borrow -boss -bottom -bounce -box -boy -bracket -brain -brand -brass -brave -bread -breeze -brick -bridge -brief -bright -bring -brisk -broccoli -broken -bronze -broom -brother -brown -brush -bubble -buddy -budget -buffalo -build -bulb -bulk -bullet -bundle -bunker -burden -burger -burst -bus -business -busy -butter -buyer -buzz -cabbage -cabin -cable -cactus -cage -cake -call -calm -camera -camp -can -canal -cancel -candy -cannon -canoe -canvas -canyon -capable -capital -captain -car -carbon -card -cargo -carpet -carry -cart -case -cash -casino -castle -casual -cat -catalog -catch -category -cattle -caught -cause -caution -cave -ceiling -celery -cement -census -century -cereal -certain -chair -chalk -champion -change -chaos -chapter -charge -chase -chat -cheap -check -cheese -chef -cherry -chest -chicken -chief -child -chimney -choice -choose -chronic -chuckle -chunk -churn -cigar -cinnamon -circle -citizen -city -civil -claim -clap -clarify -claw -clay -clean -clerk -clever -click -client -cliff -climb -clinic -clip -clock -clog -close -cloth -cloud -clown -club -clump -cluster -clutch -coach -coast -coconut -code -coffee -coil -coin -collect -color -column -combine -come -comfort -comic -common -company -concert -conduct -confirm -congress -connect -consider -control -convince -cook -cool -copper -copy -coral -core -corn -correct -cost -cotton -couch -country -couple -course -cousin -cover -coyote -crack -cradle -craft -cram -crane -crash -crater -crawl -crazy -cream -credit -creek -crew -cricket -crime -crisp -critic -crop -cross -crouch -crowd -crucial -cruel -cruise -crumble -crunch -crush -cry -crystal -cube -culture -cup -cupboard -curious -current -curtain -curve -cushion -custom -cute -cycle -dad -damage -damp -dance -danger -daring -dash -daughter -dawn -day -deal -debate -debris -decade -december -decide -decline -decorate -decrease -deer -defense -define -defy -degree -delay -deliver -demand -demise -denial -dentist -deny -depart -depend -deposit -depth -deputy -derive -describe -desert -design -desk -despair -destroy -detail -detect -develop -device -devote -diagram -dial -diamond -diary -dice -diesel -diet -differ -digital -dignity -dilemma -dinner -dinosaur -direct -dirt -disagree -discover -disease -dish -dismiss -disorder -display -distance -divert -divide -divorce -dizzy -doctor -document -dog -doll -dolphin -domain -donate -donkey -donor -door -dose -double -dove -draft -dragon -drama -drastic -draw -dream -dress -drift -drill -drink -drip -drive -drop -drum -dry -duck -dumb -dune -during -dust -dutch -duty -dwarf -dynamic -eager -eagle -early -earn -earth -easily -east -easy -echo -ecology -economy -edge -edit -educate -effort -egg -eight -either -elbow -elder -electric -elegant -element -elephant -elevator -elite -else -embark -embody -embrace -emerge -emotion -employ -empower -empty -enable -enact -end -endless -endorse -enemy -energy -enforce -engage -engine -enhance -enjoy -enlist -enough -enrich -enroll -ensure -enter -entire -entry -envelope -episode -equal -equip -era -erase -erode -erosion -error -erupt -escape -essay -essence -estate -eternal -ethics -evidence -evil -evoke -evolve -exact -example -excess -exchange -excite -exclude -excuse -execute -exercise -exhaust -exhibit -exile -exist -exit -exotic -expand -expect -expire -explain -expose -express -extend -extra -eye -eyebrow -fabric -face -faculty -fade -faint -faith -fall -false -fame -family -famous -fan -fancy -fantasy -farm -fashion -fat -fatal -father -fatigue -fault -favorite -feature -february -federal -fee -feed -feel -female -fence -festival -fetch -fever -few -fiber -fiction -field -figure -file -film -filter -final -find -fine -finger -finish -fire -firm -first -fiscal -fish -fit -fitness -fix -flag -flame -flash -flat -flavor -flee -flight -flip -float -flock -floor -flower -fluid -flush -fly -foam -focus -fog -foil -fold -follow -food -foot -force -forest -forget -fork -fortune -forum -forward -fossil -foster -found -fox -fragile -frame -frequent -fresh -friend -fringe -frog -front -frost -frown -frozen -fruit -fuel -fun -funny -furnace -fury -future -gadget -gain -galaxy -gallery -game -gap -garage -garbage -garden -garlic -garment -gas -gasp -gate -gather -gauge -gaze -general -genius -genre -gentle -genuine -gesture -ghost -giant -gift -giggle -ginger -giraffe -girl -give -glad -glance -glare -glass -glide -glimpse -globe -gloom -glory -glove -glow -glue -goat -goddess -gold -good -goose -gorilla -gospel -gossip -govern -gown -grab -grace -grain -grant -grape -grass -gravity -great -green -grid -grief -grit -grocery -group -grow -grunt -guard -guess -guide -guilt -guitar -gun -gym -habit -hair -half -hammer -hamster -hand -happy -harbor -hard -harsh -harvest -hat -have -hawk -hazard -head -health -heart -heavy -hedgehog -height -hello -helmet -help -hen -hero -hidden -high -hill -hint -hip -hire -history -hobby -hockey -hold -hole -holiday -hollow -home -honey -hood -hope -horn -horror -horse -hospital -host -hotel -hour -hover -hub -huge -human -humble -humor -hundred -hungry -hunt -hurdle -hurry -hurt -husband -hybrid -ice -icon -idea -identify -idle -ignore -ill -illegal -illness -image -imitate -immense -immune -impact -impose -improve -impulse -inch -include -income -increase -index -indicate -indoor -industry -infant -inflict -inform -inhale -inherit -initial -inject -injury -inmate -inner -innocent -input -inquiry -insane -insect -inside -inspire -install -intact -interest -into -invest -invite -involve -iron -island -isolate -issue -item -ivory -jacket -jaguar -jar -jazz -jealous -jeans -jelly -jewel -job -join -joke -journey -joy -judge -juice -jump -jungle -junior -junk -just -kangaroo -keen -keep -ketchup -key -kick -kid -kidney -kind -kingdom -kiss -kit -kitchen -kite -kitten -kiwi -knee -knife -knock -know -lab -label -labor -ladder -lady -lake -lamp -language -laptop -large -later -latin -laugh -laundry -lava -law -lawn -lawsuit -layer -lazy -leader -leaf -learn -leave -lecture -left -leg -legal -legend -leisure -lemon -lend -length -lens -leopard -lesson -letter -level -liar -liberty -library -license -life -lift -light -like -limb -limit -link -lion -liquid -list -little -live -lizard -load -loan -lobster -local -lock -logic -lonely -long -loop -lottery -loud -lounge -love -loyal -lucky -luggage -lumber -lunar -lunch -luxury -lyrics -machine -mad -magic -magnet -maid -mail -main -major -make -mammal -man -manage -mandate -mango -mansion -manual -maple -marble -march -margin -marine -market -marriage -mask -mass -master -match -material -math -matrix -matter -maximum -maze -meadow -mean -measure -meat -mechanic -medal -media -melody -melt -member -memory -mention -menu -mercy -merge -merit -merry -mesh -message -metal -method -middle -midnight -milk -million -mimic -mind -minimum -minor -minute -miracle -mirror -misery -miss -mistake -mix -mixed -mixture -mobile -model -modify -mom -moment -monitor -monkey -monster -month -moon -moral -more -morning -mosquito -mother -motion -motor -mountain -mouse -move -movie -much -muffin -mule -multiply -muscle -museum -mushroom -music -must -mutual -myself -mystery -myth -naive -name -napkin -narrow -nasty -nation -nature -near -neck -need -negative -neglect -neither -nephew -nerve -nest -net -network -neutral -never -news -next -nice -night -noble -noise -nominee -noodle -normal -north -nose -notable -note -nothing -notice -novel -now -nuclear -number -nurse -nut -oak -obey -object -oblige -obscure -observe -obtain -obvious -occur -ocean -october -odor -off -offer -office -often -oil -okay -old -olive -olympic -omit -once -one -onion -online -only -open -opera -opinion -oppose -option -orange -orbit -orchard -order -ordinary -organ -orient -original -orphan -ostrich -other -outdoor -outer -output -outside -oval -oven -over -own -owner -oxygen -oyster -ozone -pact -paddle -page -pair -palace -palm -panda -panel -panic -panther -paper -parade -parent -park -parrot -party -pass -patch -path -patient -patrol -pattern -pause -pave -payment -peace -peanut -pear -peasant -pelican -pen -penalty -pencil -people -pepper -perfect -permit -person -pet -phone -photo -phrase -physical -piano -picnic -picture -piece -pig -pigeon -pill -pilot -pink -pioneer -pipe -pistol -pitch -pizza -place -planet -plastic -plate -play -please -pledge -pluck -plug -plunge -poem -poet -point -polar -pole -police -pond -pony -pool -popular -portion -position -possible -post -potato -pottery -poverty -powder -power -practice -praise -predict -prefer -prepare -present -pretty -prevent -price -pride -primary -print -priority -prison -private -prize -problem -process -produce -profit -program -project -promote -proof -property -prosper -protect -proud -provide -public -pudding -pull -pulp -pulse -pumpkin -punch -pupil -puppy -purchase -purity -purpose -purse -push -put -puzzle -pyramid -quality -quantum -quarter -question -quick -quit -quiz -quote -rabbit -raccoon -race -rack -radar -radio -rail -rain -raise -rally -ramp -ranch -random -range -rapid -rare -rate -rather -raven -raw -razor -ready -real -reason -rebel -rebuild -recall -receive -recipe -record -recycle -reduce -reflect -reform -refuse -region -regret -regular -reject -relax -release -relief -rely -remain -remember -remind -remove -render -renew -rent -reopen -repair -repeat -replace -report -require -rescue -resemble -resist -resource -response -result -retire -retreat -return -reunion -reveal -review -reward -rhythm -rib -ribbon -rice -rich -ride -ridge -rifle -right -rigid -ring -riot -ripple -risk -ritual -rival -river -road -roast -robot -robust -rocket -romance -roof -rookie -room -rose -rotate -rough -round -route -royal -rubber -rude -rug -rule -run -runway -rural -sad -saddle -sadness -safe -sail -salad -salmon -salon -salt -salute -same -sample -sand -satisfy -satoshi -sauce -sausage -save -say -scale -scan -scare -scatter -scene -scheme -school -science -scissors -scorpion -scout -scrap -screen -script -scrub -sea -search -season -seat -second -secret -section -security -seed -seek -segment -select -sell -seminar -senior -sense -sentence -series -service -session -settle -setup -seven -shadow -shaft -shallow -share -shed -shell -sheriff -shield -shift -shine -ship -shiver -shock -shoe -shoot -shop -short -shoulder -shove -shrimp -shrug -shuffle -shy -sibling -sick -side -siege -sight -sign -silent -silk -silly -silver -similar -simple -since -sing -siren -sister -situate -six -size -skate -sketch -ski -skill -skin -skirt -skull -slab -slam -sleep -slender -slice -slide -slight -slim -slogan -slot -slow -slush -small -smart -smile -smoke -smooth -snack -snake -snap -sniff -snow -soap -soccer -social -sock -soda -soft -solar -soldier -solid -solution -solve -someone -song -soon -sorry -sort -soul -sound -soup -source -south -space -spare -spatial -spawn -speak -special -speed -spell -spend -sphere -spice -spider -spike -spin -spirit -split -spoil -sponsor -spoon -sport -spot -spray -spread -spring -spy -square -squeeze -squirrel -stable -stadium -staff -stage -stairs -stamp -stand -start -state -stay -steak -steel -stem -step -stereo -stick -still -sting -stock -stomach -stone -stool -story -stove -strategy -street -strike -strong -struggle -student -stuff -stumble -style -subject -submit -subway -success -such -sudden -suffer -sugar -suggest -suit -summer -sun -sunny -sunset -super -supply -supreme -sure -surface -surge -surprise -surround -survey -suspect -sustain -swallow -swamp -swap -swarm -swear -sweet -swift -swim -swing -switch -sword -symbol -symptom -syrup -system -table -tackle -tag -tail -talent -talk -tank -tape -target -task -taste -tattoo -taxi -teach -team -tell -ten -tenant -tennis -tent -term -test -text -thank -that -theme -then -theory -there -they -thing -this -thought -three -thrive -throw -thumb -thunder -ticket -tide -tiger -tilt -timber -time -tiny -tip -tired -tissue -title -toast -tobacco -today -toddler -toe -together -toilet -token -tomato -tomorrow -tone -tongue -tonight -tool -tooth -top -topic -topple -torch -tornado -tortoise -toss -total -tourist -toward -tower -town -toy -track -trade -traffic -tragic -train -transfer -trap -trash -travel -tray -treat -tree -trend -trial -tribe -trick -trigger -trim -trip -trophy -trouble -truck -true -truly -trumpet -trust -truth -try -tube -tuition -tumble -tuna -tunnel -turkey -turn -turtle -twelve -twenty -twice -twin -twist -two -type -typical -ugly -umbrella -unable -unaware -uncle -uncover -under -undo -unfair -unfold -unhappy -uniform -unique -unit -universe -unknown -unlock -until -unusual -unveil -update -upgrade -uphold -upon -upper -upset -urban -urge -usage -use -used -useful -useless -usual -utility -vacant -vacuum -vague -valid -valley -valve -van -vanish -vapor -various -vast -vault -vehicle -velvet -vendor -venture -venue -verb -verify -version -very -vessel -veteran -viable -vibrant -vicious -victory -video -view -village -vintage -violin -virtual -virus -visa -visit -visual -vital -vivid -vocal -voice -void -volcano -volume -vote -voyage -wage -wagon -wait -walk -wall -walnut -want -warfare -warm -warrior -wash -wasp -waste -water -wave -way -wealth -weapon -wear -weasel -weather -web -wedding -weekend -weird -welcome -west -wet -whale -what -wheat -wheel -when -where -whip -whisper -wide -width -wife -wild -will -win -window -wine -wing -wink -winner -winter -wire -wisdom -wise -wish -witness -wolf -woman -wonder -wood -wool -word -work -world -worry -worth -wrap -wreck -wrestle -wrist -write -wrong -yard -year -yellow -you -young -youth -zebra -zero -zone -zoo diff --git a/torba/words/japanese.py b/torba/words/japanese.py new file mode 100644 index 000000000..170bb6172 --- /dev/null +++ b/torba/words/japanese.py @@ -0,0 +1,2050 @@ +words = [ +'あいこくしん', +'あいさつ', +'あいだ', +'あおぞら', +'あかちゃん', +'あきる', +'あけがた', +'あける', +'あこがれる', +'あさい', +'あさひ', +'あしあと', +'あじわう', +'あずかる', +'あずき', +'あそぶ', +'あたえる', +'あたためる', +'あたりまえ', +'あたる', +'あつい', +'あつかう', +'あっしゅく', +'あつまり', +'あつめる', +'あてな', +'あてはまる', +'あひる', +'あぶら', +'あぶる', +'あふれる', +'あまい', +'あまど', +'あまやかす', +'あまり', +'あみもの', +'あめりか', +'あやまる', +'あゆむ', +'あらいぐま', +'あらし', +'あらすじ', +'あらためる', +'あらゆる', +'あらわす', +'ありがとう', +'あわせる', +'あわてる', +'あんい', +'あんがい', +'あんこ', +'あんぜん', +'あんてい', +'あんない', +'あんまり', +'いいだす', +'いおん', +'いがい', +'いがく', +'いきおい', +'いきなり', +'いきもの', +'いきる', +'いくじ', +'いくぶん', +'いけばな', +'いけん', +'いこう', +'いこく', +'いこつ', +'いさましい', +'いさん', +'いしき', +'いじゅう', +'いじょう', +'いじわる', +'いずみ', +'いずれ', +'いせい', +'いせえび', +'いせかい', +'いせき', +'いぜん', +'いそうろう', +'いそがしい', +'いだい', +'いだく', +'いたずら', +'いたみ', +'いたりあ', +'いちおう', +'いちじ', +'いちど', +'いちば', +'いちぶ', +'いちりゅう', +'いつか', +'いっしゅん', +'いっせい', +'いっそう', +'いったん', +'いっち', +'いってい', +'いっぽう', +'いてざ', +'いてん', +'いどう', +'いとこ', +'いない', +'いなか', +'いねむり', +'いのち', +'いのる', +'いはつ', +'いばる', +'いはん', +'いびき', +'いひん', +'いふく', +'いへん', +'いほう', +'いみん', +'いもうと', +'いもたれ', +'いもり', +'いやがる', +'いやす', +'いよかん', +'いよく', +'いらい', +'いらすと', +'いりぐち', +'いりょう', +'いれい', +'いれもの', +'いれる', +'いろえんぴつ', +'いわい', +'いわう', +'いわかん', +'いわば', +'いわゆる', +'いんげんまめ', +'いんさつ', +'いんしょう', +'いんよう', +'うえき', +'うえる', +'うおざ', +'うがい', +'うかぶ', +'うかべる', +'うきわ', +'うくらいな', +'うくれれ', +'うけたまわる', +'うけつけ', +'うけとる', +'うけもつ', +'うける', +'うごかす', +'うごく', +'うこん', +'うさぎ', +'うしなう', +'うしろがみ', +'うすい', +'うすぎ', +'うすぐらい', +'うすめる', +'うせつ', +'うちあわせ', +'うちがわ', +'うちき', +'うちゅう', +'うっかり', +'うつくしい', +'うったえる', +'うつる', +'うどん', +'うなぎ', +'うなじ', +'うなずく', +'うなる', +'うねる', +'うのう', +'うぶげ', +'うぶごえ', +'うまれる', +'うめる', +'うもう', +'うやまう', +'うよく', +'うらがえす', +'うらぐち', +'うらない', +'うりあげ', +'うりきれ', +'うるさい', +'うれしい', +'うれゆき', +'うれる', +'うろこ', +'うわき', +'うわさ', +'うんこう', +'うんちん', +'うんてん', +'うんどう', +'えいえん', +'えいが', +'えいきょう', +'えいご', +'えいせい', +'えいぶん', +'えいよう', +'えいわ', +'えおり', +'えがお', +'えがく', +'えきたい', +'えくせる', +'えしゃく', +'えすて', +'えつらん', +'えのぐ', +'えほうまき', +'えほん', +'えまき', +'えもじ', +'えもの', +'えらい', +'えらぶ', +'えりあ', +'えんえん', +'えんかい', +'えんぎ', +'えんげき', +'えんしゅう', +'えんぜつ', +'えんそく', +'えんちょう', +'えんとつ', +'おいかける', +'おいこす', +'おいしい', +'おいつく', +'おうえん', +'おうさま', +'おうじ', +'おうせつ', +'おうたい', +'おうふく', +'おうべい', +'おうよう', +'おえる', +'おおい', +'おおう', +'おおどおり', +'おおや', +'おおよそ', +'おかえり', +'おかず', +'おがむ', +'おかわり', +'おぎなう', +'おきる', +'おくさま', +'おくじょう', +'おくりがな', +'おくる', +'おくれる', +'おこす', +'おこなう', +'おこる', +'おさえる', +'おさない', +'おさめる', +'おしいれ', +'おしえる', +'おじぎ', +'おじさん', +'おしゃれ', +'おそらく', +'おそわる', +'おたがい', +'おたく', +'おだやか', +'おちつく', +'おっと', +'おつり', +'おでかけ', +'おとしもの', +'おとなしい', +'おどり', +'おどろかす', +'おばさん', +'おまいり', +'おめでとう', +'おもいで', +'おもう', +'おもたい', +'おもちゃ', +'おやつ', +'おやゆび', +'およぼす', +'おらんだ', +'おろす', +'おんがく', +'おんけい', +'おんしゃ', +'おんせん', +'おんだん', +'おんちゅう', +'おんどけい', +'かあつ', +'かいが', +'がいき', +'がいけん', +'がいこう', +'かいさつ', +'かいしゃ', +'かいすいよく', +'かいぜん', +'かいぞうど', +'かいつう', +'かいてん', +'かいとう', +'かいふく', +'がいへき', +'かいほう', +'かいよう', +'がいらい', +'かいわ', +'かえる', +'かおり', +'かかえる', +'かがく', +'かがし', +'かがみ', +'かくご', +'かくとく', +'かざる', +'がぞう', +'かたい', +'かたち', +'がちょう', +'がっきゅう', +'がっこう', +'がっさん', +'がっしょう', +'かなざわし', +'かのう', +'がはく', +'かぶか', +'かほう', +'かほご', +'かまう', +'かまぼこ', +'かめれおん', +'かゆい', +'かようび', +'からい', +'かるい', +'かろう', +'かわく', +'かわら', +'がんか', +'かんけい', +'かんこう', +'かんしゃ', +'かんそう', +'かんたん', +'かんち', +'がんばる', +'きあい', +'きあつ', +'きいろ', +'ぎいん', +'きうい', +'きうん', +'きえる', +'きおう', +'きおく', +'きおち', +'きおん', +'きかい', +'きかく', +'きかんしゃ', +'ききて', +'きくばり', +'きくらげ', +'きけんせい', +'きこう', +'きこえる', +'きこく', +'きさい', +'きさく', +'きさま', +'きさらぎ', +'ぎじかがく', +'ぎしき', +'ぎじたいけん', +'ぎじにってい', +'ぎじゅつしゃ', +'きすう', +'きせい', +'きせき', +'きせつ', +'きそう', +'きぞく', +'きぞん', +'きたえる', +'きちょう', +'きつえん', +'ぎっちり', +'きつつき', +'きつね', +'きてい', +'きどう', +'きどく', +'きない', +'きなが', +'きなこ', +'きぬごし', +'きねん', +'きのう', +'きのした', +'きはく', +'きびしい', +'きひん', +'きふく', +'きぶん', +'きぼう', +'きほん', +'きまる', +'きみつ', +'きむずかしい', +'きめる', +'きもだめし', +'きもち', +'きもの', +'きゃく', +'きやく', +'ぎゅうにく', +'きよう', +'きょうりゅう', +'きらい', +'きらく', +'きりん', +'きれい', +'きれつ', +'きろく', +'ぎろん', +'きわめる', +'ぎんいろ', +'きんかくじ', +'きんじょ', +'きんようび', +'ぐあい', +'くいず', +'くうかん', +'くうき', +'くうぐん', +'くうこう', +'ぐうせい', +'くうそう', +'ぐうたら', +'くうふく', +'くうぼ', +'くかん', +'くきょう', +'くげん', +'ぐこう', +'くさい', +'くさき', +'くさばな', +'くさる', +'くしゃみ', +'くしょう', +'くすのき', +'くすりゆび', +'くせげ', +'くせん', +'ぐたいてき', +'くださる', +'くたびれる', +'くちこみ', +'くちさき', +'くつした', +'ぐっすり', +'くつろぐ', +'くとうてん', +'くどく', +'くなん', +'くねくね', +'くのう', +'くふう', +'くみあわせ', +'くみたてる', +'くめる', +'くやくしょ', +'くらす', +'くらべる', +'くるま', +'くれる', +'くろう', +'くわしい', +'ぐんかん', +'ぐんしょく', +'ぐんたい', +'ぐんて', +'けあな', +'けいかく', +'けいけん', +'けいこ', +'けいさつ', +'げいじゅつ', +'けいたい', +'げいのうじん', +'けいれき', +'けいろ', +'けおとす', +'けおりもの', +'げきか', +'げきげん', +'げきだん', +'げきちん', +'げきとつ', +'げきは', +'げきやく', +'げこう', +'げこくじょう', +'げざい', +'けさき', +'げざん', +'けしき', +'けしごむ', +'けしょう', +'げすと', +'けたば', +'けちゃっぷ', +'けちらす', +'けつあつ', +'けつい', +'けつえき', +'けっこん', +'けつじょ', +'けっせき', +'けってい', +'けつまつ', +'げつようび', +'げつれい', +'けつろん', +'げどく', +'けとばす', +'けとる', +'けなげ', +'けなす', +'けなみ', +'けぬき', +'げねつ', +'けねん', +'けはい', +'げひん', +'けぶかい', +'げぼく', +'けまり', +'けみかる', +'けむし', +'けむり', +'けもの', +'けらい', +'けろけろ', +'けわしい', +'けんい', +'けんえつ', +'けんお', +'けんか', +'げんき', +'けんげん', +'けんこう', +'けんさく', +'けんしゅう', +'けんすう', +'げんそう', +'けんちく', +'けんてい', +'けんとう', +'けんない', +'けんにん', +'げんぶつ', +'けんま', +'けんみん', +'けんめい', +'けんらん', +'けんり', +'こあくま', +'こいぬ', +'こいびと', +'ごうい', +'こうえん', +'こうおん', +'こうかん', +'ごうきゅう', +'ごうけい', +'こうこう', +'こうさい', +'こうじ', +'こうすい', +'ごうせい', +'こうそく', +'こうたい', +'こうちゃ', +'こうつう', +'こうてい', +'こうどう', +'こうない', +'こうはい', +'ごうほう', +'ごうまん', +'こうもく', +'こうりつ', +'こえる', +'こおり', +'ごかい', +'ごがつ', +'ごかん', +'こくご', +'こくさい', +'こくとう', +'こくない', +'こくはく', +'こぐま', +'こけい', +'こける', +'ここのか', +'こころ', +'こさめ', +'こしつ', +'こすう', +'こせい', +'こせき', +'こぜん', +'こそだて', +'こたい', +'こたえる', +'こたつ', +'こちょう', +'こっか', +'こつこつ', +'こつばん', +'こつぶ', +'こてい', +'こてん', +'ことがら', +'ことし', +'ことば', +'ことり', +'こなごな', +'こねこね', +'このまま', +'このみ', +'このよ', +'ごはん', +'こひつじ', +'こふう', +'こふん', +'こぼれる', +'ごまあぶら', +'こまかい', +'ごますり', +'こまつな', +'こまる', +'こむぎこ', +'こもじ', +'こもち', +'こもの', +'こもん', +'こやく', +'こやま', +'こゆう', +'こゆび', +'こよい', +'こよう', +'こりる', +'これくしょん', +'ころっけ', +'こわもて', +'こわれる', +'こんいん', +'こんかい', +'こんき', +'こんしゅう', +'こんすい', +'こんだて', +'こんとん', +'こんなん', +'こんびに', +'こんぽん', +'こんまけ', +'こんや', +'こんれい', +'こんわく', +'ざいえき', +'さいかい', +'さいきん', +'ざいげん', +'ざいこ', +'さいしょ', +'さいせい', +'ざいたく', +'ざいちゅう', +'さいてき', +'ざいりょう', +'さうな', +'さかいし', +'さがす', +'さかな', +'さかみち', +'さがる', +'さぎょう', +'さくし', +'さくひん', +'さくら', +'さこく', +'さこつ', +'さずかる', +'ざせき', +'さたん', +'さつえい', +'ざつおん', +'ざっか', +'ざつがく', +'さっきょく', +'ざっし', +'さつじん', +'ざっそう', +'さつたば', +'さつまいも', +'さてい', +'さといも', +'さとう', +'さとおや', +'さとし', +'さとる', +'さのう', +'さばく', +'さびしい', +'さべつ', +'さほう', +'さほど', +'さます', +'さみしい', +'さみだれ', +'さむけ', +'さめる', +'さやえんどう', +'さゆう', +'さよう', +'さよく', +'さらだ', +'ざるそば', +'さわやか', +'さわる', +'さんいん', +'さんか', +'さんきゃく', +'さんこう', +'さんさい', +'ざんしょ', +'さんすう', +'さんせい', +'さんそ', +'さんち', +'さんま', +'さんみ', +'さんらん', +'しあい', +'しあげ', +'しあさって', +'しあわせ', +'しいく', +'しいん', +'しうち', +'しえい', +'しおけ', +'しかい', +'しかく', +'じかん', +'しごと', +'しすう', +'じだい', +'したうけ', +'したぎ', +'したて', +'したみ', +'しちょう', +'しちりん', +'しっかり', +'しつじ', +'しつもん', +'してい', +'してき', +'してつ', +'じてん', +'じどう', +'しなぎれ', +'しなもの', +'しなん', +'しねま', +'しねん', +'しのぐ', +'しのぶ', +'しはい', +'しばかり', +'しはつ', +'しはらい', +'しはん', +'しひょう', +'しふく', +'じぶん', +'しへい', +'しほう', +'しほん', +'しまう', +'しまる', +'しみん', +'しむける', +'じむしょ', +'しめい', +'しめる', +'しもん', +'しゃいん', +'しゃうん', +'しゃおん', +'じゃがいも', +'しやくしょ', +'しゃくほう', +'しゃけん', +'しゃこ', +'しゃざい', +'しゃしん', +'しゃせん', +'しゃそう', +'しゃたい', +'しゃちょう', +'しゃっきん', +'じゃま', +'しゃりん', +'しゃれい', +'じゆう', +'じゅうしょ', +'しゅくはく', +'じゅしん', +'しゅっせき', +'しゅみ', +'しゅらば', +'じゅんばん', +'しょうかい', +'しょくたく', +'しょっけん', +'しょどう', +'しょもつ', +'しらせる', +'しらべる', +'しんか', +'しんこう', +'じんじゃ', +'しんせいじ', +'しんちく', +'しんりん', +'すあげ', +'すあし', +'すあな', +'ずあん', +'すいえい', +'すいか', +'すいとう', +'ずいぶん', +'すいようび', +'すうがく', +'すうじつ', +'すうせん', +'すおどり', +'すきま', +'すくう', +'すくない', +'すける', +'すごい', +'すこし', +'ずさん', +'すずしい', +'すすむ', +'すすめる', +'すっかり', +'ずっしり', +'ずっと', +'すてき', +'すてる', +'すねる', +'すのこ', +'すはだ', +'すばらしい', +'ずひょう', +'ずぶぬれ', +'すぶり', +'すふれ', +'すべて', +'すべる', +'ずほう', +'すぼん', +'すまい', +'すめし', +'すもう', +'すやき', +'すらすら', +'するめ', +'すれちがう', +'すろっと', +'すわる', +'すんぜん', +'すんぽう', +'せあぶら', +'せいかつ', +'せいげん', +'せいじ', +'せいよう', +'せおう', +'せかいかん', +'せきにん', +'せきむ', +'せきゆ', +'せきらんうん', +'せけん', +'せこう', +'せすじ', +'せたい', +'せたけ', +'せっかく', +'せっきゃく', +'ぜっく', +'せっけん', +'せっこつ', +'せっさたくま', +'せつぞく', +'せつだん', +'せつでん', +'せっぱん', +'せつび', +'せつぶん', +'せつめい', +'せつりつ', +'せなか', +'せのび', +'せはば', +'せびろ', +'せぼね', +'せまい', +'せまる', +'せめる', +'せもたれ', +'せりふ', +'ぜんあく', +'せんい', +'せんえい', +'せんか', +'せんきょ', +'せんく', +'せんげん', +'ぜんご', +'せんさい', +'せんしゅ', +'せんすい', +'せんせい', +'せんぞ', +'せんたく', +'せんちょう', +'せんてい', +'せんとう', +'せんぬき', +'せんねん', +'せんぱい', +'ぜんぶ', +'ぜんぽう', +'せんむ', +'せんめんじょ', +'せんもん', +'せんやく', +'せんゆう', +'せんよう', +'ぜんら', +'ぜんりゃく', +'せんれい', +'せんろ', +'そあく', +'そいとげる', +'そいね', +'そうがんきょう', +'そうき', +'そうご', +'そうしん', +'そうだん', +'そうなん', +'そうび', +'そうめん', +'そうり', +'そえもの', +'そえん', +'そがい', +'そげき', +'そこう', +'そこそこ', +'そざい', +'そしな', +'そせい', +'そせん', +'そそぐ', +'そだてる', +'そつう', +'そつえん', +'そっかん', +'そつぎょう', +'そっけつ', +'そっこう', +'そっせん', +'そっと', +'そとがわ', +'そとづら', +'そなえる', +'そなた', +'そふぼ', +'そぼく', +'そぼろ', +'そまつ', +'そまる', +'そむく', +'そむりえ', +'そめる', +'そもそも', +'そよかぜ', +'そらまめ', +'そろう', +'そんかい', +'そんけい', +'そんざい', +'そんしつ', +'そんぞく', +'そんちょう', +'ぞんび', +'ぞんぶん', +'そんみん', +'たあい', +'たいいん', +'たいうん', +'たいえき', +'たいおう', +'だいがく', +'たいき', +'たいぐう', +'たいけん', +'たいこ', +'たいざい', +'だいじょうぶ', +'だいすき', +'たいせつ', +'たいそう', +'だいたい', +'たいちょう', +'たいてい', +'だいどころ', +'たいない', +'たいねつ', +'たいのう', +'たいはん', +'だいひょう', +'たいふう', +'たいへん', +'たいほ', +'たいまつばな', +'たいみんぐ', +'たいむ', +'たいめん', +'たいやき', +'たいよう', +'たいら', +'たいりょく', +'たいる', +'たいわん', +'たうえ', +'たえる', +'たおす', +'たおる', +'たおれる', +'たかい', +'たかね', +'たきび', +'たくさん', +'たこく', +'たこやき', +'たさい', +'たしざん', +'だじゃれ', +'たすける', +'たずさわる', +'たそがれ', +'たたかう', +'たたく', +'ただしい', +'たたみ', +'たちばな', +'だっかい', +'だっきゃく', +'だっこ', +'だっしゅつ', +'だったい', +'たてる', +'たとえる', +'たなばた', +'たにん', +'たぬき', +'たのしみ', +'たはつ', +'たぶん', +'たべる', +'たぼう', +'たまご', +'たまる', +'だむる', +'ためいき', +'ためす', +'ためる', +'たもつ', +'たやすい', +'たよる', +'たらす', +'たりきほんがん', +'たりょう', +'たりる', +'たると', +'たれる', +'たれんと', +'たろっと', +'たわむれる', +'だんあつ', +'たんい', +'たんおん', +'たんか', +'たんき', +'たんけん', +'たんご', +'たんさん', +'たんじょうび', +'だんせい', +'たんそく', +'たんたい', +'だんち', +'たんてい', +'たんとう', +'だんな', +'たんにん', +'だんねつ', +'たんのう', +'たんぴん', +'だんぼう', +'たんまつ', +'たんめい', +'だんれつ', +'だんろ', +'だんわ', +'ちあい', +'ちあん', +'ちいき', +'ちいさい', +'ちえん', +'ちかい', +'ちから', +'ちきゅう', +'ちきん', +'ちけいず', +'ちけん', +'ちこく', +'ちさい', +'ちしき', +'ちしりょう', +'ちせい', +'ちそう', +'ちたい', +'ちたん', +'ちちおや', +'ちつじょ', +'ちてき', +'ちてん', +'ちぬき', +'ちぬり', +'ちのう', +'ちひょう', +'ちへいせん', +'ちほう', +'ちまた', +'ちみつ', +'ちみどろ', +'ちめいど', +'ちゃんこなべ', +'ちゅうい', +'ちゆりょく', +'ちょうし', +'ちょさくけん', +'ちらし', +'ちらみ', +'ちりがみ', +'ちりょう', +'ちるど', +'ちわわ', +'ちんたい', +'ちんもく', +'ついか', +'ついたち', +'つうか', +'つうじょう', +'つうはん', +'つうわ', +'つかう', +'つかれる', +'つくね', +'つくる', +'つけね', +'つける', +'つごう', +'つたえる', +'つづく', +'つつじ', +'つつむ', +'つとめる', +'つながる', +'つなみ', +'つねづね', +'つのる', +'つぶす', +'つまらない', +'つまる', +'つみき', +'つめたい', +'つもり', +'つもる', +'つよい', +'つるぼ', +'つるみく', +'つわもの', +'つわり', +'てあし', +'てあて', +'てあみ', +'ていおん', +'ていか', +'ていき', +'ていけい', +'ていこく', +'ていさつ', +'ていし', +'ていせい', +'ていたい', +'ていど', +'ていねい', +'ていひょう', +'ていへん', +'ていぼう', +'てうち', +'ておくれ', +'てきとう', +'てくび', +'でこぼこ', +'てさぎょう', +'てさげ', +'てすり', +'てそう', +'てちがい', +'てちょう', +'てつがく', +'てつづき', +'でっぱ', +'てつぼう', +'てつや', +'でぬかえ', +'てぬき', +'てぬぐい', +'てのひら', +'てはい', +'てぶくろ', +'てふだ', +'てほどき', +'てほん', +'てまえ', +'てまきずし', +'てみじか', +'てみやげ', +'てらす', +'てれび', +'てわけ', +'てわたし', +'でんあつ', +'てんいん', +'てんかい', +'てんき', +'てんぐ', +'てんけん', +'てんごく', +'てんさい', +'てんし', +'てんすう', +'でんち', +'てんてき', +'てんとう', +'てんない', +'てんぷら', +'てんぼうだい', +'てんめつ', +'てんらんかい', +'でんりょく', +'でんわ', +'どあい', +'といれ', +'どうかん', +'とうきゅう', +'どうぐ', +'とうし', +'とうむぎ', +'とおい', +'とおか', +'とおく', +'とおす', +'とおる', +'とかい', +'とかす', +'ときおり', +'ときどき', +'とくい', +'とくしゅう', +'とくてん', +'とくに', +'とくべつ', +'とけい', +'とける', +'とこや', +'とさか', +'としょかん', +'とそう', +'とたん', +'とちゅう', +'とっきゅう', +'とっくん', +'とつぜん', +'とつにゅう', +'とどける', +'ととのえる', +'とない', +'となえる', +'となり', +'とのさま', +'とばす', +'どぶがわ', +'とほう', +'とまる', +'とめる', +'ともだち', +'ともる', +'どようび', +'とらえる', +'とんかつ', +'どんぶり', +'ないかく', +'ないこう', +'ないしょ', +'ないす', +'ないせん', +'ないそう', +'なおす', +'ながい', +'なくす', +'なげる', +'なこうど', +'なさけ', +'なたでここ', +'なっとう', +'なつやすみ', +'ななおし', +'なにごと', +'なにもの', +'なにわ', +'なのか', +'なふだ', +'なまいき', +'なまえ', +'なまみ', +'なみだ', +'なめらか', +'なめる', +'なやむ', +'ならう', +'ならび', +'ならぶ', +'なれる', +'なわとび', +'なわばり', +'にあう', +'にいがた', +'にうけ', +'におい', +'にかい', +'にがて', +'にきび', +'にくしみ', +'にくまん', +'にげる', +'にさんかたんそ', +'にしき', +'にせもの', +'にちじょう', +'にちようび', +'にっか', +'にっき', +'にっけい', +'にっこう', +'にっさん', +'にっしょく', +'にっすう', +'にっせき', +'にってい', +'になう', +'にほん', +'にまめ', +'にもつ', +'にやり', +'にゅういん', +'にりんしゃ', +'にわとり', +'にんい', +'にんか', +'にんき', +'にんげん', +'にんしき', +'にんずう', +'にんそう', +'にんたい', +'にんち', +'にんてい', +'にんにく', +'にんぷ', +'にんまり', +'にんむ', +'にんめい', +'にんよう', +'ぬいくぎ', +'ぬかす', +'ぬぐいとる', +'ぬぐう', +'ぬくもり', +'ぬすむ', +'ぬまえび', +'ぬめり', +'ぬらす', +'ぬんちゃく', +'ねあげ', +'ねいき', +'ねいる', +'ねいろ', +'ねぐせ', +'ねくたい', +'ねくら', +'ねこぜ', +'ねこむ', +'ねさげ', +'ねすごす', +'ねそべる', +'ねだん', +'ねつい', +'ねっしん', +'ねつぞう', +'ねったいぎょ', +'ねぶそく', +'ねふだ', +'ねぼう', +'ねほりはほり', +'ねまき', +'ねまわし', +'ねみみ', +'ねむい', +'ねむたい', +'ねもと', +'ねらう', +'ねわざ', +'ねんいり', +'ねんおし', +'ねんかん', +'ねんきん', +'ねんぐ', +'ねんざ', +'ねんし', +'ねんちゃく', +'ねんど', +'ねんぴ', +'ねんぶつ', +'ねんまつ', +'ねんりょう', +'ねんれい', +'のいず', +'のおづま', +'のがす', +'のきなみ', +'のこぎり', +'のこす', +'のこる', +'のせる', +'のぞく', +'のぞむ', +'のたまう', +'のちほど', +'のっく', +'のばす', +'のはら', +'のべる', +'のぼる', +'のみもの', +'のやま', +'のらいぬ', +'のらねこ', +'のりもの', +'のりゆき', +'のれん', +'のんき', +'ばあい', +'はあく', +'ばあさん', +'ばいか', +'ばいく', +'はいけん', +'はいご', +'はいしん', +'はいすい', +'はいせん', +'はいそう', +'はいち', +'ばいばい', +'はいれつ', +'はえる', +'はおる', +'はかい', +'ばかり', +'はかる', +'はくしゅ', +'はけん', +'はこぶ', +'はさみ', +'はさん', +'はしご', +'ばしょ', +'はしる', +'はせる', +'ぱそこん', +'はそん', +'はたん', +'はちみつ', +'はつおん', +'はっかく', +'はづき', +'はっきり', +'はっくつ', +'はっけん', +'はっこう', +'はっさん', +'はっしん', +'はったつ', +'はっちゅう', +'はってん', +'はっぴょう', +'はっぽう', +'はなす', +'はなび', +'はにかむ', +'はぶらし', +'はみがき', +'はむかう', +'はめつ', +'はやい', +'はやし', +'はらう', +'はろうぃん', +'はわい', +'はんい', +'はんえい', +'はんおん', +'はんかく', +'はんきょう', +'ばんぐみ', +'はんこ', +'はんしゃ', +'はんすう', +'はんだん', +'ぱんち', +'ぱんつ', +'はんてい', +'はんとし', +'はんのう', +'はんぱ', +'はんぶん', +'はんぺん', +'はんぼうき', +'はんめい', +'はんらん', +'はんろん', +'ひいき', +'ひうん', +'ひえる', +'ひかく', +'ひかり', +'ひかる', +'ひかん', +'ひくい', +'ひけつ', +'ひこうき', +'ひこく', +'ひさい', +'ひさしぶり', +'ひさん', +'びじゅつかん', +'ひしょ', +'ひそか', +'ひそむ', +'ひたむき', +'ひだり', +'ひたる', +'ひつぎ', +'ひっこし', +'ひっし', +'ひつじゅひん', +'ひっす', +'ひつぜん', +'ぴったり', +'ぴっちり', +'ひつよう', +'ひてい', +'ひとごみ', +'ひなまつり', +'ひなん', +'ひねる', +'ひはん', +'ひびく', +'ひひょう', +'ひほう', +'ひまわり', +'ひまん', +'ひみつ', +'ひめい', +'ひめじし', +'ひやけ', +'ひやす', +'ひよう', +'びょうき', +'ひらがな', +'ひらく', +'ひりつ', +'ひりょう', +'ひるま', +'ひるやすみ', +'ひれい', +'ひろい', +'ひろう', +'ひろき', +'ひろゆき', +'ひんかく', +'ひんけつ', +'ひんこん', +'ひんしゅ', +'ひんそう', +'ぴんち', +'ひんぱん', +'びんぼう', +'ふあん', +'ふいうち', +'ふうけい', +'ふうせん', +'ぷうたろう', +'ふうとう', +'ふうふ', +'ふえる', +'ふおん', +'ふかい', +'ふきん', +'ふくざつ', +'ふくぶくろ', +'ふこう', +'ふさい', +'ふしぎ', +'ふじみ', +'ふすま', +'ふせい', +'ふせぐ', +'ふそく', +'ぶたにく', +'ふたん', +'ふちょう', +'ふつう', +'ふつか', +'ふっかつ', +'ふっき', +'ふっこく', +'ぶどう', +'ふとる', +'ふとん', +'ふのう', +'ふはい', +'ふひょう', +'ふへん', +'ふまん', +'ふみん', +'ふめつ', +'ふめん', +'ふよう', +'ふりこ', +'ふりる', +'ふるい', +'ふんいき', +'ぶんがく', +'ぶんぐ', +'ふんしつ', +'ぶんせき', +'ふんそう', +'ぶんぽう', +'へいあん', +'へいおん', +'へいがい', +'へいき', +'へいげん', +'へいこう', +'へいさ', +'へいしゃ', +'へいせつ', +'へいそ', +'へいたく', +'へいてん', +'へいねつ', +'へいわ', +'へきが', +'へこむ', +'べにいろ', +'べにしょうが', +'へらす', +'へんかん', +'べんきょう', +'べんごし', +'へんさい', +'へんたい', +'べんり', +'ほあん', +'ほいく', +'ぼうぎょ', +'ほうこく', +'ほうそう', +'ほうほう', +'ほうもん', +'ほうりつ', +'ほえる', +'ほおん', +'ほかん', +'ほきょう', +'ぼきん', +'ほくろ', +'ほけつ', +'ほけん', +'ほこう', +'ほこる', +'ほしい', +'ほしつ', +'ほしゅ', +'ほしょう', +'ほせい', +'ほそい', +'ほそく', +'ほたて', +'ほたる', +'ぽちぶくろ', +'ほっきょく', +'ほっさ', +'ほったん', +'ほとんど', +'ほめる', +'ほんい', +'ほんき', +'ほんけ', +'ほんしつ', +'ほんやく', +'まいにち', +'まかい', +'まかせる', +'まがる', +'まける', +'まこと', +'まさつ', +'まじめ', +'ますく', +'まぜる', +'まつり', +'まとめ', +'まなぶ', +'まぬけ', +'まねく', +'まほう', +'まもる', +'まゆげ', +'まよう', +'まろやか', +'まわす', +'まわり', +'まわる', +'まんが', +'まんきつ', +'まんぞく', +'まんなか', +'みいら', +'みうち', +'みえる', +'みがく', +'みかた', +'みかん', +'みけん', +'みこん', +'みじかい', +'みすい', +'みすえる', +'みせる', +'みっか', +'みつかる', +'みつける', +'みてい', +'みとめる', +'みなと', +'みなみかさい', +'みねらる', +'みのう', +'みのがす', +'みほん', +'みもと', +'みやげ', +'みらい', +'みりょく', +'みわく', +'みんか', +'みんぞく', +'むいか', +'むえき', +'むえん', +'むかい', +'むかう', +'むかえ', +'むかし', +'むぎちゃ', +'むける', +'むげん', +'むさぼる', +'むしあつい', +'むしば', +'むじゅん', +'むしろ', +'むすう', +'むすこ', +'むすぶ', +'むすめ', +'むせる', +'むせん', +'むちゅう', +'むなしい', +'むのう', +'むやみ', +'むよう', +'むらさき', +'むりょう', +'むろん', +'めいあん', +'めいうん', +'めいえん', +'めいかく', +'めいきょく', +'めいさい', +'めいし', +'めいそう', +'めいぶつ', +'めいれい', +'めいわく', +'めぐまれる', +'めざす', +'めした', +'めずらしい', +'めだつ', +'めまい', +'めやす', +'めんきょ', +'めんせき', +'めんどう', +'もうしあげる', +'もうどうけん', +'もえる', +'もくし', +'もくてき', +'もくようび', +'もちろん', +'もどる', +'もらう', +'もんく', +'もんだい', +'やおや', +'やける', +'やさい', +'やさしい', +'やすい', +'やすたろう', +'やすみ', +'やせる', +'やそう', +'やたい', +'やちん', +'やっと', +'やっぱり', +'やぶる', +'やめる', +'ややこしい', +'やよい', +'やわらかい', +'ゆうき', +'ゆうびんきょく', +'ゆうべ', +'ゆうめい', +'ゆけつ', +'ゆしゅつ', +'ゆせん', +'ゆそう', +'ゆたか', +'ゆちゃく', +'ゆでる', +'ゆにゅう', +'ゆびわ', +'ゆらい', +'ゆれる', +'ようい', +'ようか', +'ようきゅう', +'ようじ', +'ようす', +'ようちえん', +'よかぜ', +'よかん', +'よきん', +'よくせい', +'よくぼう', +'よけい', +'よごれる', +'よさん', +'よしゅう', +'よそう', +'よそく', +'よっか', +'よてい', +'よどがわく', +'よねつ', +'よやく', +'よゆう', +'よろこぶ', +'よろしい', +'らいう', +'らくがき', +'らくご', +'らくさつ', +'らくだ', +'らしんばん', +'らせん', +'らぞく', +'らたい', +'らっか', +'られつ', +'りえき', +'りかい', +'りきさく', +'りきせつ', +'りくぐん', +'りくつ', +'りけん', +'りこう', +'りせい', +'りそう', +'りそく', +'りてん', +'りねん', +'りゆう', +'りゅうがく', +'りよう', +'りょうり', +'りょかん', +'りょくちゃ', +'りょこう', +'りりく', +'りれき', +'りろん', +'りんご', +'るいけい', +'るいさい', +'るいじ', +'るいせき', +'るすばん', +'るりがわら', +'れいかん', +'れいぎ', +'れいせい', +'れいぞうこ', +'れいとう', +'れいぼう', +'れきし', +'れきだい', +'れんあい', +'れんけい', +'れんこん', +'れんさい', +'れんしゅう', +'れんぞく', +'れんらく', +'ろうか', +'ろうご', +'ろうじん', +'ろうそく', +'ろくが', +'ろこつ', +'ろじうら', +'ろしゅつ', +'ろせん', +'ろてん', +'ろめん', +'ろれつ', +'ろんぎ', +'ろんぱ', +'ろんぶん', +'ろんり', +'わかす', +'わかめ', +'わかやま', +'わかれる', +'わしつ', +'わじまし', +'わすれもの', +'わらう', +'われる' +] diff --git a/torba/words/japanese.txt b/torba/words/japanese.txt deleted file mode 100644 index c4c9dca4e..000000000 --- a/torba/words/japanese.txt +++ /dev/null @@ -1,2048 +0,0 @@ -あいこくしん -あいさつ -あいだ -あおぞら -あかちゃん -あきる -あけがた -あける -あこがれる -あさい -あさひ -あしあと -あじわう -あずかる -あずき -あそぶ -あたえる -あたためる -あたりまえ -あたる -あつい -あつかう -あっしゅく -あつまり -あつめる -あてな -あてはまる -あひる -あぶら -あぶる -あふれる -あまい -あまど -あまやかす -あまり -あみもの -あめりか -あやまる -あゆむ -あらいぐま -あらし -あらすじ -あらためる -あらゆる -あらわす -ありがとう -あわせる -あわてる -あんい -あんがい -あんこ -あんぜん -あんてい -あんない -あんまり -いいだす -いおん -いがい -いがく -いきおい -いきなり -いきもの -いきる -いくじ -いくぶん -いけばな -いけん -いこう -いこく -いこつ -いさましい -いさん -いしき -いじゅう -いじょう -いじわる -いずみ -いずれ -いせい -いせえび -いせかい -いせき -いぜん -いそうろう -いそがしい -いだい -いだく -いたずら -いたみ -いたりあ -いちおう -いちじ -いちど -いちば -いちぶ -いちりゅう -いつか -いっしゅん -いっせい -いっそう -いったん -いっち -いってい -いっぽう -いてざ -いてん -いどう -いとこ -いない -いなか -いねむり -いのち -いのる -いはつ -いばる -いはん -いびき -いひん -いふく -いへん -いほう -いみん -いもうと -いもたれ -いもり -いやがる -いやす -いよかん -いよく -いらい -いらすと -いりぐち -いりょう -いれい -いれもの -いれる -いろえんぴつ -いわい -いわう -いわかん -いわば -いわゆる -いんげんまめ -いんさつ -いんしょう -いんよう -うえき -うえる -うおざ -うがい -うかぶ -うかべる -うきわ -うくらいな -うくれれ -うけたまわる -うけつけ -うけとる -うけもつ -うける -うごかす -うごく -うこん -うさぎ -うしなう -うしろがみ -うすい -うすぎ -うすぐらい -うすめる -うせつ -うちあわせ -うちがわ -うちき -うちゅう -うっかり -うつくしい -うったえる -うつる -うどん -うなぎ -うなじ -うなずく -うなる -うねる -うのう -うぶげ -うぶごえ -うまれる -うめる -うもう -うやまう -うよく -うらがえす -うらぐち -うらない -うりあげ -うりきれ -うるさい -うれしい -うれゆき -うれる -うろこ -うわき -うわさ -うんこう -うんちん -うんてん -うんどう -えいえん -えいが -えいきょう -えいご -えいせい -えいぶん -えいよう -えいわ -えおり -えがお -えがく -えきたい -えくせる -えしゃく -えすて -えつらん -えのぐ -えほうまき -えほん -えまき -えもじ -えもの -えらい -えらぶ -えりあ -えんえん -えんかい -えんぎ -えんげき -えんしゅう -えんぜつ -えんそく -えんちょう -えんとつ -おいかける -おいこす -おいしい -おいつく -おうえん -おうさま -おうじ -おうせつ -おうたい -おうふく -おうべい -おうよう -おえる -おおい -おおう -おおどおり -おおや -おおよそ -おかえり -おかず -おがむ -おかわり -おぎなう -おきる -おくさま -おくじょう -おくりがな -おくる -おくれる -おこす -おこなう -おこる -おさえる -おさない -おさめる -おしいれ -おしえる -おじぎ -おじさん -おしゃれ -おそらく -おそわる -おたがい -おたく -おだやか -おちつく -おっと -おつり -おでかけ -おとしもの -おとなしい -おどり -おどろかす -おばさん -おまいり -おめでとう -おもいで -おもう -おもたい -おもちゃ -おやつ -おやゆび -およぼす -おらんだ -おろす -おんがく -おんけい -おんしゃ -おんせん -おんだん -おんちゅう -おんどけい -かあつ -かいが -がいき -がいけん -がいこう -かいさつ -かいしゃ -かいすいよく -かいぜん -かいぞうど -かいつう -かいてん -かいとう -かいふく -がいへき -かいほう -かいよう -がいらい -かいわ -かえる -かおり -かかえる -かがく -かがし -かがみ -かくご -かくとく -かざる -がぞう -かたい -かたち -がちょう -がっきゅう -がっこう -がっさん -がっしょう -かなざわし -かのう -がはく -かぶか -かほう -かほご -かまう -かまぼこ -かめれおん -かゆい -かようび -からい -かるい -かろう -かわく -かわら -がんか -かんけい -かんこう -かんしゃ -かんそう -かんたん -かんち -がんばる -きあい -きあつ -きいろ -ぎいん -きうい -きうん -きえる -きおう -きおく -きおち -きおん -きかい -きかく -きかんしゃ -ききて -きくばり -きくらげ -きけんせい -きこう -きこえる -きこく -きさい -きさく -きさま -きさらぎ -ぎじかがく -ぎしき -ぎじたいけん -ぎじにってい -ぎじゅつしゃ -きすう -きせい -きせき -きせつ -きそう -きぞく -きぞん -きたえる -きちょう -きつえん -ぎっちり -きつつき -きつね -きてい -きどう -きどく -きない -きなが -きなこ -きぬごし -きねん -きのう -きのした -きはく -きびしい -きひん -きふく -きぶん -きぼう -きほん -きまる -きみつ -きむずかしい -きめる -きもだめし -きもち -きもの -きゃく -きやく -ぎゅうにく -きよう -きょうりゅう -きらい -きらく -きりん -きれい -きれつ -きろく -ぎろん -きわめる -ぎんいろ -きんかくじ -きんじょ -きんようび -ぐあい -くいず -くうかん -くうき -くうぐん -くうこう -ぐうせい -くうそう -ぐうたら -くうふく -くうぼ -くかん -くきょう -くげん -ぐこう -くさい -くさき -くさばな -くさる -くしゃみ -くしょう -くすのき -くすりゆび -くせげ -くせん -ぐたいてき -くださる -くたびれる -くちこみ -くちさき -くつした -ぐっすり -くつろぐ -くとうてん -くどく -くなん -くねくね -くのう -くふう -くみあわせ -くみたてる -くめる -くやくしょ -くらす -くらべる -くるま -くれる -くろう -くわしい -ぐんかん -ぐんしょく -ぐんたい -ぐんて -けあな -けいかく -けいけん -けいこ -けいさつ -げいじゅつ -けいたい -げいのうじん -けいれき -けいろ -けおとす -けおりもの -げきか -げきげん -げきだん -げきちん -げきとつ -げきは -げきやく -げこう -げこくじょう -げざい -けさき -げざん -けしき -けしごむ -けしょう -げすと -けたば -けちゃっぷ -けちらす -けつあつ -けつい -けつえき -けっこん -けつじょ -けっせき -けってい -けつまつ -げつようび -げつれい -けつろん -げどく -けとばす -けとる -けなげ -けなす -けなみ -けぬき -げねつ -けねん -けはい -げひん -けぶかい -げぼく -けまり -けみかる -けむし -けむり -けもの -けらい -けろけろ -けわしい -けんい -けんえつ -けんお -けんか -げんき -けんげん -けんこう -けんさく -けんしゅう -けんすう -げんそう -けんちく -けんてい -けんとう -けんない -けんにん -げんぶつ -けんま -けんみん -けんめい -けんらん -けんり -こあくま -こいぬ -こいびと -ごうい -こうえん -こうおん -こうかん -ごうきゅう -ごうけい -こうこう -こうさい -こうじ -こうすい -ごうせい -こうそく -こうたい -こうちゃ -こうつう -こうてい -こうどう -こうない -こうはい -ごうほう -ごうまん -こうもく -こうりつ -こえる -こおり -ごかい -ごがつ -ごかん -こくご -こくさい -こくとう -こくない -こくはく -こぐま -こけい -こける -ここのか -こころ -こさめ -こしつ -こすう -こせい -こせき -こぜん -こそだて -こたい -こたえる -こたつ -こちょう -こっか -こつこつ -こつばん -こつぶ -こてい -こてん -ことがら -ことし -ことば -ことり -こなごな -こねこね -このまま -このみ -このよ -ごはん -こひつじ -こふう -こふん -こぼれる -ごまあぶら -こまかい -ごますり -こまつな -こまる -こむぎこ -こもじ -こもち -こもの -こもん -こやく -こやま -こゆう -こゆび -こよい -こよう -こりる -これくしょん -ころっけ -こわもて -こわれる -こんいん -こんかい -こんき -こんしゅう -こんすい -こんだて -こんとん -こんなん -こんびに -こんぽん -こんまけ -こんや -こんれい -こんわく -ざいえき -さいかい -さいきん -ざいげん -ざいこ -さいしょ -さいせい -ざいたく -ざいちゅう -さいてき -ざいりょう -さうな -さかいし -さがす -さかな -さかみち -さがる -さぎょう -さくし -さくひん -さくら -さこく -さこつ -さずかる -ざせき -さたん -さつえい -ざつおん -ざっか -ざつがく -さっきょく -ざっし -さつじん -ざっそう -さつたば -さつまいも -さてい -さといも -さとう -さとおや -さとし -さとる -さのう -さばく -さびしい -さべつ -さほう -さほど -さます -さみしい -さみだれ -さむけ -さめる -さやえんどう -さゆう -さよう -さよく -さらだ -ざるそば -さわやか -さわる -さんいん -さんか -さんきゃく -さんこう -さんさい -ざんしょ -さんすう -さんせい -さんそ -さんち -さんま -さんみ -さんらん -しあい -しあげ -しあさって -しあわせ -しいく -しいん -しうち -しえい -しおけ -しかい -しかく -じかん -しごと -しすう -じだい -したうけ -したぎ -したて -したみ -しちょう -しちりん -しっかり -しつじ -しつもん -してい -してき -してつ -じてん -じどう -しなぎれ -しなもの -しなん -しねま -しねん -しのぐ -しのぶ -しはい -しばかり -しはつ -しはらい -しはん -しひょう -しふく -じぶん -しへい -しほう -しほん -しまう -しまる -しみん -しむける -じむしょ -しめい -しめる -しもん -しゃいん -しゃうん -しゃおん -じゃがいも -しやくしょ -しゃくほう -しゃけん -しゃこ -しゃざい -しゃしん -しゃせん -しゃそう -しゃたい -しゃちょう -しゃっきん -じゃま -しゃりん -しゃれい -じゆう -じゅうしょ -しゅくはく -じゅしん -しゅっせき -しゅみ -しゅらば -じゅんばん -しょうかい -しょくたく -しょっけん -しょどう -しょもつ -しらせる -しらべる -しんか -しんこう -じんじゃ -しんせいじ -しんちく -しんりん -すあげ -すあし -すあな -ずあん -すいえい -すいか -すいとう -ずいぶん -すいようび -すうがく -すうじつ -すうせん -すおどり -すきま -すくう -すくない -すける -すごい -すこし -ずさん -すずしい -すすむ -すすめる -すっかり -ずっしり -ずっと -すてき -すてる -すねる -すのこ -すはだ -すばらしい -ずひょう -ずぶぬれ -すぶり -すふれ -すべて -すべる -ずほう -すぼん -すまい -すめし -すもう -すやき -すらすら -するめ -すれちがう -すろっと -すわる -すんぜん -すんぽう -せあぶら -せいかつ -せいげん -せいじ -せいよう -せおう -せかいかん -せきにん -せきむ -せきゆ -せきらんうん -せけん -せこう -せすじ -せたい -せたけ -せっかく -せっきゃく -ぜっく -せっけん -せっこつ -せっさたくま -せつぞく -せつだん -せつでん -せっぱん -せつび -せつぶん -せつめい -せつりつ -せなか -せのび -せはば -せびろ -せぼね -せまい -せまる -せめる -せもたれ -せりふ -ぜんあく -せんい -せんえい -せんか -せんきょ -せんく -せんげん -ぜんご -せんさい -せんしゅ -せんすい -せんせい -せんぞ -せんたく -せんちょう -せんてい -せんとう -せんぬき -せんねん -せんぱい -ぜんぶ -ぜんぽう -せんむ -せんめんじょ -せんもん -せんやく -せんゆう -せんよう -ぜんら -ぜんりゃく -せんれい -せんろ -そあく -そいとげる -そいね -そうがんきょう -そうき -そうご -そうしん -そうだん -そうなん -そうび -そうめん -そうり -そえもの -そえん -そがい -そげき -そこう -そこそこ -そざい -そしな -そせい -そせん -そそぐ -そだてる -そつう -そつえん -そっかん -そつぎょう -そっけつ -そっこう -そっせん -そっと -そとがわ -そとづら -そなえる -そなた -そふぼ -そぼく -そぼろ -そまつ -そまる -そむく -そむりえ -そめる -そもそも -そよかぜ -そらまめ -そろう -そんかい -そんけい -そんざい -そんしつ -そんぞく -そんちょう -ぞんび -ぞんぶん -そんみん -たあい -たいいん -たいうん -たいえき -たいおう -だいがく -たいき -たいぐう -たいけん -たいこ -たいざい -だいじょうぶ -だいすき -たいせつ -たいそう -だいたい -たいちょう -たいてい -だいどころ -たいない -たいねつ -たいのう -たいはん -だいひょう -たいふう -たいへん -たいほ -たいまつばな -たいみんぐ -たいむ -たいめん -たいやき -たいよう -たいら -たいりょく -たいる -たいわん -たうえ -たえる -たおす -たおる -たおれる -たかい -たかね -たきび -たくさん -たこく -たこやき -たさい -たしざん -だじゃれ -たすける -たずさわる -たそがれ -たたかう -たたく -ただしい -たたみ -たちばな -だっかい -だっきゃく -だっこ -だっしゅつ -だったい -たてる -たとえる -たなばた -たにん -たぬき -たのしみ -たはつ -たぶん -たべる -たぼう -たまご -たまる -だむる -ためいき -ためす -ためる -たもつ -たやすい -たよる -たらす -たりきほんがん -たりょう -たりる -たると -たれる -たれんと -たろっと -たわむれる -だんあつ -たんい -たんおん -たんか -たんき -たんけん -たんご -たんさん -たんじょうび -だんせい -たんそく -たんたい -だんち -たんてい -たんとう -だんな -たんにん -だんねつ -たんのう -たんぴん -だんぼう -たんまつ -たんめい -だんれつ -だんろ -だんわ -ちあい -ちあん -ちいき -ちいさい -ちえん -ちかい -ちから -ちきゅう -ちきん -ちけいず -ちけん -ちこく -ちさい -ちしき -ちしりょう -ちせい -ちそう -ちたい -ちたん -ちちおや -ちつじょ -ちてき -ちてん -ちぬき -ちぬり -ちのう -ちひょう -ちへいせん -ちほう -ちまた -ちみつ -ちみどろ -ちめいど -ちゃんこなべ -ちゅうい -ちゆりょく -ちょうし -ちょさくけん -ちらし -ちらみ -ちりがみ -ちりょう -ちるど -ちわわ -ちんたい -ちんもく -ついか -ついたち -つうか -つうじょう -つうはん -つうわ -つかう -つかれる -つくね -つくる -つけね -つける -つごう -つたえる -つづく -つつじ -つつむ -つとめる -つながる -つなみ -つねづね -つのる -つぶす -つまらない -つまる -つみき -つめたい -つもり -つもる -つよい -つるぼ -つるみく -つわもの -つわり -てあし -てあて -てあみ -ていおん -ていか -ていき -ていけい -ていこく -ていさつ -ていし -ていせい -ていたい -ていど -ていねい -ていひょう -ていへん -ていぼう -てうち -ておくれ -てきとう -てくび -でこぼこ -てさぎょう -てさげ -てすり -てそう -てちがい -てちょう -てつがく -てつづき -でっぱ -てつぼう -てつや -でぬかえ -てぬき -てぬぐい -てのひら -てはい -てぶくろ -てふだ -てほどき -てほん -てまえ -てまきずし -てみじか -てみやげ -てらす -てれび -てわけ -てわたし -でんあつ -てんいん -てんかい -てんき -てんぐ -てんけん -てんごく -てんさい -てんし -てんすう -でんち -てんてき -てんとう -てんない -てんぷら -てんぼうだい -てんめつ -てんらんかい -でんりょく -でんわ -どあい -といれ -どうかん -とうきゅう -どうぐ -とうし -とうむぎ -とおい -とおか -とおく -とおす -とおる -とかい -とかす -ときおり -ときどき -とくい -とくしゅう -とくてん -とくに -とくべつ -とけい -とける -とこや -とさか -としょかん -とそう -とたん -とちゅう -とっきゅう -とっくん -とつぜん -とつにゅう -とどける -ととのえる -とない -となえる -となり -とのさま -とばす -どぶがわ -とほう -とまる -とめる -ともだち -ともる -どようび -とらえる -とんかつ -どんぶり -ないかく -ないこう -ないしょ -ないす -ないせん -ないそう -なおす -ながい -なくす -なげる -なこうど -なさけ -なたでここ -なっとう -なつやすみ -ななおし -なにごと -なにもの -なにわ -なのか -なふだ -なまいき -なまえ -なまみ -なみだ -なめらか -なめる -なやむ -ならう -ならび -ならぶ -なれる -なわとび -なわばり -にあう -にいがた -にうけ -におい -にかい -にがて -にきび -にくしみ -にくまん -にげる -にさんかたんそ -にしき -にせもの -にちじょう -にちようび -にっか -にっき -にっけい -にっこう -にっさん -にっしょく -にっすう -にっせき -にってい -になう -にほん -にまめ -にもつ -にやり -にゅういん -にりんしゃ -にわとり -にんい -にんか -にんき -にんげん -にんしき -にんずう -にんそう -にんたい -にんち -にんてい -にんにく -にんぷ -にんまり -にんむ -にんめい -にんよう -ぬいくぎ -ぬかす -ぬぐいとる -ぬぐう -ぬくもり -ぬすむ -ぬまえび -ぬめり -ぬらす -ぬんちゃく -ねあげ -ねいき -ねいる -ねいろ -ねぐせ -ねくたい -ねくら -ねこぜ -ねこむ -ねさげ -ねすごす -ねそべる -ねだん -ねつい -ねっしん -ねつぞう -ねったいぎょ -ねぶそく -ねふだ -ねぼう -ねほりはほり -ねまき -ねまわし -ねみみ -ねむい -ねむたい -ねもと -ねらう -ねわざ -ねんいり -ねんおし -ねんかん -ねんきん -ねんぐ -ねんざ -ねんし -ねんちゃく -ねんど -ねんぴ -ねんぶつ -ねんまつ -ねんりょう -ねんれい -のいず -のおづま -のがす -のきなみ -のこぎり -のこす -のこる -のせる -のぞく -のぞむ -のたまう -のちほど -のっく -のばす -のはら -のべる -のぼる -のみもの -のやま -のらいぬ -のらねこ -のりもの -のりゆき -のれん -のんき -ばあい -はあく -ばあさん -ばいか -ばいく -はいけん -はいご -はいしん -はいすい -はいせん -はいそう -はいち -ばいばい -はいれつ -はえる -はおる -はかい -ばかり -はかる -はくしゅ -はけん -はこぶ -はさみ -はさん -はしご -ばしょ -はしる -はせる -ぱそこん -はそん -はたん -はちみつ -はつおん -はっかく -はづき -はっきり -はっくつ -はっけん -はっこう -はっさん -はっしん -はったつ -はっちゅう -はってん -はっぴょう -はっぽう -はなす -はなび -はにかむ -はぶらし -はみがき -はむかう -はめつ -はやい -はやし -はらう -はろうぃん -はわい -はんい -はんえい -はんおん -はんかく -はんきょう -ばんぐみ -はんこ -はんしゃ -はんすう -はんだん -ぱんち -ぱんつ -はんてい -はんとし -はんのう -はんぱ -はんぶん -はんぺん -はんぼうき -はんめい -はんらん -はんろん -ひいき -ひうん -ひえる -ひかく -ひかり -ひかる -ひかん -ひくい -ひけつ -ひこうき -ひこく -ひさい -ひさしぶり -ひさん -びじゅつかん -ひしょ -ひそか -ひそむ -ひたむき -ひだり -ひたる -ひつぎ -ひっこし -ひっし -ひつじゅひん -ひっす -ひつぜん -ぴったり -ぴっちり -ひつよう -ひてい -ひとごみ -ひなまつり -ひなん -ひねる -ひはん -ひびく -ひひょう -ひほう -ひまわり -ひまん -ひみつ -ひめい -ひめじし -ひやけ -ひやす -ひよう -びょうき -ひらがな -ひらく -ひりつ -ひりょう -ひるま -ひるやすみ -ひれい -ひろい -ひろう -ひろき -ひろゆき -ひんかく -ひんけつ -ひんこん -ひんしゅ -ひんそう -ぴんち -ひんぱん -びんぼう -ふあん -ふいうち -ふうけい -ふうせん -ぷうたろう -ふうとう -ふうふ -ふえる -ふおん -ふかい -ふきん -ふくざつ -ふくぶくろ -ふこう -ふさい -ふしぎ -ふじみ -ふすま -ふせい -ふせぐ -ふそく -ぶたにく -ふたん -ふちょう -ふつう -ふつか -ふっかつ -ふっき -ふっこく -ぶどう -ふとる -ふとん -ふのう -ふはい -ふひょう -ふへん -ふまん -ふみん -ふめつ -ふめん -ふよう -ふりこ -ふりる -ふるい -ふんいき -ぶんがく -ぶんぐ -ふんしつ -ぶんせき -ふんそう -ぶんぽう -へいあん -へいおん -へいがい -へいき -へいげん -へいこう -へいさ -へいしゃ -へいせつ -へいそ -へいたく -へいてん -へいねつ -へいわ -へきが -へこむ -べにいろ -べにしょうが -へらす -へんかん -べんきょう -べんごし -へんさい -へんたい -べんり -ほあん -ほいく -ぼうぎょ -ほうこく -ほうそう -ほうほう -ほうもん -ほうりつ -ほえる -ほおん -ほかん -ほきょう -ぼきん -ほくろ -ほけつ -ほけん -ほこう -ほこる -ほしい -ほしつ -ほしゅ -ほしょう -ほせい -ほそい -ほそく -ほたて -ほたる -ぽちぶくろ -ほっきょく -ほっさ -ほったん -ほとんど -ほめる -ほんい -ほんき -ほんけ -ほんしつ -ほんやく -まいにち -まかい -まかせる -まがる -まける -まこと -まさつ -まじめ -ますく -まぜる -まつり -まとめ -まなぶ -まぬけ -まねく -まほう -まもる -まゆげ -まよう -まろやか -まわす -まわり -まわる -まんが -まんきつ -まんぞく -まんなか -みいら -みうち -みえる -みがく -みかた -みかん -みけん -みこん -みじかい -みすい -みすえる -みせる -みっか -みつかる -みつける -みてい -みとめる -みなと -みなみかさい -みねらる -みのう -みのがす -みほん -みもと -みやげ -みらい -みりょく -みわく -みんか -みんぞく -むいか -むえき -むえん -むかい -むかう -むかえ -むかし -むぎちゃ -むける -むげん -むさぼる -むしあつい -むしば -むじゅん -むしろ -むすう -むすこ -むすぶ -むすめ -むせる -むせん -むちゅう -むなしい -むのう -むやみ -むよう -むらさき -むりょう -むろん -めいあん -めいうん -めいえん -めいかく -めいきょく -めいさい -めいし -めいそう -めいぶつ -めいれい -めいわく -めぐまれる -めざす -めした -めずらしい -めだつ -めまい -めやす -めんきょ -めんせき -めんどう -もうしあげる -もうどうけん -もえる -もくし -もくてき -もくようび -もちろん -もどる -もらう -もんく -もんだい -やおや -やける -やさい -やさしい -やすい -やすたろう -やすみ -やせる -やそう -やたい -やちん -やっと -やっぱり -やぶる -やめる -ややこしい -やよい -やわらかい -ゆうき -ゆうびんきょく -ゆうべ -ゆうめい -ゆけつ -ゆしゅつ -ゆせん -ゆそう -ゆたか -ゆちゃく -ゆでる -ゆにゅう -ゆびわ -ゆらい -ゆれる -ようい -ようか -ようきゅう -ようじ -ようす -ようちえん -よかぜ -よかん -よきん -よくせい -よくぼう -よけい -よごれる -よさん -よしゅう -よそう -よそく -よっか -よてい -よどがわく -よねつ -よやく -よゆう -よろこぶ -よろしい -らいう -らくがき -らくご -らくさつ -らくだ -らしんばん -らせん -らぞく -らたい -らっか -られつ -りえき -りかい -りきさく -りきせつ -りくぐん -りくつ -りけん -りこう -りせい -りそう -りそく -りてん -りねん -りゆう -りゅうがく -りよう -りょうり -りょかん -りょくちゃ -りょこう -りりく -りれき -りろん -りんご -るいけい -るいさい -るいじ -るいせき -るすばん -るりがわら -れいかん -れいぎ -れいせい -れいぞうこ -れいとう -れいぼう -れきし -れきだい -れんあい -れんけい -れんこん -れんさい -れんしゅう -れんぞく -れんらく -ろうか -ろうご -ろうじん -ろうそく -ろくが -ろこつ -ろじうら -ろしゅつ -ろせん -ろてん -ろめん -ろれつ -ろんぎ -ろんぱ -ろんぶん -ろんり -わかす -わかめ -わかやま -わかれる -わしつ -わじまし -わすれもの -わらう -われる diff --git a/torba/words/portuguese.py b/torba/words/portuguese.py new file mode 100644 index 000000000..5a8d60da6 --- /dev/null +++ b/torba/words/portuguese.py @@ -0,0 +1,1628 @@ +words = [ +'abaular', +'abdominal', +'abeto', +'abissinio', +'abjeto', +'ablucao', +'abnegar', +'abotoar', +'abrutalhar', +'absurdo', +'abutre', +'acautelar', +'accessorios', +'acetona', +'achocolatado', +'acirrar', +'acne', +'acovardar', +'acrostico', +'actinomicete', +'acustico', +'adaptavel', +'adeus', +'adivinho', +'adjunto', +'admoestar', +'adnominal', +'adotivo', +'adquirir', +'adriatico', +'adsorcao', +'adutora', +'advogar', +'aerossol', +'afazeres', +'afetuoso', +'afixo', +'afluir', +'afortunar', +'afrouxar', +'aftosa', +'afunilar', +'agentes', +'agito', +'aglutinar', +'aiatola', +'aimore', +'aino', +'aipo', +'airoso', +'ajeitar', +'ajoelhar', +'ajudante', +'ajuste', +'alazao', +'albumina', +'alcunha', +'alegria', +'alexandre', +'alforriar', +'alguns', +'alhures', +'alivio', +'almoxarife', +'alotropico', +'alpiste', +'alquimista', +'alsaciano', +'altura', +'aluviao', +'alvura', +'amazonico', +'ambulatorio', +'ametodico', +'amizades', +'amniotico', +'amovivel', +'amurada', +'anatomico', +'ancorar', +'anexo', +'anfora', +'aniversario', +'anjo', +'anotar', +'ansioso', +'anturio', +'anuviar', +'anverso', +'anzol', +'aonde', +'apaziguar', +'apito', +'aplicavel', +'apoteotico', +'aprimorar', +'aprumo', +'apto', +'apuros', +'aquoso', +'arauto', +'arbusto', +'arduo', +'aresta', +'arfar', +'arguto', +'aritmetico', +'arlequim', +'armisticio', +'aromatizar', +'arpoar', +'arquivo', +'arrumar', +'arsenio', +'arturiano', +'aruaque', +'arvores', +'asbesto', +'ascorbico', +'aspirina', +'asqueroso', +'assustar', +'astuto', +'atazanar', +'ativo', +'atletismo', +'atmosferico', +'atormentar', +'atroz', +'aturdir', +'audivel', +'auferir', +'augusto', +'aula', +'aumento', +'aurora', +'autuar', +'avatar', +'avexar', +'avizinhar', +'avolumar', +'avulso', +'axiomatico', +'azerbaijano', +'azimute', +'azoto', +'azulejo', +'bacteriologista', +'badulaque', +'baforada', +'baixote', +'bajular', +'balzaquiana', +'bambuzal', +'banzo', +'baoba', +'baqueta', +'barulho', +'bastonete', +'batuta', +'bauxita', +'bavaro', +'bazuca', +'bcrepuscular', +'beato', +'beduino', +'begonia', +'behaviorista', +'beisebol', +'belzebu', +'bemol', +'benzido', +'beocio', +'bequer', +'berro', +'besuntar', +'betume', +'bexiga', +'bezerro', +'biatlon', +'biboca', +'bicuspide', +'bidirecional', +'bienio', +'bifurcar', +'bigorna', +'bijuteria', +'bimotor', +'binormal', +'bioxido', +'bipolarizacao', +'biquini', +'birutice', +'bisturi', +'bituca', +'biunivoco', +'bivalve', +'bizarro', +'blasfemo', +'blenorreia', +'blindar', +'bloqueio', +'blusao', +'boazuda', +'bofete', +'bojudo', +'bolso', +'bombordo', +'bonzo', +'botina', +'boquiaberto', +'bostoniano', +'botulismo', +'bourbon', +'bovino', +'boximane', +'bravura', +'brevidade', +'britar', +'broxar', +'bruno', +'bruxuleio', +'bubonico', +'bucolico', +'buda', +'budista', +'bueiro', +'buffer', +'bugre', +'bujao', +'bumerangue', +'burundines', +'busto', +'butique', +'buzios', +'caatinga', +'cabuqui', +'cacunda', +'cafuzo', +'cajueiro', +'camurca', +'canudo', +'caquizeiro', +'carvoeiro', +'casulo', +'catuaba', +'cauterizar', +'cebolinha', +'cedula', +'ceifeiro', +'celulose', +'cerzir', +'cesto', +'cetro', +'ceus', +'cevar', +'chavena', +'cheroqui', +'chita', +'chovido', +'chuvoso', +'ciatico', +'cibernetico', +'cicuta', +'cidreira', +'cientistas', +'cifrar', +'cigarro', +'cilio', +'cimo', +'cinzento', +'cioso', +'cipriota', +'cirurgico', +'cisto', +'citrico', +'ciumento', +'civismo', +'clavicula', +'clero', +'clitoris', +'cluster', +'coaxial', +'cobrir', +'cocota', +'codorniz', +'coexistir', +'cogumelo', +'coito', +'colusao', +'compaixao', +'comutativo', +'contentamento', +'convulsivo', +'coordenativa', +'coquetel', +'correto', +'corvo', +'costureiro', +'cotovia', +'covil', +'cozinheiro', +'cretino', +'cristo', +'crivo', +'crotalo', +'cruzes', +'cubo', +'cucuia', +'cueiro', +'cuidar', +'cujo', +'cultural', +'cunilingua', +'cupula', +'curvo', +'custoso', +'cutucar', +'czarismo', +'dablio', +'dacota', +'dados', +'daguerreotipo', +'daiquiri', +'daltonismo', +'damista', +'dantesco', +'daquilo', +'darwinista', +'dasein', +'dativo', +'deao', +'debutantes', +'decurso', +'deduzir', +'defunto', +'degustar', +'dejeto', +'deltoide', +'demover', +'denunciar', +'deputado', +'deque', +'dervixe', +'desvirtuar', +'deturpar', +'deuteronomio', +'devoto', +'dextrose', +'dezoito', +'diatribe', +'dicotomico', +'didatico', +'dietista', +'difuso', +'digressao', +'diluvio', +'diminuto', +'dinheiro', +'dinossauro', +'dioxido', +'diplomatico', +'dique', +'dirimivel', +'disturbio', +'diurno', +'divulgar', +'dizivel', +'doar', +'dobro', +'docura', +'dodoi', +'doer', +'dogue', +'doloso', +'domo', +'donzela', +'doping', +'dorsal', +'dossie', +'dote', +'doutro', +'doze', +'dravidico', +'dreno', +'driver', +'dropes', +'druso', +'dubnio', +'ducto', +'dueto', +'dulija', +'dundum', +'duodeno', +'duquesa', +'durou', +'duvidoso', +'duzia', +'ebano', +'ebrio', +'eburneo', +'echarpe', +'eclusa', +'ecossistema', +'ectoplasma', +'ecumenismo', +'eczema', +'eden', +'editorial', +'edredom', +'edulcorar', +'efetuar', +'efigie', +'efluvio', +'egiptologo', +'egresso', +'egua', +'einsteiniano', +'eira', +'eivar', +'eixos', +'ejetar', +'elastomero', +'eldorado', +'elixir', +'elmo', +'eloquente', +'elucidativo', +'emaranhar', +'embutir', +'emerito', +'emfa', +'emitir', +'emotivo', +'empuxo', +'emulsao', +'enamorar', +'encurvar', +'enduro', +'enevoar', +'enfurnar', +'enguico', +'enho', +'enigmista', +'enlutar', +'enormidade', +'enpreendimento', +'enquanto', +'enriquecer', +'enrugar', +'entusiastico', +'enunciar', +'envolvimento', +'enxuto', +'enzimatico', +'eolico', +'epiteto', +'epoxi', +'epura', +'equivoco', +'erario', +'erbio', +'ereto', +'erguido', +'erisipela', +'ermo', +'erotizar', +'erros', +'erupcao', +'ervilha', +'esburacar', +'escutar', +'esfuziante', +'esguio', +'esloveno', +'esmurrar', +'esoterismo', +'esperanca', +'espirito', +'espurio', +'essencialmente', +'esturricar', +'esvoacar', +'etario', +'eterno', +'etiquetar', +'etnologo', +'etos', +'etrusco', +'euclidiano', +'euforico', +'eugenico', +'eunuco', +'europio', +'eustaquio', +'eutanasia', +'evasivo', +'eventualidade', +'evitavel', +'evoluir', +'exaustor', +'excursionista', +'exercito', +'exfoliado', +'exito', +'exotico', +'expurgo', +'exsudar', +'extrusora', +'exumar', +'fabuloso', +'facultativo', +'fado', +'fagulha', +'faixas', +'fajuto', +'faltoso', +'famoso', +'fanzine', +'fapesp', +'faquir', +'fartura', +'fastio', +'faturista', +'fausto', +'favorito', +'faxineira', +'fazer', +'fealdade', +'febril', +'fecundo', +'fedorento', +'feerico', +'feixe', +'felicidade', +'felipe', +'feltro', +'femur', +'fenotipo', +'fervura', +'festivo', +'feto', +'feudo', +'fevereiro', +'fezinha', +'fiasco', +'fibra', +'ficticio', +'fiduciario', +'fiesp', +'fifa', +'figurino', +'fijiano', +'filtro', +'finura', +'fiorde', +'fiquei', +'firula', +'fissurar', +'fitoteca', +'fivela', +'fixo', +'flavio', +'flexor', +'flibusteiro', +'flotilha', +'fluxograma', +'fobos', +'foco', +'fofura', +'foguista', +'foie', +'foliculo', +'fominha', +'fonte', +'forum', +'fosso', +'fotossintese', +'foxtrote', +'fraudulento', +'frevo', +'frivolo', +'frouxo', +'frutose', +'fuba', +'fucsia', +'fugitivo', +'fuinha', +'fujao', +'fulustreco', +'fumo', +'funileiro', +'furunculo', +'fustigar', +'futurologo', +'fuxico', +'fuzue', +'gabriel', +'gado', +'gaelico', +'gafieira', +'gaguejo', +'gaivota', +'gajo', +'galvanoplastico', +'gamo', +'ganso', +'garrucha', +'gastronomo', +'gatuno', +'gaussiano', +'gaviao', +'gaxeta', +'gazeteiro', +'gear', +'geiser', +'geminiano', +'generoso', +'genuino', +'geossinclinal', +'gerundio', +'gestual', +'getulista', +'gibi', +'gigolo', +'gilete', +'ginseng', +'giroscopio', +'glaucio', +'glacial', +'gleba', +'glifo', +'glote', +'glutonia', +'gnostico', +'goela', +'gogo', +'goitaca', +'golpista', +'gomo', +'gonzo', +'gorro', +'gostou', +'goticula', +'gourmet', +'governo', +'gozo', +'graxo', +'grevista', +'grito', +'grotesco', +'gruta', +'guaxinim', +'gude', +'gueto', +'guizo', +'guloso', +'gume', +'guru', +'gustativo', +'gustavo', +'gutural', +'habitue', +'haitiano', +'halterofilista', +'hamburguer', +'hanseniase', +'happening', +'harpista', +'hastear', +'haveres', +'hebreu', +'hectometro', +'hedonista', +'hegira', +'helena', +'helminto', +'hemorroidas', +'henrique', +'heptassilabo', +'hertziano', +'hesitar', +'heterossexual', +'heuristico', +'hexagono', +'hiato', +'hibrido', +'hidrostatico', +'hieroglifo', +'hifenizar', +'higienizar', +'hilario', +'himen', +'hino', +'hippie', +'hirsuto', +'historiografia', +'hitlerista', +'hodometro', +'hoje', +'holograma', +'homus', +'honroso', +'hoquei', +'horto', +'hostilizar', +'hotentote', +'huguenote', +'humilde', +'huno', +'hurra', +'hutu', +'iaia', +'ialorixa', +'iambico', +'iansa', +'iaque', +'iara', +'iatista', +'iberico', +'ibis', +'icar', +'iceberg', +'icosagono', +'idade', +'ideologo', +'idiotice', +'idoso', +'iemenita', +'iene', +'igarape', +'iglu', +'ignorar', +'igreja', +'iguaria', +'iidiche', +'ilativo', +'iletrado', +'ilharga', +'ilimitado', +'ilogismo', +'ilustrissimo', +'imaturo', +'imbuzeiro', +'imerso', +'imitavel', +'imovel', +'imputar', +'imutavel', +'inaveriguavel', +'incutir', +'induzir', +'inextricavel', +'infusao', +'ingua', +'inhame', +'iniquo', +'injusto', +'inning', +'inoxidavel', +'inquisitorial', +'insustentavel', +'intumescimento', +'inutilizavel', +'invulneravel', +'inzoneiro', +'iodo', +'iogurte', +'ioio', +'ionosfera', +'ioruba', +'iota', +'ipsilon', +'irascivel', +'iris', +'irlandes', +'irmaos', +'iroques', +'irrupcao', +'isca', +'isento', +'islandes', +'isotopo', +'isqueiro', +'israelita', +'isso', +'isto', +'iterbio', +'itinerario', +'itrio', +'iuane', +'iugoslavo', +'jabuticabeira', +'jacutinga', +'jade', +'jagunco', +'jainista', +'jaleco', +'jambo', +'jantarada', +'japones', +'jaqueta', +'jarro', +'jasmim', +'jato', +'jaula', +'javel', +'jazz', +'jegue', +'jeitoso', +'jejum', +'jenipapo', +'jeova', +'jequitiba', +'jersei', +'jesus', +'jetom', +'jiboia', +'jihad', +'jilo', +'jingle', +'jipe', +'jocoso', +'joelho', +'joguete', +'joio', +'jojoba', +'jorro', +'jota', +'joule', +'joviano', +'jubiloso', +'judoca', +'jugular', +'juizo', +'jujuba', +'juliano', +'jumento', +'junto', +'jururu', +'justo', +'juta', +'juventude', +'labutar', +'laguna', +'laico', +'lajota', +'lanterninha', +'lapso', +'laquear', +'lastro', +'lauto', +'lavrar', +'laxativo', +'lazer', +'leasing', +'lebre', +'lecionar', +'ledo', +'leguminoso', +'leitura', +'lele', +'lemure', +'lento', +'leonardo', +'leopardo', +'lepton', +'leque', +'leste', +'letreiro', +'leucocito', +'levitico', +'lexicologo', +'lhama', +'lhufas', +'liame', +'licoroso', +'lidocaina', +'liliputiano', +'limusine', +'linotipo', +'lipoproteina', +'liquidos', +'lirismo', +'lisura', +'liturgico', +'livros', +'lixo', +'lobulo', +'locutor', +'lodo', +'logro', +'lojista', +'lombriga', +'lontra', +'loop', +'loquaz', +'lorota', +'losango', +'lotus', +'louvor', +'luar', +'lubrificavel', +'lucros', +'lugubre', +'luis', +'luminoso', +'luneta', +'lustroso', +'luto', +'luvas', +'luxuriante', +'luzeiro', +'maduro', +'maestro', +'mafioso', +'magro', +'maiuscula', +'majoritario', +'malvisto', +'mamute', +'manutencao', +'mapoteca', +'maquinista', +'marzipa', +'masturbar', +'matuto', +'mausoleu', +'mavioso', +'maxixe', +'mazurca', +'meandro', +'mecha', +'medusa', +'mefistofelico', +'megera', +'meirinho', +'melro', +'memorizar', +'menu', +'mequetrefe', +'mertiolate', +'mestria', +'metroviario', +'mexilhao', +'mezanino', +'miau', +'microssegundo', +'midia', +'migratorio', +'mimosa', +'minuto', +'miosotis', +'mirtilo', +'misturar', +'mitzvah', +'miudos', +'mixuruca', +'mnemonico', +'moagem', +'mobilizar', +'modulo', +'moer', +'mofo', +'mogno', +'moita', +'molusco', +'monumento', +'moqueca', +'morubixaba', +'mostruario', +'motriz', +'mouse', +'movivel', +'mozarela', +'muarra', +'muculmano', +'mudo', +'mugir', +'muitos', +'mumunha', +'munir', +'muon', +'muquira', +'murros', +'musselina', +'nacoes', +'nado', +'naftalina', +'nago', +'naipe', +'naja', +'nalgum', +'namoro', +'nanquim', +'napolitano', +'naquilo', +'nascimento', +'nautilo', +'navios', +'nazista', +'nebuloso', +'nectarina', +'nefrologo', +'negus', +'nelore', +'nenufar', +'nepotismo', +'nervura', +'neste', +'netuno', +'neutron', +'nevoeiro', +'newtoniano', +'nexo', +'nhenhenhem', +'nhoque', +'nigeriano', +'niilista', +'ninho', +'niobio', +'niponico', +'niquelar', +'nirvana', +'nisto', +'nitroglicerina', +'nivoso', +'nobreza', +'nocivo', +'noel', +'nogueira', +'noivo', +'nojo', +'nominativo', +'nonuplo', +'noruegues', +'nostalgico', +'noturno', +'nouveau', +'nuanca', +'nublar', +'nucleotideo', +'nudista', +'nulo', +'numismatico', +'nunquinha', +'nupcias', +'nutritivo', +'nuvens', +'oasis', +'obcecar', +'obeso', +'obituario', +'objetos', +'oblongo', +'obnoxio', +'obrigatorio', +'obstruir', +'obtuso', +'obus', +'obvio', +'ocaso', +'occipital', +'oceanografo', +'ocioso', +'oclusivo', +'ocorrer', +'ocre', +'octogono', +'odalisca', +'odisseia', +'odorifico', +'oersted', +'oeste', +'ofertar', +'ofidio', +'oftalmologo', +'ogiva', +'ogum', +'oigale', +'oitavo', +'oitocentos', +'ojeriza', +'olaria', +'oleoso', +'olfato', +'olhos', +'oliveira', +'olmo', +'olor', +'olvidavel', +'ombudsman', +'omeleteira', +'omitir', +'omoplata', +'onanismo', +'ondular', +'oneroso', +'onomatopeico', +'ontologico', +'onus', +'onze', +'opalescente', +'opcional', +'operistico', +'opio', +'oposto', +'oprobrio', +'optometrista', +'opusculo', +'oratorio', +'orbital', +'orcar', +'orfao', +'orixa', +'orla', +'ornitologo', +'orquidea', +'ortorrombico', +'orvalho', +'osculo', +'osmotico', +'ossudo', +'ostrogodo', +'otario', +'otite', +'ouro', +'ousar', +'outubro', +'ouvir', +'ovario', +'overnight', +'oviparo', +'ovni', +'ovoviviparo', +'ovulo', +'oxala', +'oxente', +'oxiuro', +'oxossi', +'ozonizar', +'paciente', +'pactuar', +'padronizar', +'paete', +'pagodeiro', +'paixao', +'pajem', +'paludismo', +'pampas', +'panturrilha', +'papudo', +'paquistanes', +'pastoso', +'patua', +'paulo', +'pauzinhos', +'pavoroso', +'paxa', +'pazes', +'peao', +'pecuniario', +'pedunculo', +'pegaso', +'peixinho', +'pejorativo', +'pelvis', +'penuria', +'pequno', +'petunia', +'pezada', +'piauiense', +'pictorico', +'pierro', +'pigmeu', +'pijama', +'pilulas', +'pimpolho', +'pintura', +'piorar', +'pipocar', +'piqueteiro', +'pirulito', +'pistoleiro', +'pituitaria', +'pivotar', +'pixote', +'pizzaria', +'plistoceno', +'plotar', +'pluviometrico', +'pneumonico', +'poco', +'podridao', +'poetisa', +'pogrom', +'pois', +'polvorosa', +'pomposo', +'ponderado', +'pontudo', +'populoso', +'poquer', +'porvir', +'posudo', +'potro', +'pouso', +'povoar', +'prazo', +'prezar', +'privilegios', +'proximo', +'prussiano', +'pseudopode', +'psoriase', +'pterossauros', +'ptialina', +'ptolemaico', +'pudor', +'pueril', +'pufe', +'pugilista', +'puir', +'pujante', +'pulverizar', +'pumba', +'punk', +'purulento', +'pustula', +'putsch', +'puxe', +'quatrocentos', +'quetzal', +'quixotesco', +'quotizavel', +'rabujice', +'racista', +'radonio', +'rafia', +'ragu', +'rajado', +'ralo', +'rampeiro', +'ranzinza', +'raptor', +'raquitismo', +'raro', +'rasurar', +'ratoeira', +'ravioli', +'razoavel', +'reavivar', +'rebuscar', +'recusavel', +'reduzivel', +'reexposicao', +'refutavel', +'regurgitar', +'reivindicavel', +'rejuvenescimento', +'relva', +'remuneravel', +'renunciar', +'reorientar', +'repuxo', +'requisito', +'resumo', +'returno', +'reutilizar', +'revolvido', +'rezonear', +'riacho', +'ribossomo', +'ricota', +'ridiculo', +'rifle', +'rigoroso', +'rijo', +'rimel', +'rins', +'rios', +'riqueza', +'riquixa', +'rissole', +'ritualistico', +'rivalizar', +'rixa', +'robusto', +'rococo', +'rodoviario', +'roer', +'rogo', +'rojao', +'rolo', +'rompimento', +'ronronar', +'roqueiro', +'rorqual', +'rosto', +'rotundo', +'rouxinol', +'roxo', +'royal', +'ruas', +'rucula', +'rudimentos', +'ruela', +'rufo', +'rugoso', +'ruivo', +'rule', +'rumoroso', +'runico', +'ruptura', +'rural', +'rustico', +'rutilar', +'saariano', +'sabujo', +'sacudir', +'sadomasoquista', +'safra', +'sagui', +'sais', +'samurai', +'santuario', +'sapo', +'saquear', +'sartriano', +'saturno', +'saude', +'sauva', +'saveiro', +'saxofonista', +'sazonal', +'scherzo', +'script', +'seara', +'seborreia', +'secura', +'seduzir', +'sefardim', +'seguro', +'seja', +'selvas', +'sempre', +'senzala', +'sepultura', +'sequoia', +'sestercio', +'setuplo', +'seus', +'seviciar', +'sezonismo', +'shalom', +'siames', +'sibilante', +'sicrano', +'sidra', +'sifilitico', +'signos', +'silvo', +'simultaneo', +'sinusite', +'sionista', +'sirio', +'sisudo', +'situar', +'sivan', +'slide', +'slogan', +'soar', +'sobrio', +'socratico', +'sodomizar', +'soerguer', +'software', +'sogro', +'soja', +'solver', +'somente', +'sonso', +'sopro', +'soquete', +'sorveteiro', +'sossego', +'soturno', +'sousafone', +'sovinice', +'sozinho', +'suavizar', +'subverter', +'sucursal', +'sudoriparo', +'sufragio', +'sugestoes', +'suite', +'sujo', +'sultao', +'sumula', +'suntuoso', +'suor', +'supurar', +'suruba', +'susto', +'suturar', +'suvenir', +'tabuleta', +'taco', +'tadjique', +'tafeta', +'tagarelice', +'taitiano', +'talvez', +'tampouco', +'tanzaniano', +'taoista', +'tapume', +'taquion', +'tarugo', +'tascar', +'tatuar', +'tautologico', +'tavola', +'taxionomista', +'tchecoslovaco', +'teatrologo', +'tectonismo', +'tedioso', +'teflon', +'tegumento', +'teixo', +'telurio', +'temporas', +'tenue', +'teosofico', +'tepido', +'tequila', +'terrorista', +'testosterona', +'tetrico', +'teutonico', +'teve', +'texugo', +'tiara', +'tibia', +'tiete', +'tifoide', +'tigresa', +'tijolo', +'tilintar', +'timpano', +'tintureiro', +'tiquete', +'tiroteio', +'tisico', +'titulos', +'tive', +'toar', +'toboga', +'tofu', +'togoles', +'toicinho', +'tolueno', +'tomografo', +'tontura', +'toponimo', +'toquio', +'torvelinho', +'tostar', +'toto', +'touro', +'toxina', +'trazer', +'trezentos', +'trivialidade', +'trovoar', +'truta', +'tuaregue', +'tubular', +'tucano', +'tudo', +'tufo', +'tuiste', +'tulipa', +'tumultuoso', +'tunisino', +'tupiniquim', +'turvo', +'tutu', +'ucraniano', +'udenista', +'ufanista', +'ufologo', +'ugaritico', +'uiste', +'uivo', +'ulceroso', +'ulema', +'ultravioleta', +'umbilical', +'umero', +'umido', +'umlaut', +'unanimidade', +'unesco', +'ungulado', +'unheiro', +'univoco', +'untuoso', +'urano', +'urbano', +'urdir', +'uretra', +'urgente', +'urinol', +'urna', +'urologo', +'urro', +'ursulina', +'urtiga', +'urupe', +'usavel', +'usbeque', +'usei', +'usineiro', +'usurpar', +'utero', +'utilizar', +'utopico', +'uvular', +'uxoricidio', +'vacuo', +'vadio', +'vaguear', +'vaivem', +'valvula', +'vampiro', +'vantajoso', +'vaporoso', +'vaquinha', +'varziano', +'vasto', +'vaticinio', +'vaudeville', +'vazio', +'veado', +'vedico', +'veemente', +'vegetativo', +'veio', +'veja', +'veludo', +'venusiano', +'verdade', +'verve', +'vestuario', +'vetusto', +'vexatorio', +'vezes', +'viavel', +'vibratorio', +'victor', +'vicunha', +'vidros', +'vietnamita', +'vigoroso', +'vilipendiar', +'vime', +'vintem', +'violoncelo', +'viquingue', +'virus', +'visualizar', +'vituperio', +'viuvo', +'vivo', +'vizir', +'voar', +'vociferar', +'vodu', +'vogar', +'voile', +'volver', +'vomito', +'vontade', +'vortice', +'vosso', +'voto', +'vovozinha', +'voyeuse', +'vozes', +'vulva', +'vupt', +'western', +'xadrez', +'xale', +'xampu', +'xango', +'xarope', +'xaual', +'xavante', +'xaxim', +'xenonio', +'xepa', +'xerox', +'xicara', +'xifopago', +'xiita', +'xilogravura', +'xinxim', +'xistoso', +'xixi', +'xodo', +'xogum', +'xucro', +'zabumba', +'zagueiro', +'zambiano', +'zanzar', +'zarpar', +'zebu', +'zefiro', +'zeloso', +'zenite', +'zumbi' +] diff --git a/torba/words/portuguese.txt b/torba/words/portuguese.txt deleted file mode 100644 index 394c88da2..000000000 --- a/torba/words/portuguese.txt +++ /dev/null @@ -1,1654 +0,0 @@ -# Copyright (c) 2014, The Monero Project -# -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without modification, are -# permitted provided that the following conditions are met: -# -# 1. Redistributions of source code must retain the above copyright notice, this list of -# conditions and the following disclaimer. -# -# 2. Redistributions in binary form must reproduce the above copyright notice, this list -# of conditions and the following disclaimer in the documentation and/or other -# materials provided with the distribution. -# -# 3. Neither the name of the copyright holder nor the names of its contributors may be -# used to endorse or promote products derived from this software without specific -# prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY -# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL -# THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, -# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF -# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -abaular -abdominal -abeto -abissinio -abjeto -ablucao -abnegar -abotoar -abrutalhar -absurdo -abutre -acautelar -accessorios -acetona -achocolatado -acirrar -acne -acovardar -acrostico -actinomicete -acustico -adaptavel -adeus -adivinho -adjunto -admoestar -adnominal -adotivo -adquirir -adriatico -adsorcao -adutora -advogar -aerossol -afazeres -afetuoso -afixo -afluir -afortunar -afrouxar -aftosa -afunilar -agentes -agito -aglutinar -aiatola -aimore -aino -aipo -airoso -ajeitar -ajoelhar -ajudante -ajuste -alazao -albumina -alcunha -alegria -alexandre -alforriar -alguns -alhures -alivio -almoxarife -alotropico -alpiste -alquimista -alsaciano -altura -aluviao -alvura -amazonico -ambulatorio -ametodico -amizades -amniotico -amovivel -amurada -anatomico -ancorar -anexo -anfora -aniversario -anjo -anotar -ansioso -anturio -anuviar -anverso -anzol -aonde -apaziguar -apito -aplicavel -apoteotico -aprimorar -aprumo -apto -apuros -aquoso -arauto -arbusto -arduo -aresta -arfar -arguto -aritmetico -arlequim -armisticio -aromatizar -arpoar -arquivo -arrumar -arsenio -arturiano -aruaque -arvores -asbesto -ascorbico -aspirina -asqueroso -assustar -astuto -atazanar -ativo -atletismo -atmosferico -atormentar -atroz -aturdir -audivel -auferir -augusto -aula -aumento -aurora -autuar -avatar -avexar -avizinhar -avolumar -avulso -axiomatico -azerbaijano -azimute -azoto -azulejo -bacteriologista -badulaque -baforada -baixote -bajular -balzaquiana -bambuzal -banzo -baoba -baqueta -barulho -bastonete -batuta -bauxita -bavaro -bazuca -bcrepuscular -beato -beduino -begonia -behaviorista -beisebol -belzebu -bemol -benzido -beocio -bequer -berro -besuntar -betume -bexiga -bezerro -biatlon -biboca -bicuspide -bidirecional -bienio -bifurcar -bigorna -bijuteria -bimotor -binormal -bioxido -bipolarizacao -biquini -birutice -bisturi -bituca -biunivoco -bivalve -bizarro -blasfemo -blenorreia -blindar -bloqueio -blusao -boazuda -bofete -bojudo -bolso -bombordo -bonzo -botina -boquiaberto -bostoniano -botulismo -bourbon -bovino -boximane -bravura -brevidade -britar -broxar -bruno -bruxuleio -bubonico -bucolico -buda -budista -bueiro -buffer -bugre -bujao -bumerangue -burundines -busto -butique -buzios -caatinga -cabuqui -cacunda -cafuzo -cajueiro -camurca -canudo -caquizeiro -carvoeiro -casulo -catuaba -cauterizar -cebolinha -cedula -ceifeiro -celulose -cerzir -cesto -cetro -ceus -cevar -chavena -cheroqui -chita -chovido -chuvoso -ciatico -cibernetico -cicuta -cidreira -cientistas -cifrar -cigarro -cilio -cimo -cinzento -cioso -cipriota -cirurgico -cisto -citrico -ciumento -civismo -clavicula -clero -clitoris -cluster -coaxial -cobrir -cocota -codorniz -coexistir -cogumelo -coito -colusao -compaixao -comutativo -contentamento -convulsivo -coordenativa -coquetel -correto -corvo -costureiro -cotovia -covil -cozinheiro -cretino -cristo -crivo -crotalo -cruzes -cubo -cucuia -cueiro -cuidar -cujo -cultural -cunilingua -cupula -curvo -custoso -cutucar -czarismo -dablio -dacota -dados -daguerreotipo -daiquiri -daltonismo -damista -dantesco -daquilo -darwinista -dasein -dativo -deao -debutantes -decurso -deduzir -defunto -degustar -dejeto -deltoide -demover -denunciar -deputado -deque -dervixe -desvirtuar -deturpar -deuteronomio -devoto -dextrose -dezoito -diatribe -dicotomico -didatico -dietista -difuso -digressao -diluvio -diminuto -dinheiro -dinossauro -dioxido -diplomatico -dique -dirimivel -disturbio -diurno -divulgar -dizivel -doar -dobro -docura -dodoi -doer -dogue -doloso -domo -donzela -doping -dorsal -dossie -dote -doutro -doze -dravidico -dreno -driver -dropes -druso -dubnio -ducto -dueto -dulija -dundum -duodeno -duquesa -durou -duvidoso -duzia -ebano -ebrio -eburneo -echarpe -eclusa -ecossistema -ectoplasma -ecumenismo -eczema -eden -editorial -edredom -edulcorar -efetuar -efigie -efluvio -egiptologo -egresso -egua -einsteiniano -eira -eivar -eixos -ejetar -elastomero -eldorado -elixir -elmo -eloquente -elucidativo -emaranhar -embutir -emerito -emfa -emitir -emotivo -empuxo -emulsao -enamorar -encurvar -enduro -enevoar -enfurnar -enguico -enho -enigmista -enlutar -enormidade -enpreendimento -enquanto -enriquecer -enrugar -entusiastico -enunciar -envolvimento -enxuto -enzimatico -eolico -epiteto -epoxi -epura -equivoco -erario -erbio -ereto -erguido -erisipela -ermo -erotizar -erros -erupcao -ervilha -esburacar -escutar -esfuziante -esguio -esloveno -esmurrar -esoterismo -esperanca -espirito -espurio -essencialmente -esturricar -esvoacar -etario -eterno -etiquetar -etnologo -etos -etrusco -euclidiano -euforico -eugenico -eunuco -europio -eustaquio -eutanasia -evasivo -eventualidade -evitavel -evoluir -exaustor -excursionista -exercito -exfoliado -exito -exotico -expurgo -exsudar -extrusora -exumar -fabuloso -facultativo -fado -fagulha -faixas -fajuto -faltoso -famoso -fanzine -fapesp -faquir -fartura -fastio -faturista -fausto -favorito -faxineira -fazer -fealdade -febril -fecundo -fedorento -feerico -feixe -felicidade -felipe -feltro -femur -fenotipo -fervura -festivo -feto -feudo -fevereiro -fezinha -fiasco -fibra -ficticio -fiduciario -fiesp -fifa -figurino -fijiano -filtro -finura -fiorde -fiquei -firula -fissurar -fitoteca -fivela -fixo -flavio -flexor -flibusteiro -flotilha -fluxograma -fobos -foco -fofura -foguista -foie -foliculo -fominha -fonte -forum -fosso -fotossintese -foxtrote -fraudulento -frevo -frivolo -frouxo -frutose -fuba -fucsia -fugitivo -fuinha -fujao -fulustreco -fumo -funileiro -furunculo -fustigar -futurologo -fuxico -fuzue -gabriel -gado -gaelico -gafieira -gaguejo -gaivota -gajo -galvanoplastico -gamo -ganso -garrucha -gastronomo -gatuno -gaussiano -gaviao -gaxeta -gazeteiro -gear -geiser -geminiano -generoso -genuino -geossinclinal -gerundio -gestual -getulista -gibi -gigolo -gilete -ginseng -giroscopio -glaucio -glacial -gleba -glifo -glote -glutonia -gnostico -goela -gogo -goitaca -golpista -gomo -gonzo -gorro -gostou -goticula -gourmet -governo -gozo -graxo -grevista -grito -grotesco -gruta -guaxinim -gude -gueto -guizo -guloso -gume -guru -gustativo -gustavo -gutural -habitue -haitiano -halterofilista -hamburguer -hanseniase -happening -harpista -hastear -haveres -hebreu -hectometro -hedonista -hegira -helena -helminto -hemorroidas -henrique -heptassilabo -hertziano -hesitar -heterossexual -heuristico -hexagono -hiato -hibrido -hidrostatico -hieroglifo -hifenizar -higienizar -hilario -himen -hino -hippie -hirsuto -historiografia -hitlerista -hodometro -hoje -holograma -homus -honroso -hoquei -horto -hostilizar -hotentote -huguenote -humilde -huno -hurra -hutu -iaia -ialorixa -iambico -iansa -iaque -iara -iatista -iberico -ibis -icar -iceberg -icosagono -idade -ideologo -idiotice -idoso -iemenita -iene -igarape -iglu -ignorar -igreja -iguaria -iidiche -ilativo -iletrado -ilharga -ilimitado -ilogismo -ilustrissimo -imaturo -imbuzeiro -imerso -imitavel -imovel -imputar -imutavel -inaveriguavel -incutir -induzir -inextricavel -infusao -ingua -inhame -iniquo -injusto -inning -inoxidavel -inquisitorial -insustentavel -intumescimento -inutilizavel -invulneravel -inzoneiro -iodo -iogurte -ioio -ionosfera -ioruba -iota -ipsilon -irascivel -iris -irlandes -irmaos -iroques -irrupcao -isca -isento -islandes -isotopo -isqueiro -israelita -isso -isto -iterbio -itinerario -itrio -iuane -iugoslavo -jabuticabeira -jacutinga -jade -jagunco -jainista -jaleco -jambo -jantarada -japones -jaqueta -jarro -jasmim -jato -jaula -javel -jazz -jegue -jeitoso -jejum -jenipapo -jeova -jequitiba -jersei -jesus -jetom -jiboia -jihad -jilo -jingle -jipe -jocoso -joelho -joguete -joio -jojoba -jorro -jota -joule -joviano -jubiloso -judoca -jugular -juizo -jujuba -juliano -jumento -junto -jururu -justo -juta -juventude -labutar -laguna -laico -lajota -lanterninha -lapso -laquear -lastro -lauto -lavrar -laxativo -lazer -leasing -lebre -lecionar -ledo -leguminoso -leitura -lele -lemure -lento -leonardo -leopardo -lepton -leque -leste -letreiro -leucocito -levitico -lexicologo -lhama -lhufas -liame -licoroso -lidocaina -liliputiano -limusine -linotipo -lipoproteina -liquidos -lirismo -lisura -liturgico -livros -lixo -lobulo -locutor -lodo -logro -lojista -lombriga -lontra -loop -loquaz -lorota -losango -lotus -louvor -luar -lubrificavel -lucros -lugubre -luis -luminoso -luneta -lustroso -luto -luvas -luxuriante -luzeiro -maduro -maestro -mafioso -magro -maiuscula -majoritario -malvisto -mamute -manutencao -mapoteca -maquinista -marzipa -masturbar -matuto -mausoleu -mavioso -maxixe -mazurca -meandro -mecha -medusa -mefistofelico -megera -meirinho -melro -memorizar -menu -mequetrefe -mertiolate -mestria -metroviario -mexilhao -mezanino -miau -microssegundo -midia -migratorio -mimosa -minuto -miosotis -mirtilo -misturar -mitzvah -miudos -mixuruca -mnemonico -moagem -mobilizar -modulo -moer -mofo -mogno -moita -molusco -monumento -moqueca -morubixaba -mostruario -motriz -mouse -movivel -mozarela -muarra -muculmano -mudo -mugir -muitos -mumunha -munir -muon -muquira -murros -musselina -nacoes -nado -naftalina -nago -naipe -naja -nalgum -namoro -nanquim -napolitano -naquilo -nascimento -nautilo -navios -nazista -nebuloso -nectarina -nefrologo -negus -nelore -nenufar -nepotismo -nervura -neste -netuno -neutron -nevoeiro -newtoniano -nexo -nhenhenhem -nhoque -nigeriano -niilista -ninho -niobio -niponico -niquelar -nirvana -nisto -nitroglicerina -nivoso -nobreza -nocivo -noel -nogueira -noivo -nojo -nominativo -nonuplo -noruegues -nostalgico -noturno -nouveau -nuanca -nublar -nucleotideo -nudista -nulo -numismatico -nunquinha -nupcias -nutritivo -nuvens -oasis -obcecar -obeso -obituario -objetos -oblongo -obnoxio -obrigatorio -obstruir -obtuso -obus -obvio -ocaso -occipital -oceanografo -ocioso -oclusivo -ocorrer -ocre -octogono -odalisca -odisseia -odorifico -oersted -oeste -ofertar -ofidio -oftalmologo -ogiva -ogum -oigale -oitavo -oitocentos -ojeriza -olaria -oleoso -olfato -olhos -oliveira -olmo -olor -olvidavel -ombudsman -omeleteira -omitir -omoplata -onanismo -ondular -oneroso -onomatopeico -ontologico -onus -onze -opalescente -opcional -operistico -opio -oposto -oprobrio -optometrista -opusculo -oratorio -orbital -orcar -orfao -orixa -orla -ornitologo -orquidea -ortorrombico -orvalho -osculo -osmotico -ossudo -ostrogodo -otario -otite -ouro -ousar -outubro -ouvir -ovario -overnight -oviparo -ovni -ovoviviparo -ovulo -oxala -oxente -oxiuro -oxossi -ozonizar -paciente -pactuar -padronizar -paete -pagodeiro -paixao -pajem -paludismo -pampas -panturrilha -papudo -paquistanes -pastoso -patua -paulo -pauzinhos -pavoroso -paxa -pazes -peao -pecuniario -pedunculo -pegaso -peixinho -pejorativo -pelvis -penuria -pequno -petunia -pezada -piauiense -pictorico -pierro -pigmeu -pijama -pilulas -pimpolho -pintura -piorar -pipocar -piqueteiro -pirulito -pistoleiro -pituitaria -pivotar -pixote -pizzaria -plistoceno -plotar -pluviometrico -pneumonico -poco -podridao -poetisa -pogrom -pois -polvorosa -pomposo -ponderado -pontudo -populoso -poquer -porvir -posudo -potro -pouso -povoar -prazo -prezar -privilegios -proximo -prussiano -pseudopode -psoriase -pterossauros -ptialina -ptolemaico -pudor -pueril -pufe -pugilista -puir -pujante -pulverizar -pumba -punk -purulento -pustula -putsch -puxe -quatrocentos -quetzal -quixotesco -quotizavel -rabujice -racista -radonio -rafia -ragu -rajado -ralo -rampeiro -ranzinza -raptor -raquitismo -raro -rasurar -ratoeira -ravioli -razoavel -reavivar -rebuscar -recusavel -reduzivel -reexposicao -refutavel -regurgitar -reivindicavel -rejuvenescimento -relva -remuneravel -renunciar -reorientar -repuxo -requisito -resumo -returno -reutilizar -revolvido -rezonear -riacho -ribossomo -ricota -ridiculo -rifle -rigoroso -rijo -rimel -rins -rios -riqueza -riquixa -rissole -ritualistico -rivalizar -rixa -robusto -rococo -rodoviario -roer -rogo -rojao -rolo -rompimento -ronronar -roqueiro -rorqual -rosto -rotundo -rouxinol -roxo -royal -ruas -rucula -rudimentos -ruela -rufo -rugoso -ruivo -rule -rumoroso -runico -ruptura -rural -rustico -rutilar -saariano -sabujo -sacudir -sadomasoquista -safra -sagui -sais -samurai -santuario -sapo -saquear -sartriano -saturno -saude -sauva -saveiro -saxofonista -sazonal -scherzo -script -seara -seborreia -secura -seduzir -sefardim -seguro -seja -selvas -sempre -senzala -sepultura -sequoia -sestercio -setuplo -seus -seviciar -sezonismo -shalom -siames -sibilante -sicrano -sidra -sifilitico -signos -silvo -simultaneo -sinusite -sionista -sirio -sisudo -situar -sivan -slide -slogan -soar -sobrio -socratico -sodomizar -soerguer -software -sogro -soja -solver -somente -sonso -sopro -soquete -sorveteiro -sossego -soturno -sousafone -sovinice -sozinho -suavizar -subverter -sucursal -sudoriparo -sufragio -sugestoes -suite -sujo -sultao -sumula -suntuoso -suor -supurar -suruba -susto -suturar -suvenir -tabuleta -taco -tadjique -tafeta -tagarelice -taitiano -talvez -tampouco -tanzaniano -taoista -tapume -taquion -tarugo -tascar -tatuar -tautologico -tavola -taxionomista -tchecoslovaco -teatrologo -tectonismo -tedioso -teflon -tegumento -teixo -telurio -temporas -tenue -teosofico -tepido -tequila -terrorista -testosterona -tetrico -teutonico -teve -texugo -tiara -tibia -tiete -tifoide -tigresa -tijolo -tilintar -timpano -tintureiro -tiquete -tiroteio -tisico -titulos -tive -toar -toboga -tofu -togoles -toicinho -tolueno -tomografo -tontura -toponimo -toquio -torvelinho -tostar -toto -touro -toxina -trazer -trezentos -trivialidade -trovoar -truta -tuaregue -tubular -tucano -tudo -tufo -tuiste -tulipa -tumultuoso -tunisino -tupiniquim -turvo -tutu -ucraniano -udenista -ufanista -ufologo -ugaritico -uiste -uivo -ulceroso -ulema -ultravioleta -umbilical -umero -umido -umlaut -unanimidade -unesco -ungulado -unheiro -univoco -untuoso -urano -urbano -urdir -uretra -urgente -urinol -urna -urologo -urro -ursulina -urtiga -urupe -usavel -usbeque -usei -usineiro -usurpar -utero -utilizar -utopico -uvular -uxoricidio -vacuo -vadio -vaguear -vaivem -valvula -vampiro -vantajoso -vaporoso -vaquinha -varziano -vasto -vaticinio -vaudeville -vazio -veado -vedico -veemente -vegetativo -veio -veja -veludo -venusiano -verdade -verve -vestuario -vetusto -vexatorio -vezes -viavel -vibratorio -victor -vicunha -vidros -vietnamita -vigoroso -vilipendiar -vime -vintem -violoncelo -viquingue -virus -visualizar -vituperio -viuvo -vivo -vizir -voar -vociferar -vodu -vogar -voile -volver -vomito -vontade -vortice -vosso -voto -vovozinha -voyeuse -vozes -vulva -vupt -western -xadrez -xale -xampu -xango -xarope -xaual -xavante -xaxim -xenonio -xepa -xerox -xicara -xifopago -xiita -xilogravura -xinxim -xistoso -xixi -xodo -xogum -xucro -zabumba -zagueiro -zambiano -zanzar -zarpar -zebu -zefiro -zeloso -zenite -zumbi diff --git a/torba/words/spanish.py b/torba/words/spanish.py new file mode 100644 index 000000000..8b4de2841 --- /dev/null +++ b/torba/words/spanish.py @@ -0,0 +1,2050 @@ +words = [ +'ábaco', +'abdomen', +'abeja', +'abierto', +'abogado', +'abono', +'aborto', +'abrazo', +'abrir', +'abuelo', +'abuso', +'acabar', +'academia', +'acceso', +'acción', +'aceite', +'acelga', +'acento', +'aceptar', +'ácido', +'aclarar', +'acné', +'acoger', +'acoso', +'activo', +'acto', +'actriz', +'actuar', +'acudir', +'acuerdo', +'acusar', +'adicto', +'admitir', +'adoptar', +'adorno', +'aduana', +'adulto', +'aéreo', +'afectar', +'afición', +'afinar', +'afirmar', +'ágil', +'agitar', +'agonía', +'agosto', +'agotar', +'agregar', +'agrio', +'agua', +'agudo', +'águila', +'aguja', +'ahogo', +'ahorro', +'aire', +'aislar', +'ajedrez', +'ajeno', +'ajuste', +'alacrán', +'alambre', +'alarma', +'alba', +'álbum', +'alcalde', +'aldea', +'alegre', +'alejar', +'alerta', +'aleta', +'alfiler', +'alga', +'algodón', +'aliado', +'aliento', +'alivio', +'alma', +'almeja', +'almíbar', +'altar', +'alteza', +'altivo', +'alto', +'altura', +'alumno', +'alzar', +'amable', +'amante', +'amapola', +'amargo', +'amasar', +'ámbar', +'ámbito', +'ameno', +'amigo', +'amistad', +'amor', +'amparo', +'amplio', +'ancho', +'anciano', +'ancla', +'andar', +'andén', +'anemia', +'ángulo', +'anillo', +'ánimo', +'anís', +'anotar', +'antena', +'antiguo', +'antojo', +'anual', +'anular', +'anuncio', +'añadir', +'añejo', +'año', +'apagar', +'aparato', +'apetito', +'apio', +'aplicar', +'apodo', +'aporte', +'apoyo', +'aprender', +'aprobar', +'apuesta', +'apuro', +'arado', +'araña', +'arar', +'árbitro', +'árbol', +'arbusto', +'archivo', +'arco', +'arder', +'ardilla', +'arduo', +'área', +'árido', +'aries', +'armonía', +'arnés', +'aroma', +'arpa', +'arpón', +'arreglo', +'arroz', +'arruga', +'arte', +'artista', +'asa', +'asado', +'asalto', +'ascenso', +'asegurar', +'aseo', +'asesor', +'asiento', +'asilo', +'asistir', +'asno', +'asombro', +'áspero', +'astilla', +'astro', +'astuto', +'asumir', +'asunto', +'atajo', +'ataque', +'atar', +'atento', +'ateo', +'ático', +'atleta', +'átomo', +'atraer', +'atroz', +'atún', +'audaz', +'audio', +'auge', +'aula', +'aumento', +'ausente', +'autor', +'aval', +'avance', +'avaro', +'ave', +'avellana', +'avena', +'avestruz', +'avión', +'aviso', +'ayer', +'ayuda', +'ayuno', +'azafrán', +'azar', +'azote', +'azúcar', +'azufre', +'azul', +'baba', +'babor', +'bache', +'bahía', +'baile', +'bajar', +'balanza', +'balcón', +'balde', +'bambú', +'banco', +'banda', +'baño', +'barba', +'barco', +'barniz', +'barro', +'báscula', +'bastón', +'basura', +'batalla', +'batería', +'batir', +'batuta', +'baúl', +'bazar', +'bebé', +'bebida', +'bello', +'besar', +'beso', +'bestia', +'bicho', +'bien', +'bingo', +'blanco', +'bloque', +'blusa', +'boa', +'bobina', +'bobo', +'boca', +'bocina', +'boda', +'bodega', +'boina', +'bola', +'bolero', +'bolsa', +'bomba', +'bondad', +'bonito', +'bono', +'bonsái', +'borde', +'borrar', +'bosque', +'bote', +'botín', +'bóveda', +'bozal', +'bravo', +'brazo', +'brecha', +'breve', +'brillo', +'brinco', +'brisa', +'broca', +'broma', +'bronce', +'brote', +'bruja', +'brusco', +'bruto', +'buceo', +'bucle', +'bueno', +'buey', +'bufanda', +'bufón', +'búho', +'buitre', +'bulto', +'burbuja', +'burla', +'burro', +'buscar', +'butaca', +'buzón', +'caballo', +'cabeza', +'cabina', +'cabra', +'cacao', +'cadáver', +'cadena', +'caer', +'café', +'caída', +'caimán', +'caja', +'cajón', +'cal', +'calamar', +'calcio', +'caldo', +'calidad', +'calle', +'calma', +'calor', +'calvo', +'cama', +'cambio', +'camello', +'camino', +'campo', +'cáncer', +'candil', +'canela', +'canguro', +'canica', +'canto', +'caña', +'cañón', +'caoba', +'caos', +'capaz', +'capitán', +'capote', +'captar', +'capucha', +'cara', +'carbón', +'cárcel', +'careta', +'carga', +'cariño', +'carne', +'carpeta', +'carro', +'carta', +'casa', +'casco', +'casero', +'caspa', +'castor', +'catorce', +'catre', +'caudal', +'causa', +'cazo', +'cebolla', +'ceder', +'cedro', +'celda', +'célebre', +'celoso', +'célula', +'cemento', +'ceniza', +'centro', +'cerca', +'cerdo', +'cereza', +'cero', +'cerrar', +'certeza', +'césped', +'cetro', +'chacal', +'chaleco', +'champú', +'chancla', +'chapa', +'charla', +'chico', +'chiste', +'chivo', +'choque', +'choza', +'chuleta', +'chupar', +'ciclón', +'ciego', +'cielo', +'cien', +'cierto', +'cifra', +'cigarro', +'cima', +'cinco', +'cine', +'cinta', +'ciprés', +'circo', +'ciruela', +'cisne', +'cita', +'ciudad', +'clamor', +'clan', +'claro', +'clase', +'clave', +'cliente', +'clima', +'clínica', +'cobre', +'cocción', +'cochino', +'cocina', +'coco', +'código', +'codo', +'cofre', +'coger', +'cohete', +'cojín', +'cojo', +'cola', +'colcha', +'colegio', +'colgar', +'colina', +'collar', +'colmo', +'columna', +'combate', +'comer', +'comida', +'cómodo', +'compra', +'conde', +'conejo', +'conga', +'conocer', +'consejo', +'contar', +'copa', +'copia', +'corazón', +'corbata', +'corcho', +'cordón', +'corona', +'correr', +'coser', +'cosmos', +'costa', +'cráneo', +'cráter', +'crear', +'crecer', +'creído', +'crema', +'cría', +'crimen', +'cripta', +'crisis', +'cromo', +'crónica', +'croqueta', +'crudo', +'cruz', +'cuadro', +'cuarto', +'cuatro', +'cubo', +'cubrir', +'cuchara', +'cuello', +'cuento', +'cuerda', +'cuesta', +'cueva', +'cuidar', +'culebra', +'culpa', +'culto', +'cumbre', +'cumplir', +'cuna', +'cuneta', +'cuota', +'cupón', +'cúpula', +'curar', +'curioso', +'curso', +'curva', +'cutis', +'dama', +'danza', +'dar', +'dardo', +'dátil', +'deber', +'débil', +'década', +'decir', +'dedo', +'defensa', +'definir', +'dejar', +'delfín', +'delgado', +'delito', +'demora', +'denso', +'dental', +'deporte', +'derecho', +'derrota', +'desayuno', +'deseo', +'desfile', +'desnudo', +'destino', +'desvío', +'detalle', +'detener', +'deuda', +'día', +'diablo', +'diadema', +'diamante', +'diana', +'diario', +'dibujo', +'dictar', +'diente', +'dieta', +'diez', +'difícil', +'digno', +'dilema', +'diluir', +'dinero', +'directo', +'dirigir', +'disco', +'diseño', +'disfraz', +'diva', +'divino', +'doble', +'doce', +'dolor', +'domingo', +'don', +'donar', +'dorado', +'dormir', +'dorso', +'dos', +'dosis', +'dragón', +'droga', +'ducha', +'duda', +'duelo', +'dueño', +'dulce', +'dúo', +'duque', +'durar', +'dureza', +'duro', +'ébano', +'ebrio', +'echar', +'eco', +'ecuador', +'edad', +'edición', +'edificio', +'editor', +'educar', +'efecto', +'eficaz', +'eje', +'ejemplo', +'elefante', +'elegir', +'elemento', +'elevar', +'elipse', +'élite', +'elixir', +'elogio', +'eludir', +'embudo', +'emitir', +'emoción', +'empate', +'empeño', +'empleo', +'empresa', +'enano', +'encargo', +'enchufe', +'encía', +'enemigo', +'enero', +'enfado', +'enfermo', +'engaño', +'enigma', +'enlace', +'enorme', +'enredo', +'ensayo', +'enseñar', +'entero', +'entrar', +'envase', +'envío', +'época', +'equipo', +'erizo', +'escala', +'escena', +'escolar', +'escribir', +'escudo', +'esencia', +'esfera', +'esfuerzo', +'espada', +'espejo', +'espía', +'esposa', +'espuma', +'esquí', +'estar', +'este', +'estilo', +'estufa', +'etapa', +'eterno', +'ética', +'etnia', +'evadir', +'evaluar', +'evento', +'evitar', +'exacto', +'examen', +'exceso', +'excusa', +'exento', +'exigir', +'exilio', +'existir', +'éxito', +'experto', +'explicar', +'exponer', +'extremo', +'fábrica', +'fábula', +'fachada', +'fácil', +'factor', +'faena', +'faja', +'falda', +'fallo', +'falso', +'faltar', +'fama', +'familia', +'famoso', +'faraón', +'farmacia', +'farol', +'farsa', +'fase', +'fatiga', +'fauna', +'favor', +'fax', +'febrero', +'fecha', +'feliz', +'feo', +'feria', +'feroz', +'fértil', +'fervor', +'festín', +'fiable', +'fianza', +'fiar', +'fibra', +'ficción', +'ficha', +'fideo', +'fiebre', +'fiel', +'fiera', +'fiesta', +'figura', +'fijar', +'fijo', +'fila', +'filete', +'filial', +'filtro', +'fin', +'finca', +'fingir', +'finito', +'firma', +'flaco', +'flauta', +'flecha', +'flor', +'flota', +'fluir', +'flujo', +'flúor', +'fobia', +'foca', +'fogata', +'fogón', +'folio', +'folleto', +'fondo', +'forma', +'forro', +'fortuna', +'forzar', +'fosa', +'foto', +'fracaso', +'frágil', +'franja', +'frase', +'fraude', +'freír', +'freno', +'fresa', +'frío', +'frito', +'fruta', +'fuego', +'fuente', +'fuerza', +'fuga', +'fumar', +'función', +'funda', +'furgón', +'furia', +'fusil', +'fútbol', +'futuro', +'gacela', +'gafas', +'gaita', +'gajo', +'gala', +'galería', +'gallo', +'gamba', +'ganar', +'gancho', +'ganga', +'ganso', +'garaje', +'garza', +'gasolina', +'gastar', +'gato', +'gavilán', +'gemelo', +'gemir', +'gen', +'género', +'genio', +'gente', +'geranio', +'gerente', +'germen', +'gesto', +'gigante', +'gimnasio', +'girar', +'giro', +'glaciar', +'globo', +'gloria', +'gol', +'golfo', +'goloso', +'golpe', +'goma', +'gordo', +'gorila', +'gorra', +'gota', +'goteo', +'gozar', +'grada', +'gráfico', +'grano', +'grasa', +'gratis', +'grave', +'grieta', +'grillo', +'gripe', +'gris', +'grito', +'grosor', +'grúa', +'grueso', +'grumo', +'grupo', +'guante', +'guapo', +'guardia', +'guerra', +'guía', +'guiño', +'guion', +'guiso', +'guitarra', +'gusano', +'gustar', +'haber', +'hábil', +'hablar', +'hacer', +'hacha', +'hada', +'hallar', +'hamaca', +'harina', +'haz', +'hazaña', +'hebilla', +'hebra', +'hecho', +'helado', +'helio', +'hembra', +'herir', +'hermano', +'héroe', +'hervir', +'hielo', +'hierro', +'hígado', +'higiene', +'hijo', +'himno', +'historia', +'hocico', +'hogar', +'hoguera', +'hoja', +'hombre', +'hongo', +'honor', +'honra', +'hora', +'hormiga', +'horno', +'hostil', +'hoyo', +'hueco', +'huelga', +'huerta', +'hueso', +'huevo', +'huida', +'huir', +'humano', +'húmedo', +'humilde', +'humo', +'hundir', +'huracán', +'hurto', +'icono', +'ideal', +'idioma', +'ídolo', +'iglesia', +'iglú', +'igual', +'ilegal', +'ilusión', +'imagen', +'imán', +'imitar', +'impar', +'imperio', +'imponer', +'impulso', +'incapaz', +'índice', +'inerte', +'infiel', +'informe', +'ingenio', +'inicio', +'inmenso', +'inmune', +'innato', +'insecto', +'instante', +'interés', +'íntimo', +'intuir', +'inútil', +'invierno', +'ira', +'iris', +'ironía', +'isla', +'islote', +'jabalí', +'jabón', +'jamón', +'jarabe', +'jardín', +'jarra', +'jaula', +'jazmín', +'jefe', +'jeringa', +'jinete', +'jornada', +'joroba', +'joven', +'joya', +'juerga', +'jueves', +'juez', +'jugador', +'jugo', +'juguete', +'juicio', +'junco', +'jungla', +'junio', +'juntar', +'júpiter', +'jurar', +'justo', +'juvenil', +'juzgar', +'kilo', +'koala', +'labio', +'lacio', +'lacra', +'lado', +'ladrón', +'lagarto', +'lágrima', +'laguna', +'laico', +'lamer', +'lámina', +'lámpara', +'lana', +'lancha', +'langosta', +'lanza', +'lápiz', +'largo', +'larva', +'lástima', +'lata', +'látex', +'latir', +'laurel', +'lavar', +'lazo', +'leal', +'lección', +'leche', +'lector', +'leer', +'legión', +'legumbre', +'lejano', +'lengua', +'lento', +'leña', +'león', +'leopardo', +'lesión', +'letal', +'letra', +'leve', +'leyenda', +'libertad', +'libro', +'licor', +'líder', +'lidiar', +'lienzo', +'liga', +'ligero', +'lima', +'límite', +'limón', +'limpio', +'lince', +'lindo', +'línea', +'lingote', +'lino', +'linterna', +'líquido', +'liso', +'lista', +'litera', +'litio', +'litro', +'llaga', +'llama', +'llanto', +'llave', +'llegar', +'llenar', +'llevar', +'llorar', +'llover', +'lluvia', +'lobo', +'loción', +'loco', +'locura', +'lógica', +'logro', +'lombriz', +'lomo', +'lonja', +'lote', +'lucha', +'lucir', +'lugar', +'lujo', +'luna', +'lunes', +'lupa', +'lustro', +'luto', +'luz', +'maceta', +'macho', +'madera', +'madre', +'maduro', +'maestro', +'mafia', +'magia', +'mago', +'maíz', +'maldad', +'maleta', +'malla', +'malo', +'mamá', +'mambo', +'mamut', +'manco', +'mando', +'manejar', +'manga', +'maniquí', +'manjar', +'mano', +'manso', +'manta', +'mañana', +'mapa', +'máquina', +'mar', +'marco', +'marea', +'marfil', +'margen', +'marido', +'mármol', +'marrón', +'martes', +'marzo', +'masa', +'máscara', +'masivo', +'matar', +'materia', +'matiz', +'matriz', +'máximo', +'mayor', +'mazorca', +'mecha', +'medalla', +'medio', +'médula', +'mejilla', +'mejor', +'melena', +'melón', +'memoria', +'menor', +'mensaje', +'mente', +'menú', +'mercado', +'merengue', +'mérito', +'mes', +'mesón', +'meta', +'meter', +'método', +'metro', +'mezcla', +'miedo', +'miel', +'miembro', +'miga', +'mil', +'milagro', +'militar', +'millón', +'mimo', +'mina', +'minero', +'mínimo', +'minuto', +'miope', +'mirar', +'misa', +'miseria', +'misil', +'mismo', +'mitad', +'mito', +'mochila', +'moción', +'moda', +'modelo', +'moho', +'mojar', +'molde', +'moler', +'molino', +'momento', +'momia', +'monarca', +'moneda', +'monja', +'monto', +'moño', +'morada', +'morder', +'moreno', +'morir', +'morro', +'morsa', +'mortal', +'mosca', +'mostrar', +'motivo', +'mover', +'móvil', +'mozo', +'mucho', +'mudar', +'mueble', +'muela', +'muerte', +'muestra', +'mugre', +'mujer', +'mula', +'muleta', +'multa', +'mundo', +'muñeca', +'mural', +'muro', +'músculo', +'museo', +'musgo', +'música', +'muslo', +'nácar', +'nación', +'nadar', +'naipe', +'naranja', +'nariz', +'narrar', +'nasal', +'natal', +'nativo', +'natural', +'náusea', +'naval', +'nave', +'navidad', +'necio', +'néctar', +'negar', +'negocio', +'negro', +'neón', +'nervio', +'neto', +'neutro', +'nevar', +'nevera', +'nicho', +'nido', +'niebla', +'nieto', +'niñez', +'niño', +'nítido', +'nivel', +'nobleza', +'noche', +'nómina', +'noria', +'norma', +'norte', +'nota', +'noticia', +'novato', +'novela', +'novio', +'nube', +'nuca', +'núcleo', +'nudillo', +'nudo', +'nuera', +'nueve', +'nuez', +'nulo', +'número', +'nutria', +'oasis', +'obeso', +'obispo', +'objeto', +'obra', +'obrero', +'observar', +'obtener', +'obvio', +'oca', +'ocaso', +'océano', +'ochenta', +'ocho', +'ocio', +'ocre', +'octavo', +'octubre', +'oculto', +'ocupar', +'ocurrir', +'odiar', +'odio', +'odisea', +'oeste', +'ofensa', +'oferta', +'oficio', +'ofrecer', +'ogro', +'oído', +'oír', +'ojo', +'ola', +'oleada', +'olfato', +'olivo', +'olla', +'olmo', +'olor', +'olvido', +'ombligo', +'onda', +'onza', +'opaco', +'opción', +'ópera', +'opinar', +'oponer', +'optar', +'óptica', +'opuesto', +'oración', +'orador', +'oral', +'órbita', +'orca', +'orden', +'oreja', +'órgano', +'orgía', +'orgullo', +'oriente', +'origen', +'orilla', +'oro', +'orquesta', +'oruga', +'osadía', +'oscuro', +'osezno', +'oso', +'ostra', +'otoño', +'otro', +'oveja', +'óvulo', +'óxido', +'oxígeno', +'oyente', +'ozono', +'pacto', +'padre', +'paella', +'página', +'pago', +'país', +'pájaro', +'palabra', +'palco', +'paleta', +'pálido', +'palma', +'paloma', +'palpar', +'pan', +'panal', +'pánico', +'pantera', +'pañuelo', +'papá', +'papel', +'papilla', +'paquete', +'parar', +'parcela', +'pared', +'parir', +'paro', +'párpado', +'parque', +'párrafo', +'parte', +'pasar', +'paseo', +'pasión', +'paso', +'pasta', +'pata', +'patio', +'patria', +'pausa', +'pauta', +'pavo', +'payaso', +'peatón', +'pecado', +'pecera', +'pecho', +'pedal', +'pedir', +'pegar', +'peine', +'pelar', +'peldaño', +'pelea', +'peligro', +'pellejo', +'pelo', +'peluca', +'pena', +'pensar', +'peñón', +'peón', +'peor', +'pepino', +'pequeño', +'pera', +'percha', +'perder', +'pereza', +'perfil', +'perico', +'perla', +'permiso', +'perro', +'persona', +'pesa', +'pesca', +'pésimo', +'pestaña', +'pétalo', +'petróleo', +'pez', +'pezuña', +'picar', +'pichón', +'pie', +'piedra', +'pierna', +'pieza', +'pijama', +'pilar', +'piloto', +'pimienta', +'pino', +'pintor', +'pinza', +'piña', +'piojo', +'pipa', +'pirata', +'pisar', +'piscina', +'piso', +'pista', +'pitón', +'pizca', +'placa', +'plan', +'plata', +'playa', +'plaza', +'pleito', +'pleno', +'plomo', +'pluma', +'plural', +'pobre', +'poco', +'poder', +'podio', +'poema', +'poesía', +'poeta', +'polen', +'policía', +'pollo', +'polvo', +'pomada', +'pomelo', +'pomo', +'pompa', +'poner', +'porción', +'portal', +'posada', +'poseer', +'posible', +'poste', +'potencia', +'potro', +'pozo', +'prado', +'precoz', +'pregunta', +'premio', +'prensa', +'preso', +'previo', +'primo', +'príncipe', +'prisión', +'privar', +'proa', +'probar', +'proceso', +'producto', +'proeza', +'profesor', +'programa', +'prole', +'promesa', +'pronto', +'propio', +'próximo', +'prueba', +'público', +'puchero', +'pudor', +'pueblo', +'puerta', +'puesto', +'pulga', +'pulir', +'pulmón', +'pulpo', +'pulso', +'puma', +'punto', +'puñal', +'puño', +'pupa', +'pupila', +'puré', +'quedar', +'queja', +'quemar', +'querer', +'queso', +'quieto', +'química', +'quince', +'quitar', +'rábano', +'rabia', +'rabo', +'ración', +'radical', +'raíz', +'rama', +'rampa', +'rancho', +'rango', +'rapaz', +'rápido', +'rapto', +'rasgo', +'raspa', +'rato', +'rayo', +'raza', +'razón', +'reacción', +'realidad', +'rebaño', +'rebote', +'recaer', +'receta', +'rechazo', +'recoger', +'recreo', +'recto', +'recurso', +'red', +'redondo', +'reducir', +'reflejo', +'reforma', +'refrán', +'refugio', +'regalo', +'regir', +'regla', +'regreso', +'rehén', +'reino', +'reír', +'reja', +'relato', +'relevo', +'relieve', +'relleno', +'reloj', +'remar', +'remedio', +'remo', +'rencor', +'rendir', +'renta', +'reparto', +'repetir', +'reposo', +'reptil', +'res', +'rescate', +'resina', +'respeto', +'resto', +'resumen', +'retiro', +'retorno', +'retrato', +'reunir', +'revés', +'revista', +'rey', +'rezar', +'rico', +'riego', +'rienda', +'riesgo', +'rifa', +'rígido', +'rigor', +'rincón', +'riñón', +'río', +'riqueza', +'risa', +'ritmo', +'rito', +'rizo', +'roble', +'roce', +'rociar', +'rodar', +'rodeo', +'rodilla', +'roer', +'rojizo', +'rojo', +'romero', +'romper', +'ron', +'ronco', +'ronda', +'ropa', +'ropero', +'rosa', +'rosca', +'rostro', +'rotar', +'rubí', +'rubor', +'rudo', +'rueda', +'rugir', +'ruido', +'ruina', +'ruleta', +'rulo', +'rumbo', +'rumor', +'ruptura', +'ruta', +'rutina', +'sábado', +'saber', +'sabio', +'sable', +'sacar', +'sagaz', +'sagrado', +'sala', +'saldo', +'salero', +'salir', +'salmón', +'salón', +'salsa', +'salto', +'salud', +'salvar', +'samba', +'sanción', +'sandía', +'sanear', +'sangre', +'sanidad', +'sano', +'santo', +'sapo', +'saque', +'sardina', +'sartén', +'sastre', +'satán', +'sauna', +'saxofón', +'sección', +'seco', +'secreto', +'secta', +'sed', +'seguir', +'seis', +'sello', +'selva', +'semana', +'semilla', +'senda', +'sensor', +'señal', +'señor', +'separar', +'sepia', +'sequía', +'ser', +'serie', +'sermón', +'servir', +'sesenta', +'sesión', +'seta', +'setenta', +'severo', +'sexo', +'sexto', +'sidra', +'siesta', +'siete', +'siglo', +'signo', +'sílaba', +'silbar', +'silencio', +'silla', +'símbolo', +'simio', +'sirena', +'sistema', +'sitio', +'situar', +'sobre', +'socio', +'sodio', +'sol', +'solapa', +'soldado', +'soledad', +'sólido', +'soltar', +'solución', +'sombra', +'sondeo', +'sonido', +'sonoro', +'sonrisa', +'sopa', +'soplar', +'soporte', +'sordo', +'sorpresa', +'sorteo', +'sostén', +'sótano', +'suave', +'subir', +'suceso', +'sudor', +'suegra', +'suelo', +'sueño', +'suerte', +'sufrir', +'sujeto', +'sultán', +'sumar', +'superar', +'suplir', +'suponer', +'supremo', +'sur', +'surco', +'sureño', +'surgir', +'susto', +'sutil', +'tabaco', +'tabique', +'tabla', +'tabú', +'taco', +'tacto', +'tajo', +'talar', +'talco', +'talento', +'talla', +'talón', +'tamaño', +'tambor', +'tango', +'tanque', +'tapa', +'tapete', +'tapia', +'tapón', +'taquilla', +'tarde', +'tarea', +'tarifa', +'tarjeta', +'tarot', +'tarro', +'tarta', +'tatuaje', +'tauro', +'taza', +'tazón', +'teatro', +'techo', +'tecla', +'técnica', +'tejado', +'tejer', +'tejido', +'tela', +'teléfono', +'tema', +'temor', +'templo', +'tenaz', +'tender', +'tener', +'tenis', +'tenso', +'teoría', +'terapia', +'terco', +'término', +'ternura', +'terror', +'tesis', +'tesoro', +'testigo', +'tetera', +'texto', +'tez', +'tibio', +'tiburón', +'tiempo', +'tienda', +'tierra', +'tieso', +'tigre', +'tijera', +'tilde', +'timbre', +'tímido', +'timo', +'tinta', +'tío', +'típico', +'tipo', +'tira', +'tirón', +'titán', +'títere', +'título', +'tiza', +'toalla', +'tobillo', +'tocar', +'tocino', +'todo', +'toga', +'toldo', +'tomar', +'tono', +'tonto', +'topar', +'tope', +'toque', +'tórax', +'torero', +'tormenta', +'torneo', +'toro', +'torpedo', +'torre', +'torso', +'tortuga', +'tos', +'tosco', +'toser', +'tóxico', +'trabajo', +'tractor', +'traer', +'tráfico', +'trago', +'traje', +'tramo', +'trance', +'trato', +'trauma', +'trazar', +'trébol', +'tregua', +'treinta', +'tren', +'trepar', +'tres', +'tribu', +'trigo', +'tripa', +'triste', +'triunfo', +'trofeo', +'trompa', +'tronco', +'tropa', +'trote', +'trozo', +'truco', +'trueno', +'trufa', +'tubería', +'tubo', +'tuerto', +'tumba', +'tumor', +'túnel', +'túnica', +'turbina', +'turismo', +'turno', +'tutor', +'ubicar', +'úlcera', +'umbral', +'unidad', +'unir', +'universo', +'uno', +'untar', +'uña', +'urbano', +'urbe', +'urgente', +'urna', +'usar', +'usuario', +'útil', +'utopía', +'uva', +'vaca', +'vacío', +'vacuna', +'vagar', +'vago', +'vaina', +'vajilla', +'vale', +'válido', +'valle', +'valor', +'válvula', +'vampiro', +'vara', +'variar', +'varón', +'vaso', +'vecino', +'vector', +'vehículo', +'veinte', +'vejez', +'vela', +'velero', +'veloz', +'vena', +'vencer', +'venda', +'veneno', +'vengar', +'venir', +'venta', +'venus', +'ver', +'verano', +'verbo', +'verde', +'vereda', +'verja', +'verso', +'verter', +'vía', +'viaje', +'vibrar', +'vicio', +'víctima', +'vida', +'vídeo', +'vidrio', +'viejo', +'viernes', +'vigor', +'vil', +'villa', +'vinagre', +'vino', +'viñedo', +'violín', +'viral', +'virgo', +'virtud', +'visor', +'víspera', +'vista', +'vitamina', +'viudo', +'vivaz', +'vivero', +'vivir', +'vivo', +'volcán', +'volumen', +'volver', +'voraz', +'votar', +'voto', +'voz', +'vuelo', +'vulgar', +'yacer', +'yate', +'yegua', +'yema', +'yerno', +'yeso', +'yodo', +'yoga', +'yogur', +'zafiro', +'zanja', +'zapato', +'zarza', +'zona', +'zorro', +'zumo', +'zurdo' +] diff --git a/torba/words/spanish.txt b/torba/words/spanish.txt deleted file mode 100644 index d0900c2c7..000000000 --- a/torba/words/spanish.txt +++ /dev/null @@ -1,2048 +0,0 @@ -ábaco -abdomen -abeja -abierto -abogado -abono -aborto -abrazo -abrir -abuelo -abuso -acabar -academia -acceso -acción -aceite -acelga -acento -aceptar -ácido -aclarar -acné -acoger -acoso -activo -acto -actriz -actuar -acudir -acuerdo -acusar -adicto -admitir -adoptar -adorno -aduana -adulto -aéreo -afectar -afición -afinar -afirmar -ágil -agitar -agonía -agosto -agotar -agregar -agrio -agua -agudo -águila -aguja -ahogo -ahorro -aire -aislar -ajedrez -ajeno -ajuste -alacrán -alambre -alarma -alba -álbum -alcalde -aldea -alegre -alejar -alerta -aleta -alfiler -alga -algodón -aliado -aliento -alivio -alma -almeja -almíbar -altar -alteza -altivo -alto -altura -alumno -alzar -amable -amante -amapola -amargo -amasar -ámbar -ámbito -ameno -amigo -amistad -amor -amparo -amplio -ancho -anciano -ancla -andar -andén -anemia -ángulo -anillo -ánimo -anís -anotar -antena -antiguo -antojo -anual -anular -anuncio -añadir -añejo -año -apagar -aparato -apetito -apio -aplicar -apodo -aporte -apoyo -aprender -aprobar -apuesta -apuro -arado -araña -arar -árbitro -árbol -arbusto -archivo -arco -arder -ardilla -arduo -área -árido -aries -armonía -arnés -aroma -arpa -arpón -arreglo -arroz -arruga -arte -artista -asa -asado -asalto -ascenso -asegurar -aseo -asesor -asiento -asilo -asistir -asno -asombro -áspero -astilla -astro -astuto -asumir -asunto -atajo -ataque -atar -atento -ateo -ático -atleta -átomo -atraer -atroz -atún -audaz -audio -auge -aula -aumento -ausente -autor -aval -avance -avaro -ave -avellana -avena -avestruz -avión -aviso -ayer -ayuda -ayuno -azafrán -azar -azote -azúcar -azufre -azul -baba -babor -bache -bahía -baile -bajar -balanza -balcón -balde -bambú -banco -banda -baño -barba -barco -barniz -barro -báscula -bastón -basura -batalla -batería -batir -batuta -baúl -bazar -bebé -bebida -bello -besar -beso -bestia -bicho -bien -bingo -blanco -bloque -blusa -boa -bobina -bobo -boca -bocina -boda -bodega -boina -bola -bolero -bolsa -bomba -bondad -bonito -bono -bonsái -borde -borrar -bosque -bote -botín -bóveda -bozal -bravo -brazo -brecha -breve -brillo -brinco -brisa -broca -broma -bronce -brote -bruja -brusco -bruto -buceo -bucle -bueno -buey -bufanda -bufón -búho -buitre -bulto -burbuja -burla -burro -buscar -butaca -buzón -caballo -cabeza -cabina -cabra -cacao -cadáver -cadena -caer -café -caída -caimán -caja -cajón -cal -calamar -calcio -caldo -calidad -calle -calma -calor -calvo -cama -cambio -camello -camino -campo -cáncer -candil -canela -canguro -canica -canto -caña -cañón -caoba -caos -capaz -capitán -capote -captar -capucha -cara -carbón -cárcel -careta -carga -cariño -carne -carpeta -carro -carta -casa -casco -casero -caspa -castor -catorce -catre -caudal -causa -cazo -cebolla -ceder -cedro -celda -célebre -celoso -célula -cemento -ceniza -centro -cerca -cerdo -cereza -cero -cerrar -certeza -césped -cetro -chacal -chaleco -champú -chancla -chapa -charla -chico -chiste -chivo -choque -choza -chuleta -chupar -ciclón -ciego -cielo -cien -cierto -cifra -cigarro -cima -cinco -cine -cinta -ciprés -circo -ciruela -cisne -cita -ciudad -clamor -clan -claro -clase -clave -cliente -clima -clínica -cobre -cocción -cochino -cocina -coco -código -codo -cofre -coger -cohete -cojín -cojo -cola -colcha -colegio -colgar -colina -collar -colmo -columna -combate -comer -comida -cómodo -compra -conde -conejo -conga -conocer -consejo -contar -copa -copia -corazón -corbata -corcho -cordón -corona -correr -coser -cosmos -costa -cráneo -cráter -crear -crecer -creído -crema -cría -crimen -cripta -crisis -cromo -crónica -croqueta -crudo -cruz -cuadro -cuarto -cuatro -cubo -cubrir -cuchara -cuello -cuento -cuerda -cuesta -cueva -cuidar -culebra -culpa -culto -cumbre -cumplir -cuna -cuneta -cuota -cupón -cúpula -curar -curioso -curso -curva -cutis -dama -danza -dar -dardo -dátil -deber -débil -década -decir -dedo -defensa -definir -dejar -delfín -delgado -delito -demora -denso -dental -deporte -derecho -derrota -desayuno -deseo -desfile -desnudo -destino -desvío -detalle -detener -deuda -día -diablo -diadema -diamante -diana -diario -dibujo -dictar -diente -dieta -diez -difícil -digno -dilema -diluir -dinero -directo -dirigir -disco -diseño -disfraz -diva -divino -doble -doce -dolor -domingo -don -donar -dorado -dormir -dorso -dos -dosis -dragón -droga -ducha -duda -duelo -dueño -dulce -dúo -duque -durar -dureza -duro -ébano -ebrio -echar -eco -ecuador -edad -edición -edificio -editor -educar -efecto -eficaz -eje -ejemplo -elefante -elegir -elemento -elevar -elipse -élite -elixir -elogio -eludir -embudo -emitir -emoción -empate -empeño -empleo -empresa -enano -encargo -enchufe -encía -enemigo -enero -enfado -enfermo -engaño -enigma -enlace -enorme -enredo -ensayo -enseñar -entero -entrar -envase -envío -época -equipo -erizo -escala -escena -escolar -escribir -escudo -esencia -esfera -esfuerzo -espada -espejo -espía -esposa -espuma -esquí -estar -este -estilo -estufa -etapa -eterno -ética -etnia -evadir -evaluar -evento -evitar -exacto -examen -exceso -excusa -exento -exigir -exilio -existir -éxito -experto -explicar -exponer -extremo -fábrica -fábula -fachada -fácil -factor -faena -faja -falda -fallo -falso -faltar -fama -familia -famoso -faraón -farmacia -farol -farsa -fase -fatiga -fauna -favor -fax -febrero -fecha -feliz -feo -feria -feroz -fértil -fervor -festín -fiable -fianza -fiar -fibra -ficción -ficha -fideo -fiebre -fiel -fiera -fiesta -figura -fijar -fijo -fila -filete -filial -filtro -fin -finca -fingir -finito -firma -flaco -flauta -flecha -flor -flota -fluir -flujo -flúor -fobia -foca -fogata -fogón -folio -folleto -fondo -forma -forro -fortuna -forzar -fosa -foto -fracaso -frágil -franja -frase -fraude -freír -freno -fresa -frío -frito -fruta -fuego -fuente -fuerza -fuga -fumar -función -funda -furgón -furia -fusil -fútbol -futuro -gacela -gafas -gaita -gajo -gala -galería -gallo -gamba -ganar -gancho -ganga -ganso -garaje -garza -gasolina -gastar -gato -gavilán -gemelo -gemir -gen -género -genio -gente -geranio -gerente -germen -gesto -gigante -gimnasio -girar -giro -glaciar -globo -gloria -gol -golfo -goloso -golpe -goma -gordo -gorila -gorra -gota -goteo -gozar -grada -gráfico -grano -grasa -gratis -grave -grieta -grillo -gripe -gris -grito -grosor -grúa -grueso -grumo -grupo -guante -guapo -guardia -guerra -guía -guiño -guion -guiso -guitarra -gusano -gustar -haber -hábil -hablar -hacer -hacha -hada -hallar -hamaca -harina -haz -hazaña -hebilla -hebra -hecho -helado -helio -hembra -herir -hermano -héroe -hervir -hielo -hierro -hígado -higiene -hijo -himno -historia -hocico -hogar -hoguera -hoja -hombre -hongo -honor -honra -hora -hormiga -horno -hostil -hoyo -hueco -huelga -huerta -hueso -huevo -huida -huir -humano -húmedo -humilde -humo -hundir -huracán -hurto -icono -ideal -idioma -ídolo -iglesia -iglú -igual -ilegal -ilusión -imagen -imán -imitar -impar -imperio -imponer -impulso -incapaz -índice -inerte -infiel -informe -ingenio -inicio -inmenso -inmune -innato -insecto -instante -interés -íntimo -intuir -inútil -invierno -ira -iris -ironía -isla -islote -jabalí -jabón -jamón -jarabe -jardín -jarra -jaula -jazmín -jefe -jeringa -jinete -jornada -joroba -joven -joya -juerga -jueves -juez -jugador -jugo -juguete -juicio -junco -jungla -junio -juntar -júpiter -jurar -justo -juvenil -juzgar -kilo -koala -labio -lacio -lacra -lado -ladrón -lagarto -lágrima -laguna -laico -lamer -lámina -lámpara -lana -lancha -langosta -lanza -lápiz -largo -larva -lástima -lata -látex -latir -laurel -lavar -lazo -leal -lección -leche -lector -leer -legión -legumbre -lejano -lengua -lento -leña -león -leopardo -lesión -letal -letra -leve -leyenda -libertad -libro -licor -líder -lidiar -lienzo -liga -ligero -lima -límite -limón -limpio -lince -lindo -línea -lingote -lino -linterna -líquido -liso -lista -litera -litio -litro -llaga -llama -llanto -llave -llegar -llenar -llevar -llorar -llover -lluvia -lobo -loción -loco -locura -lógica -logro -lombriz -lomo -lonja -lote -lucha -lucir -lugar -lujo -luna -lunes -lupa -lustro -luto -luz -maceta -macho -madera -madre -maduro -maestro -mafia -magia -mago -maíz -maldad -maleta -malla -malo -mamá -mambo -mamut -manco -mando -manejar -manga -maniquí -manjar -mano -manso -manta -mañana -mapa -máquina -mar -marco -marea -marfil -margen -marido -mármol -marrón -martes -marzo -masa -máscara -masivo -matar -materia -matiz -matriz -máximo -mayor -mazorca -mecha -medalla -medio -médula -mejilla -mejor -melena -melón -memoria -menor -mensaje -mente -menú -mercado -merengue -mérito -mes -mesón -meta -meter -método -metro -mezcla -miedo -miel -miembro -miga -mil -milagro -militar -millón -mimo -mina -minero -mínimo -minuto -miope -mirar -misa -miseria -misil -mismo -mitad -mito -mochila -moción -moda -modelo -moho -mojar -molde -moler -molino -momento -momia -monarca -moneda -monja -monto -moño -morada -morder -moreno -morir -morro -morsa -mortal -mosca -mostrar -motivo -mover -móvil -mozo -mucho -mudar -mueble -muela -muerte -muestra -mugre -mujer -mula -muleta -multa -mundo -muñeca -mural -muro -músculo -museo -musgo -música -muslo -nácar -nación -nadar -naipe -naranja -nariz -narrar -nasal -natal -nativo -natural -náusea -naval -nave -navidad -necio -néctar -negar -negocio -negro -neón -nervio -neto -neutro -nevar -nevera -nicho -nido -niebla -nieto -niñez -niño -nítido -nivel -nobleza -noche -nómina -noria -norma -norte -nota -noticia -novato -novela -novio -nube -nuca -núcleo -nudillo -nudo -nuera -nueve -nuez -nulo -número -nutria -oasis -obeso -obispo -objeto -obra -obrero -observar -obtener -obvio -oca -ocaso -océano -ochenta -ocho -ocio -ocre -octavo -octubre -oculto -ocupar -ocurrir -odiar -odio -odisea -oeste -ofensa -oferta -oficio -ofrecer -ogro -oído -oír -ojo -ola -oleada -olfato -olivo -olla -olmo -olor -olvido -ombligo -onda -onza -opaco -opción -ópera -opinar -oponer -optar -óptica -opuesto -oración -orador -oral -órbita -orca -orden -oreja -órgano -orgía -orgullo -oriente -origen -orilla -oro -orquesta -oruga -osadía -oscuro -osezno -oso -ostra -otoño -otro -oveja -óvulo -óxido -oxígeno -oyente -ozono -pacto -padre -paella -página -pago -país -pájaro -palabra -palco -paleta -pálido -palma -paloma -palpar -pan -panal -pánico -pantera -pañuelo -papá -papel -papilla -paquete -parar -parcela -pared -parir -paro -párpado -parque -párrafo -parte -pasar -paseo -pasión -paso -pasta -pata -patio -patria -pausa -pauta -pavo -payaso -peatón -pecado -pecera -pecho -pedal -pedir -pegar -peine -pelar -peldaño -pelea -peligro -pellejo -pelo -peluca -pena -pensar -peñón -peón -peor -pepino -pequeño -pera -percha -perder -pereza -perfil -perico -perla -permiso -perro -persona -pesa -pesca -pésimo -pestaña -pétalo -petróleo -pez -pezuña -picar -pichón -pie -piedra -pierna -pieza -pijama -pilar -piloto -pimienta -pino -pintor -pinza -piña -piojo -pipa -pirata -pisar -piscina -piso -pista -pitón -pizca -placa -plan -plata -playa -plaza -pleito -pleno -plomo -pluma -plural -pobre -poco -poder -podio -poema -poesía -poeta -polen -policía -pollo -polvo -pomada -pomelo -pomo -pompa -poner -porción -portal -posada -poseer -posible -poste -potencia -potro -pozo -prado -precoz -pregunta -premio -prensa -preso -previo -primo -príncipe -prisión -privar -proa -probar -proceso -producto -proeza -profesor -programa -prole -promesa -pronto -propio -próximo -prueba -público -puchero -pudor -pueblo -puerta -puesto -pulga -pulir -pulmón -pulpo -pulso -puma -punto -puñal -puño -pupa -pupila -puré -quedar -queja -quemar -querer -queso -quieto -química -quince -quitar -rábano -rabia -rabo -ración -radical -raíz -rama -rampa -rancho -rango -rapaz -rápido -rapto -rasgo -raspa -rato -rayo -raza -razón -reacción -realidad -rebaño -rebote -recaer -receta -rechazo -recoger -recreo -recto -recurso -red -redondo -reducir -reflejo -reforma -refrán -refugio -regalo -regir -regla -regreso -rehén -reino -reír -reja -relato -relevo -relieve -relleno -reloj -remar -remedio -remo -rencor -rendir -renta -reparto -repetir -reposo -reptil -res -rescate -resina -respeto -resto -resumen -retiro -retorno -retrato -reunir -revés -revista -rey -rezar -rico -riego -rienda -riesgo -rifa -rígido -rigor -rincón -riñón -río -riqueza -risa -ritmo -rito -rizo -roble -roce -rociar -rodar -rodeo -rodilla -roer -rojizo -rojo -romero -romper -ron -ronco -ronda -ropa -ropero -rosa -rosca -rostro -rotar -rubí -rubor -rudo -rueda -rugir -ruido -ruina -ruleta -rulo -rumbo -rumor -ruptura -ruta -rutina -sábado -saber -sabio -sable -sacar -sagaz -sagrado -sala -saldo -salero -salir -salmón -salón -salsa -salto -salud -salvar -samba -sanción -sandía -sanear -sangre -sanidad -sano -santo -sapo -saque -sardina -sartén -sastre -satán -sauna -saxofón -sección -seco -secreto -secta -sed -seguir -seis -sello -selva -semana -semilla -senda -sensor -señal -señor -separar -sepia -sequía -ser -serie -sermón -servir -sesenta -sesión -seta -setenta -severo -sexo -sexto -sidra -siesta -siete -siglo -signo -sílaba -silbar -silencio -silla -símbolo -simio -sirena -sistema -sitio -situar -sobre -socio -sodio -sol -solapa -soldado -soledad -sólido -soltar -solución -sombra -sondeo -sonido -sonoro -sonrisa -sopa -soplar -soporte -sordo -sorpresa -sorteo -sostén -sótano -suave -subir -suceso -sudor -suegra -suelo -sueño -suerte -sufrir -sujeto -sultán -sumar -superar -suplir -suponer -supremo -sur -surco -sureño -surgir -susto -sutil -tabaco -tabique -tabla -tabú -taco -tacto -tajo -talar -talco -talento -talla -talón -tamaño -tambor -tango -tanque -tapa -tapete -tapia -tapón -taquilla -tarde -tarea -tarifa -tarjeta -tarot -tarro -tarta -tatuaje -tauro -taza -tazón -teatro -techo -tecla -técnica -tejado -tejer -tejido -tela -teléfono -tema -temor -templo -tenaz -tender -tener -tenis -tenso -teoría -terapia -terco -término -ternura -terror -tesis -tesoro -testigo -tetera -texto -tez -tibio -tiburón -tiempo -tienda -tierra -tieso -tigre -tijera -tilde -timbre -tímido -timo -tinta -tío -típico -tipo -tira -tirón -titán -títere -título -tiza -toalla -tobillo -tocar -tocino -todo -toga -toldo -tomar -tono -tonto -topar -tope -toque -tórax -torero -tormenta -torneo -toro -torpedo -torre -torso -tortuga -tos -tosco -toser -tóxico -trabajo -tractor -traer -tráfico -trago -traje -tramo -trance -trato -trauma -trazar -trébol -tregua -treinta -tren -trepar -tres -tribu -trigo -tripa -triste -triunfo -trofeo -trompa -tronco -tropa -trote -trozo -truco -trueno -trufa -tubería -tubo -tuerto -tumba -tumor -túnel -túnica -turbina -turismo -turno -tutor -ubicar -úlcera -umbral -unidad -unir -universo -uno -untar -uña -urbano -urbe -urgente -urna -usar -usuario -útil -utopía -uva -vaca -vacío -vacuna -vagar -vago -vaina -vajilla -vale -válido -valle -valor -válvula -vampiro -vara -variar -varón -vaso -vecino -vector -vehículo -veinte -vejez -vela -velero -veloz -vena -vencer -venda -veneno -vengar -venir -venta -venus -ver -verano -verbo -verde -vereda -verja -verso -verter -vía -viaje -vibrar -vicio -víctima -vida -vídeo -vidrio -viejo -viernes -vigor -vil -villa -vinagre -vino -viñedo -violín -viral -virgo -virtud -visor -víspera -vista -vitamina -viudo -vivaz -vivero -vivir -vivo -volcán -volumen -volver -voraz -votar -voto -voz -vuelo -vulgar -yacer -yate -yegua -yema -yerno -yeso -yodo -yoga -yogur -zafiro -zanja -zapato -zarza -zona -zorro -zumo -zurdo From 71d99046d139dfc71c0c6b71c57b08118472e957 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 17 Sep 2018 22:44:24 -0400 Subject: [PATCH 109/383] dont perform pylint check in words directory --- setup.cfg | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.cfg b/setup.cfg index 1cb422611..de6c397aa 100644 --- a/setup.cfg +++ b/setup.cfg @@ -10,6 +10,7 @@ source = ignore_missing_imports = True [pylint] +ignore=words max-args=10 max-line-length=110 good-names=T,t,n,i,j,k,x,y,s,f,d,h,c,e,op,db,tx,io,cachedproperty,log,id From b3f3fdeb1d30b24384a2e997883a1a44c4bd650c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 18 Sep 2018 23:06:56 -0400 Subject: [PATCH 110/383] explicit import of english words --- torba/mnemonic.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/torba/mnemonic.py b/torba/mnemonic.py index 789221367..c207bbab9 100644 --- a/torba/mnemonic.py +++ b/torba/mnemonic.py @@ -13,6 +13,7 @@ import ecdsa import pbkdf2 from torba.hash import hmac_sha512 +from torba.words import english # The hash of the mnemonic seed must begin with this SEED_PREFIX = b'01' # Standard wallet @@ -77,6 +78,8 @@ def normalize_text(seed): def load_words(language_name): + if language_name == 'english': + return english.words language_module = importlib.import_module('torba.words.'+language_name) return list(map( lambda s: unicodedata.normalize('NFKD', s), From 18629c93a2cf287c0998b8d1d0bbd397840eb40a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 20 Sep 2018 13:00:38 -0400 Subject: [PATCH 111/383] defer.returnValue -> plain return per twisted support for Py3 plain return --- torba/baseledger.py | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index a498072da..9cb1c7337 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -136,7 +136,7 @@ class BaseLedger(metaclass=LedgerRegistry): def get_transaction(self, txhash): raw, _, _ = yield self.db.get_transaction(txhash) if raw is not None: - defer.returnValue(self.transaction_class(raw)) + return self.transaction_class(raw) @defer.inlineCallbacks def get_private_key_for_address(self, address): @@ -144,7 +144,7 @@ class BaseLedger(metaclass=LedgerRegistry): if match: for account in self.accounts: if match['account'] == account.public_key.address: - defer.returnValue(account.get_private_key(match['chain'], match['position'])) + return account.get_private_key(match['chain'], match['position']) @defer.inlineCallbacks def get_effective_amount_estimators(self, funding_accounts: Iterable[baseaccount.BaseAccount]): @@ -153,7 +153,7 @@ class BaseLedger(metaclass=LedgerRegistry): utxos = yield account.get_unspent_outputs() for utxo in utxos: estimators.append(utxo.get_estimator(self)) - defer.returnValue(estimators) + return estimators @defer.inlineCallbacks def get_spendable_utxos(self, amount: int, funding_accounts): @@ -172,7 +172,7 @@ class BaseLedger(metaclass=LedgerRegistry): raise finally: self._utxo_reservation_lock.release() - defer.returnValue(spendables) + return spendables def reserve_outputs(self, txos): return self.db.reserve_outputs(txos) @@ -185,14 +185,14 @@ class BaseLedger(metaclass=LedgerRegistry): address_details = yield self.db.get_address(address) history = address_details['history'] or '' h = sha256(history.encode()) - defer.returnValue(hexlify(h)) + return hexlify(h) @defer.inlineCallbacks def get_local_history(self, address): address_details = yield self.db.get_address(address) history = address_details['history'] or '' parts = history.split(':')[:-1] - defer.returnValue(list(zip(parts[0::2], map(int, parts[1::2])))) + return list(zip(parts[0::2], map(int, parts[1::2]))) @staticmethod def get_root_of_merkle_tree(branches, branch_positions, working_branch): @@ -208,11 +208,12 @@ class BaseLedger(metaclass=LedgerRegistry): @defer.inlineCallbacks def is_valid_transaction(self, tx, height): - height <= len(self.headers) or defer.returnValue(False) + if not height <= len(self.headers): + return False merkle = yield self.network.get_merkle(tx.id, height) merkle_root = self.get_root_of_merkle_tree(merkle['merkle'], merkle['pos'], tx.hash) header = self.headers[height] - defer.returnValue(merkle_root == header['merkle_root']) + return merkle_root == header['merkle_root'] @defer.inlineCallbacks def start(self): From d76758bd1d755f8eb1795c6f66f55750ba11d006 Mon Sep 17 00:00:00 2001 From: Thomas Zarebczan Date: Wed, 19 Sep 2018 00:49:35 -0400 Subject: [PATCH 112/383] am I doing this right? Copied from https://github.com/lbryio/lbry/commit/f1e36823025199461836733e2a1b2e22db35596e, looks like it could work, but didn't test locally. --- torba/basenetwork.py | 40 +++++++++++++++++++++++++++------------- 1 file changed, 27 insertions(+), 13 deletions(-) diff --git a/torba/basenetwork.py b/torba/basenetwork.py index 81085422f..e177dabb5 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -41,23 +41,37 @@ class StratumClientProtocol(LineOnlyReceiver): try: self.transport.setTcpNoDelay(True) self.transport.setTcpKeepAlive(True) - self.transport.socket.setsockopt( - socket.SOL_TCP, socket.TCP_KEEPIDLE, 120 - # Seconds before sending keepalive probes - ) - self.transport.socket.setsockopt( - socket.SOL_TCP, socket.TCP_KEEPINTVL, 1 - # Interval in seconds between keepalive probes - ) - self.transport.socket.setsockopt( - socket.SOL_TCP, socket.TCP_KEEPCNT, 5 - # Failed keepalive probles before declaring other end dead - ) - except Exception as err: # pylint: disable=broad-except + if hasattr(socket, "TCP_KEEPIDLE"): + self.transport.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPIDLE, + 120) # Seconds before sending keepalive probes + else: + log.debug("TCP_KEEPIDLE not available") + if hasattr(socket, "TCP_KEEPINTVL"): + self.transport.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPINTVL, + 1) # Interval in seconds between keepalive probes + else: + log.debug("TCP_KEEPINTVL not available") + if hasattr(socket, "TCP_KEEPCNT"): + self.transport.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPCNT, + 5) # Failed keepalive probles before declaring other end dead + else: + log.debug("TCP_KEEPCNT not available") + + except Exception as err: # pylint: disable=broad-except # Supported only by the socket transport, # but there's really no better place in code to trigger this. log.warning("Error setting up socket: %s", err) + self.request_id = 0 + self.lookup_table = {} + + self._connected.callback(True) + + # Initiate connection session + self.session = {} + + log.debug("Connected %s" % self.transport.getPeer().host) + def connectionLost(self, reason=None): self.on_disconnected_controller.add(True) From 89f4ec12e9f1f3d57840d9291a41749995abe24a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 20 Sep 2018 13:29:09 -0400 Subject: [PATCH 113/383] pylint cleanup --- torba/basenetwork.py | 28 ++++++++++++---------------- 1 file changed, 12 insertions(+), 16 deletions(-) diff --git a/torba/basenetwork.py b/torba/basenetwork.py index e177dabb5..dc1397a64 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -42,18 +42,24 @@ class StratumClientProtocol(LineOnlyReceiver): self.transport.setTcpNoDelay(True) self.transport.setTcpKeepAlive(True) if hasattr(socket, "TCP_KEEPIDLE"): - self.transport.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPIDLE, - 120) # Seconds before sending keepalive probes + self.transport.socket.setsockopt( + socket.SOL_TCP, socket.TCP_KEEPIDLE, 120 + # Seconds before sending keepalive probes + ) else: log.debug("TCP_KEEPIDLE not available") if hasattr(socket, "TCP_KEEPINTVL"): - self.transport.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPINTVL, - 1) # Interval in seconds between keepalive probes + self.transport.socket.setsockopt( + socket.SOL_TCP, socket.TCP_KEEPINTVL, 1 + # Interval in seconds between keepalive probes + ) else: log.debug("TCP_KEEPINTVL not available") if hasattr(socket, "TCP_KEEPCNT"): - self.transport.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPCNT, - 5) # Failed keepalive probles before declaring other end dead + self.transport.socket.setsockopt( + socket.SOL_TCP, socket.TCP_KEEPCNT, 5 + # Failed keepalive probles before declaring other end dead + ) else: log.debug("TCP_KEEPCNT not available") @@ -62,16 +68,6 @@ class StratumClientProtocol(LineOnlyReceiver): # but there's really no better place in code to trigger this. log.warning("Error setting up socket: %s", err) - self.request_id = 0 - self.lookup_table = {} - - self._connected.callback(True) - - # Initiate connection session - self.session = {} - - log.debug("Connected %s" % self.transport.getPeer().host) - def connectionLost(self, reason=None): self.on_disconnected_controller.add(True) From 543f533a68ca3b71ec64d78b1b957dfab2181230 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 20 Sep 2018 13:40:57 -0400 Subject: [PATCH 114/383] update bitcoin to 0.16.3 as 0.16.0 is no longer downloadable --- torba/coin/bitcoinsegwit.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torba/coin/bitcoinsegwit.py b/torba/coin/bitcoinsegwit.py index bae056eb3..167551086 100644 --- a/torba/coin/bitcoinsegwit.py +++ b/torba/coin/bitcoinsegwit.py @@ -1,8 +1,8 @@ __node_daemon__ = 'bitcoind' __node_cli__ = 'bitcoin-cli' -__node_bin__ = 'bitcoin-0.16.0/bin' +__node_bin__ = 'bitcoin-0.16.3/bin' __node_url__ = ( - 'https://bitcoin.org/bin/bitcoin-core-0.16.0/bitcoin-0.16.0-x86_64-linux-gnu.tar.gz' + 'https://bitcoin.org/bin/bitcoin-core-0.16.3/bitcoin-0.16.3-x86_64-linux-gnu.tar.gz' ) __electrumx__ = 'electrumx.lib.coins.BitcoinSegwitRegtest' From 0b75bb405204768d6bfc50d1387b3199979679de Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 21 Sep 2018 09:47:31 -0400 Subject: [PATCH 115/383] + added get_transactions --- torba/baseaccount.py | 3 +++ torba/basedatabase.py | 20 ++++++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index e7f020b2f..f22b5ad24 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -345,6 +345,9 @@ class BaseAccount: def get_inputs_outputs(self, **constraints): return self.ledger.db.get_txios_for_account(self, **constraints) + def get_transactions(self): + return self.ledger.db.get_transactions(self) + @defer.inlineCallbacks def fund(self, to_account, amount=None, everything=False, outputs=1, broadcast=False, **constraints): diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 8e4463631..d7b7c62ea 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -266,6 +266,26 @@ class BaseDatabase(SQLiteMixin): else: return None, None, False + @defer.inlineCallbacks + def get_transactions(self, account): + txs = self.run_query( + """ + SELECT raw FROM tx where txid in ( + SELECT txo.txid + FROM txo + JOIN pubkey_address USING (address) + WHERE pubkey_address.account = :account + UNION + SELECT txo.txid + FROM txi + JOIN txo USING (txoid) + JOIN pubkey_address USING (address) + WHERE pubkey_address.account = :account + ) + """, {'account': account.public_key.address} + ) + return [account.ledger.transaction_class(values[0]) for values in txs] + def get_balance_for_account(self, account, include_reserved=False, **constraints): if not include_reserved: constraints['is_reserved'] = 0 From 8a87195f551fff954b44093d7cbab05233b1c634 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Fri, 21 Sep 2018 17:12:07 -0300 Subject: [PATCH 116/383] ecdsa -> coincurve --- setup.cfg | 2 +- setup.py | 2 +- tests/unit/key_fixtures.py | 65 ++++++++++++++++++++ tests/unit/test_bip32.py | 33 ++++++++-- torba/bip32.py | 122 ++++++++----------------------------- torba/mnemonic.py | 6 +- 6 files changed, 124 insertions(+), 106 deletions(-) create mode 100644 tests/unit/key_fixtures.py diff --git a/setup.cfg b/setup.cfg index de6c397aa..30f659a16 100644 --- a/setup.cfg +++ b/setup.cfg @@ -6,7 +6,7 @@ source = torba .tox/*/lib/python*/site-packages/torba -[mypy-twisted.*,cryptography.*,ecdsa.*,pbkdf2] +[mypy-twisted.*,cryptography.*,coincurve.*,pbkdf2] ignore_missing_imports = True [pylint] diff --git a/setup.py b/setup.py index 49fca8b3b..f5b827c0c 100644 --- a/setup.py +++ b/setup.py @@ -27,7 +27,7 @@ setup( python_requires='>=3.6', install_requires=( 'twisted', - 'ecdsa', + 'coincurve', 'pbkdf2', 'cryptography' ), diff --git a/tests/unit/key_fixtures.py b/tests/unit/key_fixtures.py new file mode 100644 index 000000000..a5cdc04c7 --- /dev/null +++ b/tests/unit/key_fixtures.py @@ -0,0 +1,65 @@ +expected_ids = [ + b'948adae2a128c0bd1fa238117fd0d9690961f26e', + b'cd9f4f2adde7de0a53ab6d326bb6a62b489876dd', + b'c479e02a74a809ffecff60255d1c14f4081a197a', + b'4bab2fb2c424f31f170b15ec53c4a596db9d6710', + b'689cb7c621f57b7c398e7e04ed9a5098ab8389e9', + b'75116d6a689a0f9b56fe7cfec9cbbd0e16814288', + b'2439f0993fb298497dd7f317b9737c356f664a86', + b'32f1cb4799008cf5496bb8cafdaf59d5dabec6af', + b'fa29aa536353904e9cc813b0cf18efcc09e5ad13', + b'37df34002f34d7875428a2977df19be3f4f40a31', + b'8c8a72b5d2747a3e7e05ed85110188769d5656c3', + b'e5c8ef10c5bdaa79c9a237a096f50df4dcac27f0', + b'4d5270dc100fba85974665c20cd0f95d4822e8d1', + b'e76b07da0cdd59915475cd310599544b9744fa34', + b'6f009bccf8be99707161abb279d8ccf8fd953721', + b'f32f08b722cc8607c3f7f192b4d5f13a74c85785', + b'46f4430a5c91b9b799e9be6b47ac7a749d8d9f30', + b'ebbf9850abe0aae2d09e7e3ebd6b51f01282f39b', + b'5f6655438f8ddc6b2f6ea8197c8babaffc9f5c09', + b'e194e70ee8711b0ed765608121e4cceb551cdf28' +] +expected_privkeys = [ + b'95557ee9a2bb7665e67e45246658b5c839f7dcd99b6ebc800eeebccd28bf134a', + b'689b6921f65647a8e4fc1497924730c92ad4ad183f10fac2bdee65cc8fb6dcf9', + b'977ee018b448c530327b7e927cc3645ca4cb152c5dd98e1bd917c52fd46fc80a', + b'3c7fb05b0ab4da8b292e895f574f8213cadfe81b84ded7423eab61c5f884c8ae', + b'b21fc7be1e69182827538683a48ac9d95684faf6c1c6deabb6e513d8c76afcc9', + b'a5021734dbbf1d090b15509ba00f2c04a3d5afc19939b4594ca0850d4190b923', + b'07dfe0aa94c1b948dc935be1f8179f3050353b46f3a3134e77c70e66208be72d', + b'c331b2fb82cd91120b0703ee312042a854a51a8d945aa9e70fb14d68b0366fe1', + b'3aa59ec4d8f1e7ce2775854b5e82433535b6e3503f9a8e7c4e60aac066d44718', + b'ccc8b4ca73b266b4a0c89a9d33c4ec7532b434c9294c26832355e5e2bee2e005', + b'280c074d8982e56d70c404072252c309694a6e5c05457a6abbe8fc225c2dfd52', + b'546cee26da713a3a64b2066d5e3a52b7c1d927396d1ba8a3d9f6e3e973398856', + b'7fbc4615d5e819eee22db440c5bcc4ff25bb046841c41a192003a6d9abfbafbf', + b'5b63f13011cab965feea3a41fac2d7a877aa710ab20e2a9a1708474e3c05c050', + b'394b36f528947557d317fd40a4adde5514c8745a5f64185421fa2c0c4a158938', + b'8f101c8f5290ae6c0dd76d210b7effacd7f12db18f3befab711f533bde084c76', + b'6637a656f897a66080fbe60027d32c3f4ebc0e3b5f96123a33f932a091b039c2', + b'2815aa6667c042a3a4565fb789890cd33e380d047ed712759d097d479df71051', + b'120e761c6382b07a9548650a20b3b9dd74b906093260fa6f92f790ba71f79e8d', + b'823c8a613ea539f730a968518993195174bf973ed75c734b6898022867165d7b' +] +expected_hardened_privkeys = [ + b'abdba45b0459e7804beb68edb899e58a5c2636bf67d096711904001406afbd4c', + b'c9e804d4b8fdd99ef6ab2b0ca627a57f4283c28e11e9152ad9d3f863404d940e', + b'4cf87d68ae99711261f8cb8e1bde83b8703ff5d689ef70ce23106d1e6e8ed4bd', + b'dbf8d578c77f9bf62bb2ad40975e253af1e1d44d53abf84a22d2be29b9488f7f', + b'633bb840505521ffe39cb89a04fb8bff3298d6b64a5d8f170aca1e456d6f89b9', + b'92e80a38791bd8ba2105b9867fd58ac2cc4fb9853e18141b7fee1884bc5aae69', + b'd3663339af1386d05dd90ee20f627661ae87ddb1db0c2dc73fd8a4485930d0e7', + b'09a448303452d241b8a25670b36cc758975b97e88f62b6f25cd9084535e3c13a', + b'ee22eb77df05ff53e9c2ba797c1f2ebf97ec4cf5a99528adec94972674aeabed', + b'935facccb6120659c5b7c606a457c797e5a10ce4a728346e1a3a963251169651', + b'8ac9b4a48da1def375640ca03bc6711040dfd4eea7106d42bb4c2de83d7f595e', + b'51ecd3f7565c2b86d5782dbde2175ab26a7b896022564063fafe153588610be9', + b'04918252f6b6f51cd75957289b56a324b45cc085df80839137d740f9ada6c062', + b'2efbd0c839af971e3769c26938d776990ebf097989df4861535a7547a2701483', + b'85c6e31e6b27bd188291a910f4a7faba7fceb3e09df72884b10907ecc1491cd0', + b'05e245131885bebda993a31bb14ac98b794062a50af639ad22010aed1e533a54', + b'ddca42cf7db93f3a3f0723d5fee4c21bf60b7afac35d5c30eb34bd91b35cc609', + b'324a5c16030e0c3947e4dcd2b5057fd3a4d5bed96b23e3b476b2af0ab76369c9', + b'da63c41cdb398cdcd93e832f3e198528afbb4065821b026c143cec910d8362f0' +] diff --git a/tests/unit/test_bip32.py b/tests/unit/test_bip32.py index 5bd9fc407..59e7756f2 100644 --- a/tests/unit/test_bip32.py +++ b/tests/unit/test_bip32.py @@ -1,9 +1,10 @@ -from binascii import unhexlify +from binascii import unhexlify, hexlify from twisted.trial import unittest + +from .key_fixtures import expected_ids, expected_privkeys, expected_hardened_privkeys from torba.bip32 import PubKey, PrivateKey, from_extended_key_string from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class - class BIP32Tests(unittest.TestCase): def test_pubkey_validation(self): @@ -32,7 +33,10 @@ class BIP32Tests(unittest.TestCase): ) with self.assertRaisesRegex(ValueError, 'invalid BIP32 public key child number'): pubkey.child(-1) - self.assertIsInstance(pubkey.child(1), PubKey) + for i in range(20): + new_key = pubkey.child(i) + self.assertIsInstance(new_key, PubKey) + self.assertEqual(hexlify(new_key.identifier()), expected_ids[i]) def test_private_key_validation(self): with self.assertRaisesRegex(TypeError, 'private key must be raw bytes'): @@ -49,16 +53,35 @@ class BIP32Tests(unittest.TestCase): ) ec_point = private_key.ec_point() self.assertEqual( - ec_point.x(), 30487144161998778625547553412379759661411261804838752332906558028921886299019 + ec_point[0], 30487144161998778625547553412379759661411261804838752332906558028921886299019 ) self.assertEqual( - ec_point.y(), 86198965946979720220333266272536217633917099472454294641561154971209433250106 + ec_point[1], 86198965946979720220333266272536217633917099472454294641561154971209433250106 ) self.assertEqual(private_key.address(), '1GVM5dEhThbiyCZ9gqBZBv6p9whga7MTXo' ) with self.assertRaisesRegex(ValueError, 'invalid BIP32 private key child number'): private_key.child(-1) self.assertIsInstance(private_key.child(PrivateKey.HARDENED), PrivateKey) + def test_private_key_derivation(self): + private_key = PrivateKey( + ledger_class({ + 'db': ledger_class.database_class(':memory:'), + 'headers': ledger_class.headers_class(':memory:'), + }), + unhexlify('2423f3dc6087d9683f73a684935abc0ccd8bc26370588f56653128c6a6f0bf7c'), + b'abcd'*8, 0, 1 + ) + for i in range(20): + new_privkey = private_key.child(i) + self.assertIsInstance(new_privkey, PrivateKey) + self.assertEqual(hexlify(new_privkey.private_key_bytes), expected_privkeys[i]) + for i in range(PrivateKey.HARDENED + 1, private_key.HARDENED + 20): + new_privkey = private_key.child(i) + self.assertIsInstance(new_privkey, PrivateKey) + self.assertEqual(hexlify(new_privkey.private_key_bytes), expected_hardened_privkeys[i - 1 - PrivateKey.HARDENED]) + + def test_from_extended_keys(self): ledger = ledger_class({ 'db': ledger_class.database_class(':memory:'), diff --git a/torba/bip32.py b/torba/bip32.py index 7ef76aea6..7772356ac 100644 --- a/torba/bip32.py +++ b/torba/bip32.py @@ -7,16 +7,10 @@ # and warranty status of this software. """ Logic for BIP32 Hierarchical Key Derivation. """ - -import struct -import hashlib - -import ecdsa -import ecdsa.ellipticcurve as EC -import ecdsa.numbertheory as NT +from coincurve import PublicKey, PrivateKey as _PrivateKey from torba.hash import Base58, hmac_sha512, hash160, double_sha256 -from torba.util import cachedproperty, bytes_to_int, int_to_bytes +from torba.util import cachedproperty class DerivationError(Exception): @@ -26,8 +20,6 @@ class DerivationError(Exception): class _KeyBase: """ A BIP32 Key, public or private. """ - CURVE = ecdsa.SECP256k1 - def __init__(self, ledger, chain_code, n, depth, parent): if not isinstance(chain_code, (bytes, bytearray)): raise TypeError('chain code must be raw bytes') @@ -63,7 +55,7 @@ class _KeyBase: raise ValueError('raw_serkey must have length 33') return (ver_bytes + bytes((self.depth,)) - + self.parent_fingerprint() + struct.pack('>I', self.n) + + self.parent_fingerprint() + self.n.to_bytes(4, 'big') + self.chain_code + raw_serkey) def identifier(self): @@ -90,43 +82,26 @@ class PubKey(_KeyBase): def __init__(self, ledger, pubkey, chain_code, n, depth, parent=None): super().__init__(ledger, chain_code, n, depth, parent) - if isinstance(pubkey, ecdsa.VerifyingKey): + if isinstance(pubkey, PublicKey): self.verifying_key = pubkey else: self.verifying_key = self._verifying_key_from_pubkey(pubkey) @classmethod def _verifying_key_from_pubkey(cls, pubkey): - """ Converts a 33-byte compressed pubkey into an ecdsa.VerifyingKey object. """ + """ Converts a 33-byte compressed pubkey into an PublicKey object. """ if not isinstance(pubkey, (bytes, bytearray)): raise TypeError('pubkey must be raw bytes') if len(pubkey) != 33: raise ValueError('pubkey must be 33 bytes') if pubkey[0] not in (2, 3): raise ValueError('invalid pubkey prefix byte') - curve = cls.CURVE.curve - - is_odd = pubkey[0] == 3 - x = bytes_to_int(pubkey[1:]) - - # p is the finite field order - a, b, p = curve.a(), curve.b(), curve.p() # pylint: disable=invalid-name - y2 = pow(x, 3, p) + b # pylint: disable=invalid-name - assert a == 0 # Otherwise y2 += a * pow(x, 2, p) - y = NT.square_root_mod_prime(y2 % p, p) - if bool(y & 1) != is_odd: - y = p - y - point = EC.Point(curve, x, y) - - return ecdsa.VerifyingKey.from_public_point(point, curve=cls.CURVE) + return PublicKey(pubkey) @cachedproperty def pubkey_bytes(self): """ Return the compressed public key as 33 bytes. """ - point = self.verifying_key.pubkey.point - prefix = bytes((2 + (point.y() & 1),)) - padded_bytes = _exponent_to_bytes(point.x()) - return prefix + padded_bytes + return self.verifying_key.format(True) @cachedproperty def address(self): @@ -134,28 +109,17 @@ class PubKey(_KeyBase): return self.ledger.public_key_to_address(self.pubkey_bytes) def ec_point(self): - return self.verifying_key.pubkey.point + return self.verifying_key.point() - def child(self, n): + def child(self, n: int): """ Return the derived child extended pubkey at index N. """ if not 0 <= n < (1 << 31): raise ValueError('invalid BIP32 public key child number') - msg = self.pubkey_bytes + struct.pack('>I', n) - L, R = self._hmac_sha512(msg) # pylint: disable=invalid-name - - curve = self.CURVE - L = bytes_to_int(L) # pylint: disable=invalid-name - if L >= curve.order: - raise DerivationError - - point = curve.generator * L + self.ec_point() - if point == EC.INFINITY: - raise DerivationError - - verkey = ecdsa.VerifyingKey.from_public_point(point, curve=curve) - - return PubKey(self.ledger, verkey, R, n, self.depth + 1, self) + msg = self.pubkey_bytes + n.to_bytes(4, 'big') + L_b, R_b = self._hmac_sha512(msg) # pylint: disable=invalid-name + derived_key = self.verifying_key.add(L_b) + return PubKey(self.ledger, derived_key, R_b, n, self.depth + 1, self) def identifier(self): """ Return the key's identifier as 20 bytes. """ @@ -169,20 +133,6 @@ class PubKey(_KeyBase): ) -class LowSValueSigningKey(ecdsa.SigningKey): - """ - Enforce low S values in signatures - BIP-0062: https://github.com/bitcoin/bips/blob/master/bip-0062.mediawiki#low-s-values-in-signatures - """ - - def sign_number(self, number, entropy=None, k=None): - order = self.privkey.order - r, s = ecdsa.SigningKey.sign_number(self, number, entropy, k) # pylint: disable=invalid-name - if s > order / 2: - s = order - s - return r, s - - class PrivateKey(_KeyBase): """A BIP32 private key.""" @@ -190,16 +140,15 @@ class PrivateKey(_KeyBase): def __init__(self, ledger, privkey, chain_code, n, depth, parent=None): super().__init__(ledger, chain_code, n, depth, parent) - if isinstance(privkey, ecdsa.SigningKey): + if isinstance(privkey, _PrivateKey): self.signing_key = privkey else: self.signing_key = self._signing_key_from_privkey(privkey) @classmethod def _signing_key_from_privkey(cls, private_key): - """ Converts a 32-byte private key into an ecdsa.SigningKey object. """ - exponent = cls._private_key_secret_exponent(private_key) - return LowSValueSigningKey.from_secret_exponent(exponent, curve=cls.CURVE) + """ Converts a 32-byte private key into an coincurve.PrivateKey object. """ + return _PrivateKey.from_int(PrivateKey._private_key_secret_exponent(private_key)) @classmethod def _private_key_secret_exponent(cls, private_key): @@ -208,10 +157,7 @@ class PrivateKey(_KeyBase): raise TypeError('private key must be raw bytes') if len(private_key) != 32: raise ValueError('private key must be 32 bytes') - exponent = bytes_to_int(private_key) - if not 1 <= exponent < cls.CURVE.order: - raise ValueError('private key represents an invalid exponent') - return exponent + return int.from_bytes(private_key, 'big') @classmethod def from_seed(cls, ledger, seed): @@ -223,12 +169,12 @@ class PrivateKey(_KeyBase): @cachedproperty def private_key_bytes(self): """ Return the serialized private key (no leading zero byte). """ - return _exponent_to_bytes(self.secret_exponent()) + return self.signing_key.secret @cachedproperty def public_key(self): """ Return the corresponding extended public key. """ - verifying_key = self.signing_key.get_verifying_key() + verifying_key = self.signing_key.public_key parent_pubkey = self.parent.public_key if self.parent else None return PubKey(self.ledger, verifying_key, self.chain_code, self.n, self.depth, parent_pubkey) @@ -238,7 +184,7 @@ class PrivateKey(_KeyBase): def secret_exponent(self): """ Return the private key as a secret exponent. """ - return self.signing_key.privkey.secret_multiplier + return self.signing_key.to_int() def wif(self): """ Return the private key encoded in Wallet Import Format. """ @@ -258,24 +204,14 @@ class PrivateKey(_KeyBase): else: serkey = self.public_key.pubkey_bytes - msg = serkey + struct.pack('>I', n) - L, R = self._hmac_sha512(msg) # pylint: disable=invalid-name - - curve = self.CURVE - L = bytes_to_int(L) # pylint: disable=invalid-name - exponent = (L + bytes_to_int(self.private_key_bytes)) % curve.order - if exponent == 0 or L >= curve.order: - raise DerivationError - - privkey = _exponent_to_bytes(exponent) - - return PrivateKey(self.ledger, privkey, R, n, self.depth + 1, self) + msg = serkey + n.to_bytes(4, 'big') + L_b, R_b = self._hmac_sha512(msg) # pylint: disable=invalid-name + derived_key = self.signing_key.add(L_b) + return PrivateKey(self.ledger, derived_key, R_b, n, self.depth + 1, self) def sign(self, data): """ Produce a signature for piece of data by double hashing it and signing the hash. """ - key = self.signing_key - digest = double_sha256(data) - return key.sign_digest_deterministic(digest, hashlib.sha256, ecdsa.util.sigencode_der) + return self.signing_key.sign(data, hasher=double_sha256) def identifier(self): """Return the key's identifier as 20 bytes.""" @@ -289,11 +225,6 @@ class PrivateKey(_KeyBase): ) -def _exponent_to_bytes(exponent): - """Convert an exponent to 32 big-endian bytes""" - return (bytes((0,)*32) + int_to_bytes(exponent))[-32:] - - def _from_extended_key(ledger, ekey): """Return a PubKey or PrivateKey from an extended key raw bytes.""" if not isinstance(ekey, (bytes, bytearray)): @@ -302,8 +233,7 @@ def _from_extended_key(ledger, ekey): raise ValueError('extended key must have length 78') depth = ekey[4] - # fingerprint = ekey[5:9] - n, = struct.unpack('>I', ekey[9:13]) + n = int.from_bytes(ekey[9:13], 'big') chain_code = ekey[13:45] if ekey[:4] == ledger.extended_public_key_prefix: diff --git a/torba/mnemonic.py b/torba/mnemonic.py index c207bbab9..11451b6d9 100644 --- a/torba/mnemonic.py +++ b/torba/mnemonic.py @@ -8,8 +8,8 @@ import importlib import unicodedata import string from binascii import hexlify +from secrets import randbelow -import ecdsa import pbkdf2 from torba.hash import hmac_sha512 @@ -138,9 +138,9 @@ class Mnemonic: # rounding n = int(math.ceil(num_bits/bpw) * bpw) entropy = 1 - while entropy < pow(2, n - bpw): + while 0 < entropy < pow(2, n - bpw): # try again if seed would not contain enough words - entropy = ecdsa.util.randrange(pow(2, n)) + entropy = randbelow(pow(2, n)) nonce = 0 while True: nonce += 1 From 8ed0791b265d037dc4e6d9fdc24959bcc7a80cb1 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 21 Sep 2018 22:18:30 -0400 Subject: [PATCH 117/383] improved db.get_transactions() --- tests/integration/test_transactions.py | 11 +++- torba/baseaccount.py | 3 - torba/basedatabase.py | 79 ++++++++++++++++---------- torba/basetransaction.py | 18 ++---- 4 files changed, 65 insertions(+), 46 deletions(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index b9173b1c6..3cc2c8073 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -9,7 +9,7 @@ class BasicTransactionTests(IntegrationTestCase): async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) - yield self.ledger.update_account(account2) + await d2f(self.ledger.update_account(account2)) self.assertEqual(await self.get_balance(account1), 0) self.assertEqual(await self.get_balance(account2), 0) @@ -53,3 +53,12 @@ class BasicTransactionTests(IntegrationTestCase): await self.on_transaction(tx) # mempool await self.blockchain.generate(1) await self.on_transaction(tx) # confirmed + + txs = await d2f(account1.get_transactions()) + tx = txs[1] + self.assertEqual(round(tx.inputs[0].txo_ref.txo.amount/COIN, 1), 1.1) + self.assertEqual(round(tx.inputs[1].txo_ref.txo.amount/COIN, 1), 1.1) + self.assertEqual(round(tx.outputs[0].amount/COIN, 1), 2.0) + self.assertEqual(tx.outputs[0].get_address(self.ledger), address2) + self.assertEqual(tx.outputs[0].is_change, False) + self.assertEqual(tx.outputs[1].is_change, True) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index f22b5ad24..9a90d8244 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -342,9 +342,6 @@ class BaseAccount: def get_unspent_outputs(self, **constraints): return self.ledger.db.get_utxos_for_account(self, **constraints) - def get_inputs_outputs(self, **constraints): - return self.ledger.db.get_txios_for_account(self, **constraints) - def get_transactions(self): return self.ledger.db.get_transactions(self) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index d7b7c62ea..2912d49b9 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -6,6 +6,7 @@ from twisted.internet import defer from twisted.enterprise import adbapi from torba.hash import TXRefImmutable +from torba.basetransaction import TXORefResolvable log = logging.getLogger(__name__) @@ -267,24 +268,62 @@ class BaseDatabase(SQLiteMixin): return None, None, False @defer.inlineCallbacks - def get_transactions(self, account): - txs = self.run_query( + def get_transactions(self, account, offset=0, limit=100): + offset, limit = min(offset, 0), max(limit, 100) + tx_records = yield self.run_query( """ - SELECT raw FROM tx where txid in ( - SELECT txo.txid - FROM txo + SELECT txid, raw, height FROM tx WHERE txid IN ( + SELECT txo.txid FROM txo JOIN pubkey_address USING (address) WHERE pubkey_address.account = :account UNION - SELECT txo.txid - FROM txi + SELECT txo.txid FROM txi JOIN txo USING (txoid) JOIN pubkey_address USING (address) WHERE pubkey_address.account = :account - ) - """, {'account': account.public_key.address} + ) ORDER BY height DESC LIMIT :offset, :limit + """, {'account': account.public_key.address, 'offset': offset, 'limit': limit} ) - return [account.ledger.transaction_class(values[0]) for values in txs] + txids, txs = [], [] + for r in tx_records: + txids.append(r[0]) + txs.append(account.ledger.transaction_class(raw=r[1], height=r[2])) + + txo_records = yield self.run_query( + """ + SELECT txoid, pubkey_address.chain + FROM txo JOIN pubkey_address USING (address) + WHERE txid IN ({}) + """.format(', '.join(['?']*len(txids))), txids + ) + txos = dict(txo_records) + + txi_records = yield self.run_query( + """ + SELECT txoid, txo.amount, txo.script, txo.txid, txo.position + FROM txi JOIN txo USING (txoid) + WHERE txi.txid IN ({}) + """.format(', '.join(['?']*len(txids))), txids + ) + txis = {} + output_class = account.ledger.transaction_class.output_class + for r in txi_records: + txis[r[0]] = output_class( + r[1], + output_class.script_class(r[2]), + TXRefImmutable.from_id(r[3]), + position=r[4] + ) + + for tx in txs: + for txi in tx.inputs: + if txi.txo_ref.id in txis: + txi.txo_ref = TXORefResolvable(txis[txi.txo_ref.id]) + for txo in tx.outputs: + if txo.id in txos: + txo.is_change = txos[txo.id] == 1 + + return txs def get_balance_for_account(self, account, include_reserved=False, **constraints): if not include_reserved: @@ -323,26 +362,6 @@ class BaseDatabase(SQLiteMixin): ) for values in utxos ] - @defer.inlineCallbacks - def get_txios_for_account(self, account, **constraints): - constraints['account'] = account.public_key.address - utxos = yield self.run_query( - """ - SELECT amount, script, txid, txo.position - FROM txo JOIN pubkey_address ON pubkey_address.address=txo.address - WHERE account=:account AND txo.is_reserved=0 AND txoid NOT IN (SELECT txoid FROM txi) - """+constraints_to_sql(constraints), constraints - ) - output_class = account.ledger.transaction_class.output_class - return [ - output_class( - values[0], - output_class.script_class(values[1]), - TXRefImmutable.from_id(values[2]), - position=values[3] - ) for values in utxos - ] - def add_keys(self, account, chain, keys): sql = ( "insert into pubkey_address " diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 7302cb3d9..304bb517c 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -181,13 +181,14 @@ class BaseOutput(InputOutput): script_class = BaseOutputScript estimator_class = BaseOutputEffectiveAmountEstimator - __slots__ = 'amount', 'script' + __slots__ = 'amount', 'script', 'is_change' def __init__(self, amount: int, script: BaseOutputScript, tx_ref: TXRef = None, position: int = None) -> None: super().__init__(tx_ref, position) self.amount = amount self.script = script + self.is_change = None @property def ref(self): @@ -226,13 +227,14 @@ class BaseTransaction: input_class = BaseInput output_class = BaseOutput - def __init__(self, raw=None, version=1, locktime=0) -> None: + def __init__(self, raw=None, version=1, locktime=0, height=None) -> None: self._raw = raw self.ref = TXRefMutable(self) self.version = version # type: int self.locktime = locktime # type: int self._inputs = [] # type: List[BaseInput] self._outputs = [] # type: List[BaseOutput] + self.height = height if raw is not None: self._deserialize() @@ -416,6 +418,8 @@ class BaseTransaction: change_address = yield change_account.change.get_or_create_usable_address() change_hash160 = change_account.ledger.address_to_hash160(change_address) change_amount = change - cost_of_change + change_output = cls.output_class.pay_pubkey_hash(change_amount, change_hash160) + change_output.is_change = True tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) yield tx.sign(funding_accounts) @@ -449,13 +453,3 @@ class BaseTransaction: else: raise NotImplementedError("Don't know how to spend this output.") self._reset() - - @defer.inlineCallbacks - def get_my_addresses(self, ledger): - addresses = set() - for txo in self.outputs: - address = ledger.hash160_to_address(txo.script.values['pubkey_hash']) - record = yield ledger.db.get_address(address) - if record is not None: - addresses.add(address) - defer.returnValue(list(addresses)) From 53e0fe9a69a8f23bf1dbc7e1d87db32086f521aa Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 21 Sep 2018 22:26:07 -0400 Subject: [PATCH 118/383] pylint fix --- torba/basedatabase.py | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 2912d49b9..1730624e8 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -270,7 +270,7 @@ class BaseDatabase(SQLiteMixin): @defer.inlineCallbacks def get_transactions(self, account, offset=0, limit=100): offset, limit = min(offset, 0), max(limit, 100) - tx_records = yield self.run_query( + tx_rows = yield self.run_query( """ SELECT txid, raw, height FROM tx WHERE txid IN ( SELECT txo.txid FROM txo @@ -285,20 +285,20 @@ class BaseDatabase(SQLiteMixin): """, {'account': account.public_key.address, 'offset': offset, 'limit': limit} ) txids, txs = [], [] - for r in tx_records: - txids.append(r[0]) - txs.append(account.ledger.transaction_class(raw=r[1], height=r[2])) + for row in tx_rows: + txids.append(row[0]) + txs.append(account.ledger.transaction_class(raw=row[1], height=row[2])) - txo_records = yield self.run_query( + txo_rows = yield self.run_query( """ SELECT txoid, pubkey_address.chain FROM txo JOIN pubkey_address USING (address) WHERE txid IN ({}) """.format(', '.join(['?']*len(txids))), txids ) - txos = dict(txo_records) + txos = dict(txo_rows) - txi_records = yield self.run_query( + txi_rows = yield self.run_query( """ SELECT txoid, txo.amount, txo.script, txo.txid, txo.position FROM txi JOIN txo USING (txoid) @@ -307,12 +307,12 @@ class BaseDatabase(SQLiteMixin): ) txis = {} output_class = account.ledger.transaction_class.output_class - for r in txi_records: - txis[r[0]] = output_class( - r[1], - output_class.script_class(r[2]), - TXRefImmutable.from_id(r[3]), - position=r[4] + for row in txi_rows: + txis[row[0]] = output_class( + row[1], + output_class.script_class(row[2]), + TXRefImmutable.from_id(row[3]), + position=row[4] ) for tx in txs: From 4832526477970fc045a2389e44e27899cd77d4d2 Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Tue, 18 Sep 2018 14:32:33 -0400 Subject: [PATCH 119/383] fix aes_encrypt not prepending the iv -allow random iv to be overridden --- torba/hash.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/torba/hash.py b/torba/hash.py index eea757a6a..e6315fd2d 100644 --- a/torba/hash.py +++ b/torba/hash.py @@ -106,14 +106,17 @@ def hex_str_to_hash(x): return reversed(unhexlify(x)) -def aes_encrypt(secret, value): +def aes_encrypt(secret, value, iv=None): + if iv: + assert len(iv) == 16 + else: + iv = os.urandom(16) key = double_sha256(secret) - init_vector = os.urandom(16) - encryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).encryptor() + encryptor = Cipher(AES(key), modes.CBC(iv), default_backend()).encryptor() padder = PKCS7(AES.block_size).padder() padded_data = padder.update(value) + padder.finalize() - encrypted_data2 = encryptor.update(padded_data) + encryptor.finalize() - return base64.b64encode(encrypted_data2) + encrypted_data = encryptor.update(padded_data) + encryptor.finalize() + return base64.b64encode(iv + encrypted_data) def aes_decrypt(secret, value): From 9268b6ca134e7438c33939ddcd38343fdb08c2e9 Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Fri, 21 Sep 2018 13:10:16 -0400 Subject: [PATCH 120/383] fix double-double sha --- torba/baseaccount.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 9a90d8244..4e21127c6 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -291,16 +291,17 @@ class BaseAccount: def decrypt(self, password): assert self.encrypted, "Key is not encrypted." - secret = double_sha256(password) - self.seed = aes_decrypt(secret, self.seed) - self.private_key = from_extended_key_string(self.ledger, aes_decrypt(secret, self.private_key)) + self.seed = aes_decrypt(password, self.seed.encode()).decode() + self.private_key = from_extended_key_string( + self.ledger, aes_decrypt(password, self.private_key.encode()).decode() + ) self.encrypted = False def encrypt(self, password): assert not self.encrypted, "Key is already encrypted." - secret = double_sha256(password) - self.seed = aes_encrypt(secret, self.seed) - self.private_key = aes_encrypt(secret, self.private_key.extended_key_string()) + self.seed = aes_encrypt(password, self.seed.encode()).decode() + private_key: PrivateKey = self.private_key + self.private_key = aes_encrypt(password, private_key.extended_key_string().encode()).decode() self.encrypted = True @defer.inlineCallbacks From aa47f10602586032ee426df49b52cdc42e7e047a Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Fri, 21 Sep 2018 14:17:17 -0400 Subject: [PATCH 121/383] add encrypted_on_disk to BaseAccount -encrypt the seed and private key upon to_dict() if encrypted_on_disk is true --- torba/baseaccount.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 4e21127c6..ee3c012b5 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -205,7 +205,9 @@ class BaseAccount: self.id = public_key.address self.name = name self.seed = seed + self.password = None self.encrypted = encrypted + self.encrypted_on_disk = encrypted self.private_key = private_key self.public_key = public_key generator_name = address_generator.get('name', HierarchicalDeterministic.name) @@ -260,13 +262,17 @@ class BaseAccount: ) def to_dict(self): - private_key = self.private_key + private_key, seed = self.private_key, self.seed if not self.encrypted and self.private_key: private_key = self.private_key.extended_key_string() + if not self.encrypted and self.encrypted_on_disk: + private_key = aes_encrypt(self.password, private_key) + seed = aes_encrypt(self.password, self.seed) + return { 'ledger': self.ledger.get_id(), 'name': self.name, - 'seed': self.seed, + 'seed': seed, 'encrypted': self.encrypted, 'private_key': private_key, 'public_key': self.public_key.extended_key_string(), @@ -295,6 +301,7 @@ class BaseAccount: self.private_key = from_extended_key_string( self.ledger, aes_decrypt(password, self.private_key.encode()).decode() ) + self.password = password self.encrypted = False def encrypt(self, password): @@ -302,6 +309,7 @@ class BaseAccount: self.seed = aes_encrypt(password, self.seed.encode()).decode() private_key: PrivateKey = self.private_key self.private_key = aes_encrypt(password, private_key.extended_key_string().encode()).decode() + self.password = None self.encrypted = True @defer.inlineCallbacks From c0e0b4b74586c4f89e4536a5918b68a19bd0a08d Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Fri, 21 Sep 2018 14:49:16 -0400 Subject: [PATCH 122/383] review feedback and pylint --- torba/baseaccount.py | 39 +++++++++++++++++++++++---------------- torba/hash.py | 24 ++++++++++++------------ 2 files changed, 35 insertions(+), 28 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index ee3c012b5..eb649e411 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -1,10 +1,10 @@ import typing -from typing import Dict, Tuple, Type, Optional, Any +from typing import Dict, Tuple, Type, Optional, Any, Union from twisted.internet import defer from torba.mnemonic import Mnemonic from torba.bip32 import PrivateKey, PubKey, from_extended_key_string -from torba.hash import double_sha256, aes_encrypt, aes_decrypt +from torba.hash import aes_encrypt, aes_decrypt from torba.constants import COIN if typing.TYPE_CHECKING: @@ -199,16 +199,18 @@ class BaseAccount: def __init__(self, ledger: 'baseledger.BaseLedger', wallet: 'basewallet.Wallet', name: str, seed: str, encrypted: bool, private_key: PrivateKey, public_key: PubKey, - address_generator: dict) -> None: + address_generator: dict, password: str = None) -> None: self.ledger = ledger self.wallet = wallet self.id = public_key.address self.name = name self.seed = seed - self.password = None + self.password = password + self.encryption_init_vector = None self.encrypted = encrypted - self.encrypted_on_disk = encrypted - self.private_key = private_key + self.serialize_encrypted = encrypted + + self.private_key: Union[PrivateKey, str] = private_key self.public_key = public_key generator_name = address_generator.get('name', HierarchicalDeterministic.name) self.address_generator = self.address_generators[generator_name] @@ -265,9 +267,9 @@ class BaseAccount: private_key, seed = self.private_key, self.seed if not self.encrypted and self.private_key: private_key = self.private_key.extended_key_string() - if not self.encrypted and self.encrypted_on_disk: - private_key = aes_encrypt(self.password, private_key) - seed = aes_encrypt(self.password, self.seed) + if not self.encrypted and self.serialize_encrypted: + private_key = aes_encrypt(self.password, private_key, init_vector=self.encryption_init_vector) + seed = aes_encrypt(self.password, self.seed, init_vector=self.encryption_init_vector) return { 'ledger': self.ledger.get_id(), @@ -295,20 +297,25 @@ class BaseAccount: details['seed'] = self.seed return details - def decrypt(self, password): + def decrypt(self, password: str) -> None: assert self.encrypted, "Key is not encrypted." - self.seed = aes_decrypt(password, self.seed.encode()).decode() + self.seed = aes_decrypt(password, self.seed) + p_k: Union[PrivateKey, str] = self.private_key + assert isinstance(p_k, str) self.private_key = from_extended_key_string( - self.ledger, aes_decrypt(password, self.private_key.encode()).decode() + self.ledger, aes_decrypt(password, str(p_k)) ) self.password = password self.encrypted = False - def encrypt(self, password): + def encrypt(self, password: str) -> None: assert not self.encrypted, "Key is already encrypted." - self.seed = aes_encrypt(password, self.seed.encode()).decode() - private_key: PrivateKey = self.private_key - self.private_key = aes_encrypt(password, private_key.extended_key_string().encode()).decode() + assert isinstance(self.private_key, PrivateKey) + self.seed = aes_encrypt(password, self.seed, init_vector=self.encryption_init_vector) + p_k: PrivateKey = self.private_key # this is because the type is changing from PrivateKey <-> str + extended: str = p_k.extended_key_string() + self.private_key = aes_encrypt(password, extended, + init_vector=self.encryption_init_vector) self.password = None self.encrypted = True diff --git a/torba/hash.py b/torba/hash.py index e6315fd2d..656dec2a6 100644 --- a/torba/hash.py +++ b/torba/hash.py @@ -106,27 +106,27 @@ def hex_str_to_hash(x): return reversed(unhexlify(x)) -def aes_encrypt(secret, value, iv=None): - if iv: - assert len(iv) == 16 +def aes_encrypt(secret: str, value: str, init_vector: bytes = None) -> str: + if init_vector is not None: + assert len(init_vector) == 16 else: - iv = os.urandom(16) - key = double_sha256(secret) - encryptor = Cipher(AES(key), modes.CBC(iv), default_backend()).encryptor() + init_vector = os.urandom(16) + key = double_sha256(secret.encode()) + encryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).encryptor() padder = PKCS7(AES.block_size).padder() - padded_data = padder.update(value) + padder.finalize() + padded_data = padder.update(value.encode()) + padder.finalize() encrypted_data = encryptor.update(padded_data) + encryptor.finalize() - return base64.b64encode(iv + encrypted_data) + return base64.b64encode(init_vector + encrypted_data).decode() -def aes_decrypt(secret, value): - data = base64.b64decode(value) - key = double_sha256(secret) +def aes_decrypt(secret: str, value: str) -> str: + data = base64.b64decode(value.encode()) + key = double_sha256(secret.encode()) init_vector, data = data[:16], data[16:] decryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).decryptor() unpadder = PKCS7(AES.block_size).unpadder() result = unpadder.update(decryptor.update(data)) + unpadder.finalize() - return result + return result.decode() class Base58Error(Exception): From c45c79265768bd428cf0b8b62f407e916e35bcb2 Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Mon, 24 Sep 2018 13:57:17 -0400 Subject: [PATCH 123/383] add account encryption tests, update aes tests --- tests/unit/test_account.py | 92 ++++++++++++++++++++++++++++++++++++++ tests/unit/test_hash.py | 31 ++++++++----- 2 files changed, 113 insertions(+), 10 deletions(-) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index cbd3bc271..7bbd4afcf 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -323,3 +323,95 @@ class TestSingleKeyAccount(unittest.TestCase): self.maxDiff = None account_data['ledger'] = 'btc_mainnet' self.assertDictEqual(account_data, account.to_dict()) + + +class AccountEncryptionTests(unittest.TestCase): + password = "password" + init_vector = b'0000000000000000' + unencrypted_account = { + 'name': 'My Account', + 'seed': + "carbon smart garage balance margin twelve chest sword toast envelope bottom stomac" + "h absent", + 'encrypted': False, + 'private_key': + 'xprv9s21ZrQH143K3TsAz5efNV8K93g3Ms3FXcjaWB9fVUsMwAoE3ZT4vYymkp' + '5BxKKfnpz8J6sHDFriX1SnpvjNkzcks8XBnxjGLS83BTyfpna', + 'public_key': + 'xpub661MyMwAqRbcFwwe67Bfjd53h5WXmKm6tqfBJZZH3pQLoy8Nb6mKUMJFc7' + 'UbpVNzmwFPN2evn3YHnig1pkKVYcvCV8owTd2yAcEkJfCX53g', + 'address_generator': {'name': 'single-address'} + } + encrypted_account = { + 'name': 'My Account', + 'seed': + "MDAwMDAwMDAwMDAwMDAwMJ4e4W4pE6nQtPiD6MujNIQ7aFPhUBl63GwPziAgGN" + "MBTMoaSjZfyyvw7ELMCqAYTWJ61aV7K4lmd2hR11g9dpdnnpCb9f9j3zLZHRv7+" + "bIkZ//trah9AIkmrc/ZvNkC0Q==", + 'encrypted': True, + 'private_key': + 'MDAwMDAwMDAwMDAwMDAwMLkWikOLScA/ZxlFSGU7dl//7Q/1gS9h7vqQyrd8DX+' + 'jwcp7SwlJ1mkMwuraUaWLq9/LxiaGmqJBUZ50p77YVZbDycaCN1unBr1/i1q6RP' + 'Ob2MNCaG8nyjxZhQai+V/2JmJ+UnFMp3nHany7F8/Hr0g=', + 'public_key': + 'xpub661MyMwAqRbcFwwe67Bfjd53h5WXmKm6tqfBJZZH3pQLoy8Nb6mKUMJFc7' + 'UbpVNzmwFPN2evn3YHnig1pkKVYcvCV8owTd2yAcEkJfCX53g', + 'address_generator': {'name': 'single-address'} + } + + def setUp(self): + self.ledger = ledger_class({ + 'db': ledger_class.database_class(':memory:'), + 'headers': ledger_class.headers_class(':memory:'), + }) + + def test_encrypt_wallet(self): + account = self.ledger.account_class.from_dict(self.ledger, Wallet(), self.unencrypted_account) + account.encryption_init_vector = self.init_vector + + self.assertFalse(account.serialize_encrypted) + self.assertFalse(account.encrypted) + account.encrypt(self.password) + self.assertFalse(account.serialize_encrypted) + self.assertTrue(account.encrypted) + self.assertEqual(account.seed, self.encrypted_account['seed']) + self.assertEqual(account.private_key, self.encrypted_account['private_key']) + + self.assertEqual(account.to_dict()['seed'], self.encrypted_account['seed']) + self.assertEqual(account.to_dict()['private_key'], self.encrypted_account['private_key']) + + account.serialize_encrypted = True + account.decrypt(self.password) + + self.assertEqual(account.seed, self.unencrypted_account['seed']) + self.assertEqual(account.private_key.extended_key_string(), self.unencrypted_account['private_key']) + + self.assertEqual(account.to_dict()['seed'], self.encrypted_account['seed']) + self.assertEqual(account.to_dict()['private_key'], self.encrypted_account['private_key']) + + account.encryption_init_vector = None + self.assertNotEqual(account.to_dict()['seed'], self.encrypted_account['seed']) + self.assertNotEqual(account.to_dict()['private_key'], self.encrypted_account['private_key']) + + self.assertFalse(account.encrypted) + self.assertTrue(account.serialize_encrypted) + + def test_decrypt_wallet(self): + account = self.ledger.account_class.from_dict(self.ledger, Wallet(), self.encrypted_account) + account.encryption_init_vector = self.init_vector + + self.assertTrue(account.encrypted) + self.assertTrue(account.serialize_encrypted) + account.decrypt(self.password) + self.assertFalse(account.encrypted) + self.assertTrue(account.serialize_encrypted) + + self.assertEqual(account.seed, self.unencrypted_account['seed']) + self.assertEqual(account.private_key.extended_key_string(), self.unencrypted_account['private_key']) + + self.assertEqual(account.to_dict()['seed'], self.encrypted_account['seed']) + self.assertEqual(account.to_dict()['private_key'], self.encrypted_account['private_key']) + + account.serialize_encrypted = False + self.assertEqual(account.to_dict()['seed'], self.unencrypted_account['seed']) + self.assertEqual(account.to_dict()['private_key'], self.unencrypted_account['private_key']) diff --git a/tests/unit/test_hash.py b/tests/unit/test_hash.py index 8c7f09c53..4f4d31526 100644 --- a/tests/unit/test_hash.py +++ b/tests/unit/test_hash.py @@ -8,18 +8,29 @@ except ImportError: class TestAESEncryptDecrypt(TestCase): + message = 'The Times 03/Jan/2009 Chancellor on brink of second bailout for banks' + expected = 'ZmZmZmZmZmZmZmZmZmZmZjlrKptoKD+MFwDxcg3XtCD9qz8UWhEhq/TVJT5+Mtp2a8sE' \ + 'CaO6WQj7fYsWGu2Hvbc0qYqxdN0HeTsiO+cZRo3eJISgr3F+rXFYi5oSBlD2' + password = 'bubblegum' + + @mock.patch('os.urandom', side_effect=lambda i: b'd'*i) + def test_encrypt_iv_f(self, _): + self.assertEqual( + aes_encrypt(self.password, self.message), + 'ZGRkZGRkZGRkZGRkZGRkZKBP/4pR+47hLHbHyvDJm9aRKDuoBdTG8SrFvHqfagK6Co1VrHUOd' + 'oF+6PGSxru3+VR63ybkXLNM75s/qVw+dnKVAkI8OfoVnJvGRSc49e38' + ) @mock.patch('os.urandom', side_effect=lambda i: b'f'*i) - def test_encrypt(self, _): - self.assertEqual(aes_encrypt( - b'bubblegum', b'The Times 03/Jan/2009 Chancellor on brink of second bailout for banks'), - b'OWsqm2goP4wXAPFyDde0IP2rPxRaESGr9NUlPn4y2nZrywQJo7pZCPt9ixYa7Ye9tzSpirF03Qd5OyI75xlGjd' - b'4khKCvcX6tcViLmhIGUPY=' + def test_encrypt_iv_d(self, _): + self.assertEqual( + aes_encrypt(self.password, self.message), + 'ZmZmZmZmZmZmZmZmZmZmZjlrKptoKD+MFwDxcg3XtCD9qz8UWhEhq/TVJT5+Mtp2a8sE' + 'CaO6WQj7fYsWGu2Hvbc0qYqxdN0HeTsiO+cZRo3eJISgr3F+rXFYi5oSBlD2' ) - def test_decrypt(self): - self.assertEqual(aes_decrypt( - b'bubblegum', b'WeW99mQgRExAEzPjJOAC/MdTJaHgz3hT+kazFbvVQqF/KFva48ulVMOewU7JWD0ufWJIxtAIQ' - b'bGtlbvbq5w74bsCCJLrtNTHBhenkms8XccJXTr/UF/ZYTF1Prz8b0AQ'), - b'The Times 03/Jan/2009 Chancellor on brink of second bailout for banks' + def test_encrypt_decrypt(self): + self.assertEqual( + aes_decrypt('bubblegum', aes_encrypt('bubblegum', self.message)), + self.message ) From 58d2c04b9ffadad1fcd0b0707e8a1d559c89f5df Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 24 Sep 2018 23:12:46 -0400 Subject: [PATCH 124/383] simplified and cleaned up typing for encryp / decrypt --- tests/unit/test_account.py | 4 +++- torba/baseaccount.py | 42 +++++++++++++++++++------------------- 2 files changed, 24 insertions(+), 22 deletions(-) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index 7bbd4afcf..f23f29c0d 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -371,11 +371,13 @@ class AccountEncryptionTests(unittest.TestCase): self.assertFalse(account.serialize_encrypted) self.assertFalse(account.encrypted) + self.assertIsNotNone(account.private_key) account.encrypt(self.password) self.assertFalse(account.serialize_encrypted) self.assertTrue(account.encrypted) self.assertEqual(account.seed, self.encrypted_account['seed']) - self.assertEqual(account.private_key, self.encrypted_account['private_key']) + self.assertEqual(account.private_key_string, self.encrypted_account['private_key']) + self.assertIsNone(account.private_key) self.assertEqual(account.to_dict()['seed'], self.encrypted_account['seed']) self.assertEqual(account.to_dict()['private_key'], self.encrypted_account['private_key']) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index eb649e411..0fa266cc1 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -198,19 +198,20 @@ class BaseAccount: } def __init__(self, ledger: 'baseledger.BaseLedger', wallet: 'basewallet.Wallet', name: str, - seed: str, encrypted: bool, private_key: PrivateKey, public_key: PubKey, - address_generator: dict, password: str = None) -> None: + seed: str, private_key_string: str, encrypted: bool, + private_key: Optional[PrivateKey], public_key: PubKey, + address_generator: dict) -> None: self.ledger = ledger self.wallet = wallet self.id = public_key.address self.name = name self.seed = seed - self.password = password + self.private_key_string = private_key_string + self.password: Optional[str] = None self.encryption_init_vector = None self.encrypted = encrypted self.serialize_encrypted = encrypted - - self.private_key: Union[PrivateKey, str] = private_key + self.private_key = private_key self.public_key = public_key generator_name = address_generator.get('name', HierarchicalDeterministic.name) self.address_generator = self.address_generators[generator_name] @@ -237,7 +238,8 @@ class BaseAccount: @classmethod def from_dict(cls, ledger: 'baseledger.BaseLedger', wallet: 'basewallet.Wallet', d: dict): seed = d.get('seed', '') - private_key = d.get('private_key', '') + private_key_string = d.get('private_key', '') + private_key = None public_key = None encrypted = d.get('encrypted', False) if not encrypted: @@ -245,7 +247,7 @@ class BaseAccount: private_key = cls.get_private_key_from_seed(ledger, seed, '') public_key = private_key.public_key elif private_key: - private_key = from_extended_key_string(ledger, private_key) + private_key = from_extended_key_string(ledger, private_key_string) public_key = private_key.public_key if public_key is None: public_key = from_extended_key_string(ledger, d['public_key']) @@ -257,6 +259,7 @@ class BaseAccount: wallet=wallet, name=name, seed=seed, + private_key_string=private_key_string, encrypted=encrypted, private_key=private_key, public_key=public_key, @@ -264,19 +267,18 @@ class BaseAccount: ) def to_dict(self): - private_key, seed = self.private_key, self.seed + private_key_string, seed = self.private_key_string, self.seed if not self.encrypted and self.private_key: - private_key = self.private_key.extended_key_string() + private_key_string = self.private_key.extended_key_string() if not self.encrypted and self.serialize_encrypted: - private_key = aes_encrypt(self.password, private_key, init_vector=self.encryption_init_vector) - seed = aes_encrypt(self.password, self.seed, init_vector=self.encryption_init_vector) - + private_key_string = aes_encrypt(self.password, private_key_string, self.encryption_init_vector) + seed = aes_encrypt(self.password, self.seed, self.encryption_init_vector) return { 'ledger': self.ledger.get_id(), 'name': self.name, 'seed': seed, 'encrypted': self.encrypted, - 'private_key': private_key, + 'private_key': private_key_string, 'public_key': self.public_key.extended_key_string(), 'address_generator': self.address_generator.to_dict(self.receiving, self.change) } @@ -300,10 +302,8 @@ class BaseAccount: def decrypt(self, password: str) -> None: assert self.encrypted, "Key is not encrypted." self.seed = aes_decrypt(password, self.seed) - p_k: Union[PrivateKey, str] = self.private_key - assert isinstance(p_k, str) self.private_key = from_extended_key_string( - self.ledger, aes_decrypt(password, str(p_k)) + self.ledger, aes_decrypt(password, self.private_key_string) ) self.password = password self.encrypted = False @@ -311,11 +311,11 @@ class BaseAccount: def encrypt(self, password: str) -> None: assert not self.encrypted, "Key is already encrypted." assert isinstance(self.private_key, PrivateKey) - self.seed = aes_encrypt(password, self.seed, init_vector=self.encryption_init_vector) - p_k: PrivateKey = self.private_key # this is because the type is changing from PrivateKey <-> str - extended: str = p_k.extended_key_string() - self.private_key = aes_encrypt(password, extended, - init_vector=self.encryption_init_vector) + self.seed = aes_encrypt(password, self.seed, self.encryption_init_vector) + self.private_key_string = aes_encrypt( + password, self.private_key.extended_key_string(), self.encryption_init_vector + ) + self.private_key = None self.password = None self.encrypted = True From 5977f42a7eebc1ebcd45bcbd3e8b7365f0a18fec Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 24 Sep 2018 23:13:43 -0400 Subject: [PATCH 125/383] remove unused import --- torba/baseaccount.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 0fa266cc1..88b965416 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -1,5 +1,5 @@ import typing -from typing import Dict, Tuple, Type, Optional, Any, Union +from typing import Dict, Tuple, Type, Optional, Any from twisted.internet import defer from torba.mnemonic import Mnemonic From c29b4c476d814358fa284527f8d41af4ed7fa43d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 25 Sep 2018 18:02:50 -0400 Subject: [PATCH 126/383] + tx.position, + tx.net_account_balance, + txo.is_my_account --- tests/unit/test_transaction.py | 46 ++++++++++++++++++++- torba/basedatabase.py | 74 ++++++++++++++++++++++------------ torba/baseledger.py | 21 +++++----- torba/basetransaction.py | 61 +++++++++++++++++++++------- 4 files changed, 151 insertions(+), 51 deletions(-) diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index 2ffb5b022..d007bc12c 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -54,6 +54,50 @@ class TestSizeAndFeeEstimation(unittest.TestCase): self.assertEqual(tx.get_base_fee(self.ledger), FEE_PER_BYTE * tx.base_size) +class TestAccountBalanceImpactFromTransaction(unittest.TestCase): + + def test_is_my_account_not_set(self): + tx = get_transaction() + with self.assertRaisesRegex(ValueError, "Cannot access net_account_balance"): + _ = tx.net_account_balance + tx.inputs[0].is_my_account = True + with self.assertRaisesRegex(ValueError, "Cannot access net_account_balance"): + _ = tx.net_account_balance + tx.outputs[0].is_my_account = True + # all inputs/outputs are set now so it should work + _ = tx.net_account_balance + + def test_paying_from_my_account_to_other_account(self): + tx = ledger_class.transaction_class() \ + .add_inputs([get_input(300*CENT)]) \ + .add_outputs([get_output(190*CENT, NULL_HASH), + get_output(100*CENT, NULL_HASH)]) + tx.inputs[0].is_my_account = True + tx.outputs[0].is_my_account = False + tx.outputs[1].is_my_account = True + self.assertEqual(tx.net_account_balance, -200*CENT) + + def test_paying_from_other_account_to_my_account(self): + tx = ledger_class.transaction_class() \ + .add_inputs([get_input(300*CENT)]) \ + .add_outputs([get_output(190*CENT, NULL_HASH), + get_output(100*CENT, NULL_HASH)]) + tx.inputs[0].is_my_account = False + tx.outputs[0].is_my_account = True + tx.outputs[1].is_my_account = False + self.assertEqual(tx.net_account_balance, 190*CENT) + + def test_paying_from_my_account_to_my_account(self): + tx = ledger_class.transaction_class() \ + .add_inputs([get_input(300*CENT)]) \ + .add_outputs([get_output(190*CENT, NULL_HASH), + get_output(100*CENT, NULL_HASH)]) + tx.inputs[0].is_my_account = True + tx.outputs[0].is_my_account = True + tx.outputs[1].is_my_account = True + self.assertEqual(tx.net_account_balance, -10*CENT) # lost to fee + + class TestTransactionSerialization(unittest.TestCase): def test_genesis_transaction(self): @@ -217,7 +261,7 @@ class TransactionIOBalancing(unittest.TestCase): save_tx = 'insert' for utxo in utxos: yield self.ledger.db.save_transaction_io( - save_tx, self.funding_tx, 1, True, + save_tx, self.funding_tx, True, self.ledger.hash160_to_address(utxo.script.values['pubkey_hash']), utxo.script.values['pubkey_hash'], '' ) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 1730624e8..35cb4b087 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -143,6 +143,7 @@ class BaseDatabase(SQLiteMixin): txid text primary key, raw blob not null, height integer not null, + position integer not null, is_verified boolean not null default 0 ); """ @@ -185,19 +186,20 @@ class BaseDatabase(SQLiteMixin): 'script': sqlite3.Binary(txo.script.source) } - def save_transaction_io(self, save_tx, tx, height, is_verified, address, txhash, history): + def save_transaction_io(self, save_tx, tx, is_verified, address, txhash, history): def _steps(t): if save_tx == 'insert': self.execute(t, *self._insert_sql('tx', { 'txid': tx.id, 'raw': sqlite3.Binary(tx.raw), - 'height': height, + 'height': tx.height, + 'position': tx.position, 'is_verified': is_verified })) elif save_tx == 'update': self.execute(t, *self._update_sql("tx", { - 'height': height, 'is_verified': is_verified + 'height': tx.height, 'position': tx.position, 'is_verified': is_verified }, 'txid = ?', (tx.id,))) existing_txos = [r[0] for r in self.execute( @@ -260,19 +262,19 @@ class BaseDatabase(SQLiteMixin): @defer.inlineCallbacks def get_transaction(self, txid): result = yield self.run_query( - "SELECT raw, height, is_verified FROM tx WHERE txid = ?", (txid,) + "SELECT raw, height, position, is_verified FROM tx WHERE txid = ?", (txid,) ) if result: return result[0] else: - return None, None, False + return None, None, None, False @defer.inlineCallbacks def get_transactions(self, account, offset=0, limit=100): - offset, limit = min(offset, 0), max(limit, 100) + account_id = account.public_key.address tx_rows = yield self.run_query( """ - SELECT txid, raw, height FROM tx WHERE txid IN ( + SELECT txid, raw, height, position FROM tx WHERE txid IN ( SELECT txo.txid FROM txo JOIN pubkey_address USING (address) WHERE pubkey_address.account = :account @@ -281,47 +283,67 @@ class BaseDatabase(SQLiteMixin): JOIN txo USING (txoid) JOIN pubkey_address USING (address) WHERE pubkey_address.account = :account - ) ORDER BY height DESC LIMIT :offset, :limit - """, {'account': account.public_key.address, 'offset': offset, 'limit': limit} + ) ORDER BY height DESC, position DESC LIMIT :offset, :limit + """, { + 'account': account_id, + 'offset': min(offset, 0), + 'limit': max(limit, 100) + } ) txids, txs = [], [] for row in tx_rows: txids.append(row[0]) - txs.append(account.ledger.transaction_class(raw=row[1], height=row[2])) + txs.append(account.ledger.transaction_class( + raw=row[1], height=row[2], position=row[3] + )) txo_rows = yield self.run_query( """ - SELECT txoid, pubkey_address.chain + SELECT txoid, chain, account FROM txo JOIN pubkey_address USING (address) WHERE txid IN ({}) """.format(', '.join(['?']*len(txids))), txids ) - txos = dict(txo_rows) + txos = {} + for row in txo_rows: + txos[row[0]] = { + 'is_change': row[1] == 1, + 'is_my_account': row[2] == account_id + } - txi_rows = yield self.run_query( + referenced_txo_rows = yield self.run_query( """ - SELECT txoid, txo.amount, txo.script, txo.txid, txo.position - FROM txi JOIN txo USING (txoid) + SELECT txoid, txo.amount, txo.script, txo.txid, txo.position, chain, account + FROM txi + JOIN txo USING (txoid) + JOIN pubkey_address USING (address) WHERE txi.txid IN ({}) """.format(', '.join(['?']*len(txids))), txids ) - txis = {} + referenced_txos = {} output_class = account.ledger.transaction_class.output_class - for row in txi_rows: - txis[row[0]] = output_class( - row[1], - output_class.script_class(row[2]), - TXRefImmutable.from_id(row[3]), - position=row[4] + for row in referenced_txo_rows: + referenced_txos[row[0]] = output_class( + amount=row[1], + script=output_class.script_class(row[2]), + tx_ref=TXRefImmutable.from_id(row[3]), + position=row[4], + is_change=row[5] == 1, + is_my_account=row[6] == account_id ) for tx in txs: for txi in tx.inputs: - if txi.txo_ref.id in txis: - txi.txo_ref = TXORefResolvable(txis[txi.txo_ref.id]) + if txi.txo_ref.id in referenced_txos: + txi.txo_ref = TXORefResolvable(referenced_txos[txi.txo_ref.id]) for txo in tx.outputs: - if txo.id in txos: - txo.is_change = txos[txo.id] == 1 + txo_meta = txos.get(txo.id) + if txo_meta is not None: + txo.is_change = txo_meta['is_change'] + txo.is_my_account = txo_meta['is_my_account'] + else: + txo.is_change = False + txo.is_my_account = False return txs diff --git a/torba/baseledger.py b/torba/baseledger.py index 9cb1c7337..1e836a1d8 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -40,7 +40,7 @@ class LedgerRegistry(type): return mcs.ledgers[ledger_id] -class TransactionEvent(namedtuple('TransactionEvent', ('address', 'tx', 'height', 'is_verified'))): +class TransactionEvent(namedtuple('TransactionEvent', ('address', 'tx', 'is_verified'))): pass @@ -87,7 +87,7 @@ class BaseLedger(metaclass=LedgerRegistry): self.on_transaction.listen( lambda e: log.info( '(%s) on_transaction: address=%s, height=%s, is_verified=%s, tx.id=%s', - self.get_id(), e.address, e.height, e.is_verified, e.tx.id + self.get_id(), e.address, e.tx.height, e.is_verified, e.tx.id ) ) @@ -207,12 +207,13 @@ class BaseLedger(metaclass=LedgerRegistry): return hexlify(working_branch[::-1]) @defer.inlineCallbacks - def is_valid_transaction(self, tx, height): + def validate_transaction_and_set_position(self, tx, height): if not height <= len(self.headers): return False merkle = yield self.network.get_merkle(tx.id, height) merkle_root = self.get_root_of_merkle_tree(merkle['merkle'], merkle['pos'], tx.hash) header = self.headers[height] + tx.position = merkle['pos'] return merkle_root == header['merkle_root'] @defer.inlineCallbacks @@ -365,23 +366,23 @@ class BaseLedger(metaclass=LedgerRegistry): try: # see if we have a local copy of transaction, otherwise fetch it from server - raw, _, is_verified = yield self.db.get_transaction(hex_id) + raw, _, position, is_verified = yield self.db.get_transaction(hex_id) save_tx = None if raw is None: _raw = yield self.network.get_transaction(hex_id) - tx = self.transaction_class(unhexlify(_raw)) + tx = self.transaction_class(unhexlify(_raw), height=remote_height) save_tx = 'insert' else: - tx = self.transaction_class(raw) + tx = self.transaction_class(raw, height=remote_height) - if remote_height > 0 and not is_verified: - is_verified = yield self.is_valid_transaction(tx, remote_height) + if remote_height > 0 and (not is_verified or position is None): + is_verified = yield self.validate_transaction_and_set_position(tx, remote_height) is_verified = 1 if is_verified else 0 if save_tx is None: save_tx = 'update' yield self.db.save_transaction_io( - save_tx, tx, remote_height, is_verified, address, self.address_to_hash160(address), + save_tx, tx, is_verified, address, self.address_to_hash160(address), ''.join('{}:{}:'.format(tx_id, tx_height) for tx_id, tx_height in synced_history) ) @@ -390,7 +391,7 @@ class BaseLedger(metaclass=LedgerRegistry): self.get_id(), hex_id, address, remote_height, is_verified ) - self._on_transaction_controller.add(TransactionEvent(address, tx, remote_height, is_verified)) + self._on_transaction_controller.add(TransactionEvent(address, tx, is_verified)) except Exception: log.exception('Failed to synchronize transaction:') diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 304bb517c..20935ba3c 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -137,6 +137,13 @@ class BaseInput(InputOutput): raise ValueError('Cannot resolve output to get amount.') return self.txo_ref.txo.amount + @property + def is_my_account(self) -> int: + """ True if the output this input spends is yours. """ + if self.txo_ref.txo is None: + raise ValueError('Cannot resolve output to determine ownership.') + return self.txo_ref.txo.is_my_account + @classmethod def deserialize_from(cls, stream): tx_ref = TXRefImmutable.from_hash(stream.read(32)) @@ -181,14 +188,17 @@ class BaseOutput(InputOutput): script_class = BaseOutputScript estimator_class = BaseOutputEffectiveAmountEstimator - __slots__ = 'amount', 'script', 'is_change' + __slots__ = 'amount', 'script', 'is_change', 'is_my_account' def __init__(self, amount: int, script: BaseOutputScript, - tx_ref: TXRef = None, position: int = None) -> None: + tx_ref: TXRef = None, position: int = None, + is_change: Optional[bool] = None, is_my_account: Optional[bool] = None + ) -> None: super().__init__(tx_ref, position) self.amount = amount self.script = script - self.is_change = None + self.is_change = is_change + self.is_my_account = is_my_account @property def ref(self): @@ -227,14 +237,16 @@ class BaseTransaction: input_class = BaseInput output_class = BaseOutput - def __init__(self, raw=None, version=1, locktime=0, height=None) -> None: + def __init__(self, raw=None, version: int=1, locktime: int=0, + height: int=-1, position: int=-1) -> None: self._raw = raw self.ref = TXRefMutable(self) - self.version = version # type: int - self.locktime = locktime # type: int - self._inputs = [] # type: List[BaseInput] - self._outputs = [] # type: List[BaseOutput] + self.version = version + self.locktime = locktime + self._inputs: List[BaseInput] = [] + self._outputs: List[BaseOutput] = [] self.height = height + self.position = position if raw is not None: self._deserialize() @@ -257,11 +269,11 @@ class BaseTransaction: self.ref.reset() @property - def inputs(self): # type: () -> ReadOnlyList[BaseInput] + def inputs(self) -> ReadOnlyList[BaseInput]: return ReadOnlyList(self._inputs) @property - def outputs(self): # type: () -> ReadOnlyList[BaseOutput] + def outputs(self) -> ReadOnlyList[BaseOutput]: return ReadOnlyList(self._outputs) def _add(self, new_ios: Iterable[InputOutput], existing_ios: List) -> 'BaseTransaction': @@ -301,18 +313,39 @@ class BaseTransaction: return sum(o.amount for o in self.outputs) @property - def fee(self): + def net_account_balance(self) -> int: + balance = 0 + for txi in self.inputs: + if txi.is_my_account is None: + raise ValueError( + "Cannot access net_account_balance if inputs/outputs do not " + "have is_my_account set properly." + ) + elif txi.is_my_account: + balance -= txi.amount + for txo in self.outputs: + if txo.is_my_account is None: + raise ValueError( + "Cannot access net_account_balance if inputs/outputs do not " + "have is_my_account set properly." + ) + elif txo.is_my_account: + balance += txo.amount + return balance + + @property + def fee(self) -> int: return self.input_sum - self.output_sum - def get_base_fee(self, ledger): + def get_base_fee(self, ledger) -> int: """ Fee for base tx excluding inputs and outputs. """ return self.base_size * ledger.fee_per_byte - def get_effective_input_sum(self, ledger): + def get_effective_input_sum(self, ledger) -> int: """ Sum of input values *minus* the cost involved to spend them. """ return sum(txi.amount - txi.get_fee(ledger) for txi in self._inputs) - def get_total_output_sum(self, ledger): + def get_total_output_sum(self, ledger) -> int: """ Sum of output values *plus* the cost involved to spend them. """ return sum(txo.amount + txo.get_fee(ledger) for txo in self._outputs) From 0d22b8c23ccce635b52c73d2c0a0f9b46f2fb44a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 25 Sep 2018 18:14:28 -0400 Subject: [PATCH 127/383] typing and pylint fixes --- torba/basetransaction.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 20935ba3c..9c653b825 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -138,7 +138,7 @@ class BaseInput(InputOutput): return self.txo_ref.txo.amount @property - def is_my_account(self) -> int: + def is_my_account(self) -> Optional[bool]: """ True if the output this input spends is yours. """ if self.txo_ref.txo is None: raise ValueError('Cannot resolve output to determine ownership.') @@ -237,8 +237,8 @@ class BaseTransaction: input_class = BaseInput output_class = BaseOutput - def __init__(self, raw=None, version: int=1, locktime: int=0, - height: int=-1, position: int=-1) -> None: + def __init__(self, raw=None, version: int = 1, locktime: int = 0, + height: int = -1, position: int = -1) -> None: self._raw = raw self.ref = TXRefMutable(self) self.version = version From 841d49554cd87b0efb63239c8e3fbcf5223132d9 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 25 Sep 2018 18:21:42 -0400 Subject: [PATCH 128/383] fix unit tests --- tests/unit/test_transaction.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index d007bc12c..640f82346 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -60,7 +60,7 @@ class TestAccountBalanceImpactFromTransaction(unittest.TestCase): tx = get_transaction() with self.assertRaisesRegex(ValueError, "Cannot access net_account_balance"): _ = tx.net_account_balance - tx.inputs[0].is_my_account = True + tx.inputs[0].txo_ref.txo.is_my_account = True with self.assertRaisesRegex(ValueError, "Cannot access net_account_balance"): _ = tx.net_account_balance tx.outputs[0].is_my_account = True @@ -72,7 +72,7 @@ class TestAccountBalanceImpactFromTransaction(unittest.TestCase): .add_inputs([get_input(300*CENT)]) \ .add_outputs([get_output(190*CENT, NULL_HASH), get_output(100*CENT, NULL_HASH)]) - tx.inputs[0].is_my_account = True + tx.inputs[0].txo_ref.txo.is_my_account = True tx.outputs[0].is_my_account = False tx.outputs[1].is_my_account = True self.assertEqual(tx.net_account_balance, -200*CENT) @@ -82,7 +82,7 @@ class TestAccountBalanceImpactFromTransaction(unittest.TestCase): .add_inputs([get_input(300*CENT)]) \ .add_outputs([get_output(190*CENT, NULL_HASH), get_output(100*CENT, NULL_HASH)]) - tx.inputs[0].is_my_account = False + tx.inputs[0].txo_ref.txo.is_my_account = False tx.outputs[0].is_my_account = True tx.outputs[1].is_my_account = False self.assertEqual(tx.net_account_balance, 190*CENT) @@ -92,7 +92,7 @@ class TestAccountBalanceImpactFromTransaction(unittest.TestCase): .add_inputs([get_input(300*CENT)]) \ .add_outputs([get_output(190*CENT, NULL_HASH), get_output(100*CENT, NULL_HASH)]) - tx.inputs[0].is_my_account = True + tx.inputs[0].txo_ref.txo.is_my_account = True tx.outputs[0].is_my_account = True tx.outputs[1].is_my_account = True self.assertEqual(tx.net_account_balance, -10*CENT) # lost to fee From a879c822c20b63e46ea8ba9ae447a17305b5c871 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 25 Sep 2018 22:39:20 -0400 Subject: [PATCH 129/383] check if txi.txo_ref.txo is not None before using it --- torba/basedatabase.py | 6 +++--- torba/basetransaction.py | 4 +++- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 35cb4b087..3cc0afc04 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -6,7 +6,7 @@ from twisted.internet import defer from twisted.enterprise import adbapi from torba.hash import TXRefImmutable -from torba.basetransaction import TXORefResolvable +from torba.basetransaction import BaseTransaction, TXORefResolvable log = logging.getLogger(__name__) @@ -186,7 +186,7 @@ class BaseDatabase(SQLiteMixin): 'script': sqlite3.Binary(txo.script.source) } - def save_transaction_io(self, save_tx, tx, is_verified, address, txhash, history): + def save_transaction_io(self, save_tx, tx: BaseTransaction, is_verified, address, txhash, history): def _steps(t): if save_tx == 'insert': @@ -270,7 +270,7 @@ class BaseDatabase(SQLiteMixin): return None, None, None, False @defer.inlineCallbacks - def get_transactions(self, account, offset=0, limit=100): + def get_transactions(self, account, offset=0, limit=100) -> List[BaseTransaction]: account_id = account.public_key.address tx_rows = yield self.run_query( """ diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 9c653b825..d19a855b0 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -306,7 +306,7 @@ class BaseTransaction: @property def input_sum(self): - return sum(i.amount for i in self.inputs) + return sum(i.amount for i in self.inputs if i.txo_ref.txo is not None) @property def output_sum(self): @@ -316,6 +316,8 @@ class BaseTransaction: def net_account_balance(self) -> int: balance = 0 for txi in self.inputs: + if txi.txo_ref.txo is None: + continue if txi.is_my_account is None: raise ValueError( "Cannot access net_account_balance if inputs/outputs do not " From 5c5b0ace53cbd95e14296935d6b00e43432b49d8 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 25 Sep 2018 22:46:22 -0400 Subject: [PATCH 130/383] mypy related fix --- torba/baseaccount.py | 5 +++-- torba/basedatabase.py | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 88b965416..a9edba945 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -1,5 +1,5 @@ import typing -from typing import Dict, Tuple, Type, Optional, Any +from typing import List, Dict, Tuple, Type, Optional, Any from twisted.internet import defer from torba.mnemonic import Mnemonic @@ -10,6 +10,7 @@ from torba.constants import COIN if typing.TYPE_CHECKING: from torba import baseledger from torba import wallet as basewallet + from torba import basetransaction class AddressManager: @@ -358,7 +359,7 @@ class BaseAccount: def get_unspent_outputs(self, **constraints): return self.ledger.db.get_utxos_for_account(self, **constraints) - def get_transactions(self): + def get_transactions(self) -> 'List[basetransaction.BaseTransaction]': return self.ledger.db.get_transactions(self) @defer.inlineCallbacks diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 3cc0afc04..898c7e62f 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -270,7 +270,7 @@ class BaseDatabase(SQLiteMixin): return None, None, None, False @defer.inlineCallbacks - def get_transactions(self, account, offset=0, limit=100) -> List[BaseTransaction]: + def get_transactions(self, account, offset=0, limit=100): account_id = account.public_key.address tx_rows = yield self.run_query( """ From cdbb34e976be522118c20551ea5c7f4dcdb002ae Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 25 Sep 2018 22:54:18 -0400 Subject: [PATCH 131/383] pylint fix --- torba/baseaccount.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index a9edba945..a53712465 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -359,7 +359,7 @@ class BaseAccount: def get_unspent_outputs(self, **constraints): return self.ledger.db.get_utxos_for_account(self, **constraints) - def get_transactions(self) -> 'List[basetransaction.BaseTransaction]': + def get_transactions(self) -> List['basetransaction.BaseTransaction']: return self.ledger.db.get_transactions(self) @defer.inlineCallbacks From b0bc06ae000ff620f2b7a0c1b24f8aeec6803508 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Tue, 25 Sep 2018 22:06:22 -0300 Subject: [PATCH 132/383] improve reorgs --- .../test_blockchain_reorganization.py | 27 ++++++++++++++++--- torba/baseheader.py | 2 +- tox.ini | 3 ++- 3 files changed, 26 insertions(+), 6 deletions(-) diff --git a/tests/integration/test_blockchain_reorganization.py b/tests/integration/test_blockchain_reorganization.py index f61d31f7c..0d6cd4068 100644 --- a/tests/integration/test_blockchain_reorganization.py +++ b/tests/integration/test_blockchain_reorganization.py @@ -1,17 +1,36 @@ from orchstr8.testcase import IntegrationTestCase +from asyncio import sleep class BlockchainReorganizationTests(IntegrationTestCase): VERBOSE = True - async def test(self): + async def test_reorg(self): self.assertEqual(self.ledger.headers.height, 200) await self.blockchain.generate(1) await self.on_header(201) self.assertEqual(self.ledger.headers.height, 201) + height = 201 - await self.blockchain.invalidateblock(self.ledger.headers.hash(201).decode()) - await self.blockchain.generate(2) - await self.on_header(203) + #simple fork (rewind+advance to immediate best) + height = await self._simulate_reorg(height, 1, 1, 2) + height = await self._simulate_reorg(height, 2, 1, 10) + height = await self._simulate_reorg(height, 4, 1, 3) + #lagged fork (rewind+batch catch up with immediate best) + height = await self._simulate_reorg(height, 4, 2, 3) + await self._simulate_reorg(height, 4, 4, 3) + + async def _simulate_reorg(self, height, rewind, winners, progress): + for i in range(rewind): + await self.blockchain.invalidateblock(self.ledger.headers.hash(height - i).decode()) + await self.blockchain.generate(rewind + winners) + height = height + winners + await self.on_header(height) + for i in range(progress): + await self.blockchain.generate(1) + height += 1 + await self.on_header(height) + self.assertEquals(height, self.ledger.headers.height) + return height diff --git a/torba/baseheader.py b/torba/baseheader.py index a4b451919..9fca794f0 100644 --- a/torba/baseheader.py +++ b/torba/baseheader.py @@ -107,7 +107,7 @@ class BaseHeaders: yield threads.deferToThread(self.validate_chunk, height, chunk) except InvalidHeader as e: bail = True - chunk = chunk[:(height-e.height)*self.header_size] + chunk = chunk[:(height-e.height+1)*self.header_size] written = 0 if chunk: self.io.seek(height * self.header_size, os.SEEK_SET) diff --git a/tox.ini b/tox.ini index 8eb3120ed..e17f52069 100644 --- a/tox.ini +++ b/tox.ini @@ -20,4 +20,5 @@ commands = unit: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial unit integration: orchstr8 download integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_transactions - integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_blockchain_reorganization + # Too slow on Travis + # integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_blockchain_reorganization From 29c0e3f15f60d36d3d687626a60b93450e52a7df Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 25 Sep 2018 23:28:06 -0400 Subject: [PATCH 133/383] fix for get_transaction --- torba/baseledger.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index 1e836a1d8..8a7ca4de8 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -134,7 +134,7 @@ class BaseLedger(metaclass=LedgerRegistry): @defer.inlineCallbacks def get_transaction(self, txhash): - raw, _, _ = yield self.db.get_transaction(txhash) + raw, _, _, _ = yield self.db.get_transaction(txhash) if raw is not None: return self.transaction_class(raw) From a55feee960c553a5e99b82494b97dbfd291ecd37 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 1 Oct 2018 22:03:48 -0400 Subject: [PATCH 134/383] 0.0.5 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 210e2b896..2123d238e 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.0.4' +__version__ = '0.0.5' From 04aa5590379f98a2f8a7ff77eba1e9df5ba5a0ea Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 2 Oct 2018 09:53:23 -0400 Subject: [PATCH 135/383] simplified .gitignore --- .gitignore | 116 ++++++----------------------------------------------- 1 file changed, 12 insertions(+), 104 deletions(-) diff --git a/.gitignore b/.gitignore index 298830b77..d7a60a79b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,108 +1,16 @@ -# Byte-compiled / optimized / DLL files -__pycache__/ -*.py[cod] -*$py.class - -# C extensions -*.so - -# Distribution / packaging -.Python -env/ -build/ -develop-eggs/ +# packaging +torba.egg-info/ dist/ -downloads/ -eggs/ -.eggs/ -lib/ -lib64/ -parts/ -sdist/ -var/ -wheels/ -*.egg-info/ -.installed.cfg -*.egg -# PyInstaller -# Usually these files are written by a python script from a template -# before PyInstaller builds the exe, so as to inject date/other infos into it. -*.manifest -*.spec - -# Installer logs -pip-log.txt -pip-delete-this-directory.txt - -# Unit test / coverage reports -htmlcov/ -.tox/ -.coverage -.coverage.* -.cache -nosetests.xml -coverage.xml -*.cover -.hypothesis/ - -# Translations -*.mo -*.pot - -# Django stuff: -*.log -local_settings.py - -# Flask stuff: -instance/ -.webassets-cache - -# Scrapy stuff: -.scrapy - -# Sphinx documentation -docs/_build/ - -# PyBuilder -target/ - -# Jupyter Notebook -.ipynb_checkpoints - -# pyenv -.python-version - -# celery beat schedule file -celerybeat-schedule - -# SageMath parsed files -*.sage.py - -# dotenv -.env - -# virtualenv -.venv -venv/ -ENV/ - -# Spyder project settings -.spyderproject -.spyproject - -# Rope project settings -.ropeproject - -# mkdocs documentation -/site - -# mypy -.mypy_cache/ - - -# pycharm configuration +# PyCharm .idea/ -bin/ -data/ +# testing +.tox/ +tests/unit/bitcoin_headers + +# cache and logs +__pycache__/ +.mypy_cache/ +_trial_temp/ +_trial_temp-*/ From a6f97dfbde45bd7d4b0f105eefabc3d87d49b697 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 3 Oct 2018 07:08:02 -0400 Subject: [PATCH 136/383] refactored queries --- tests/unit/test_bip32.py | 2 +- tests/unit/test_database.py | 133 +++++++++++++++++++++++++++- tests/unit/test_transaction.py | 6 +- torba/baseaccount.py | 4 +- torba/basedatabase.py | 153 ++++++++++++++++++--------------- torba/baseledger.py | 28 +++--- torba/basetransaction.py | 5 +- 7 files changed, 240 insertions(+), 91 deletions(-) diff --git a/tests/unit/test_bip32.py b/tests/unit/test_bip32.py index 59e7756f2..12d69089e 100644 --- a/tests/unit/test_bip32.py +++ b/tests/unit/test_bip32.py @@ -5,6 +5,7 @@ from .key_fixtures import expected_ids, expected_privkeys, expected_hardened_pri from torba.bip32 import PubKey, PrivateKey, from_extended_key_string from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class + class BIP32Tests(unittest.TestCase): def test_pubkey_validation(self): @@ -81,7 +82,6 @@ class BIP32Tests(unittest.TestCase): self.assertIsInstance(new_privkey, PrivateKey) self.assertEqual(hexlify(new_privkey.private_key_bytes), expected_hardened_privkeys[i - 1 - PrivateKey.HARDENED]) - def test_from_extended_keys(self): ledger = ledger_class({ 'db': ledger_class.database_class(':memory:'), diff --git a/tests/unit/test_database.py b/tests/unit/test_database.py index 7831f7916..f22be4769 100644 --- a/tests/unit/test_database.py +++ b/tests/unit/test_database.py @@ -1,8 +1,15 @@ -from unittest import TestCase +from twisted.trial import unittest +from twisted.internet import defer + +from torba.wallet import Wallet +from torba.constants import COIN +from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class from torba.basedatabase import constraints_to_sql +from .test_transaction import get_output, NULL_HASH -class TestConstraintBuilder(TestCase): + +class TestConstraintBuilder(unittest.TestCase): def test_any(self): constraints = { @@ -21,3 +28,125 @@ class TestConstraintBuilder(TestCase): 'ages__any_age__lt': 38 } ) + + def test_in_list(self): + constraints = {'ages__in': [18, 38]} + self.assertEqual( + constraints_to_sql(constraints, prepend_sql=''), + 'ages IN (:ages_1, :ages_2)' + ) + self.assertEqual( + constraints, { + 'ages_1': 18, + 'ages_2': 38 + } + ) + + def test_in_query(self): + constraints = {'ages__in': 'SELECT age from ages_table'} + self.assertEqual( + constraints_to_sql(constraints, prepend_sql=''), + 'ages IN (SELECT age from ages_table)' + ) + self.assertEqual(constraints, {}) + + def test_not_in_query(self): + constraints = {'ages__not_in': 'SELECT age from ages_table'} + self.assertEqual( + constraints_to_sql(constraints, prepend_sql=''), + 'ages NOT IN (SELECT age from ages_table)' + ) + self.assertEqual(constraints, {}) + + +class TestQueries(unittest.TestCase): + + def setUp(self): + self.ledger = ledger_class({ + 'db': ledger_class.database_class(':memory:'), + 'headers': ledger_class.headers_class(':memory:'), + }) + return self.ledger.db.open() + + @defer.inlineCallbacks + def create_account(self): + account = self.ledger.account_class.generate(self.ledger, Wallet()) + yield account.ensure_address_gap() + return account + + @defer.inlineCallbacks + def create_tx_from_nothing(self, my_account, height): + to_address = yield my_account.receiving.get_or_create_usable_address() + to_hash = ledger_class.address_to_hash160(to_address) + tx = ledger_class.transaction_class(height=height, is_verified=True) \ + .add_inputs([self.txi(self.txo(1, NULL_HASH))]) \ + .add_outputs([self.txo(1, to_hash)]) + yield self.ledger.db.save_transaction_io('insert', tx, to_address, to_hash, '') + return tx + + @defer.inlineCallbacks + def create_tx_from_txo(self, txo, to_account, height): + from_hash = txo.script.values['pubkey_hash'] + from_address = self.ledger.hash160_to_address(from_hash) + to_address = yield to_account.receiving.get_or_create_usable_address() + to_hash = ledger_class.address_to_hash160(to_address) + tx = ledger_class.transaction_class(height=height, is_verified=True) \ + .add_inputs([self.txi(txo)]) \ + .add_outputs([self.txo(1, to_hash)]) + yield self.ledger.db.save_transaction_io('insert', tx, from_address, from_hash, '') + yield self.ledger.db.save_transaction_io('', tx, to_address, to_hash, '') + return tx + + @defer.inlineCallbacks + def create_tx_to_nowhere(self, txo, height): + from_hash = txo.script.values['pubkey_hash'] + from_address = self.ledger.hash160_to_address(from_hash) + to_hash = NULL_HASH + tx = ledger_class.transaction_class(height=height, is_verified=True) \ + .add_inputs([self.txi(txo)]) \ + .add_outputs([self.txo(1, to_hash)]) + yield self.ledger.db.save_transaction_io('insert', tx, from_address, from_hash, '') + return tx + + def txo(self, amount, address): + return get_output(int(amount*COIN), address) + + def txi(self, txo): + return ledger_class.transaction_class.input_class.spend(txo) + + @defer.inlineCallbacks + def test_get_transactions(self): + account1 = yield self.create_account() + account2 = yield self.create_account() + tx1 = yield self.create_tx_from_nothing(account1, 1) + tx2 = yield self.create_tx_from_txo(tx1.outputs[0], account2, 2) + tx3 = yield self.create_tx_to_nowhere(tx2.outputs[0], 3) + + txs = yield self.ledger.db.get_transactions() + self.assertEqual([tx3.id, tx2.id, tx1.id], [tx.id for tx in txs]) + self.assertEqual([3, 2, 1], [tx.height for tx in txs]) + + txs = yield self.ledger.db.get_transactions(account1) + self.assertEqual([tx2.id, tx1.id], [tx.id for tx in txs]) + self.assertEqual(txs[0].inputs[0].is_my_account, True) + self.assertEqual(txs[0].outputs[0].is_my_account, False) + self.assertEqual(txs[1].inputs[0].is_my_account, False) + self.assertEqual(txs[1].outputs[0].is_my_account, True) + + txs = yield self.ledger.db.get_transactions(account2) + self.assertEqual([tx3.id, tx2.id], [tx.id for tx in txs]) + self.assertEqual(txs[0].inputs[0].is_my_account, True) + self.assertEqual(txs[0].outputs[0].is_my_account, False) + self.assertEqual(txs[1].inputs[0].is_my_account, False) + self.assertEqual(txs[1].outputs[0].is_my_account, True) + + tx = yield self.ledger.db.get_transaction(tx2.id) + self.assertEqual(tx.id, tx2.id) + self.assertEqual(tx.inputs[0].is_my_account, False) + self.assertEqual(tx.outputs[0].is_my_account, False) + tx = yield self.ledger.db.get_transaction(tx2.id, account1) + self.assertEqual(tx.inputs[0].is_my_account, True) + self.assertEqual(tx.outputs[0].is_my_account, False) + tx = yield self.ledger.db.get_transaction(tx2.id, account2) + self.assertEqual(tx.inputs[0].is_my_account, False) + self.assertEqual(tx.outputs[0].is_my_account, True) diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index 640f82346..dca00f7e7 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -254,20 +254,20 @@ class TransactionIOBalancing(unittest.TestCase): def create_utxos(self, amounts): utxos = [self.txo(amount) for amount in amounts] - self.funding_tx = ledger_class.transaction_class() \ + self.funding_tx = ledger_class.transaction_class(is_verified=True) \ .add_inputs([self.txi(self.txo(sum(amounts)+0.1))]) \ .add_outputs(utxos) save_tx = 'insert' for utxo in utxos: yield self.ledger.db.save_transaction_io( - save_tx, self.funding_tx, True, + save_tx, self.funding_tx, self.ledger.hash160_to_address(utxo.script.values['pubkey_hash']), utxo.script.values['pubkey_hash'], '' ) save_tx = 'update' - defer.returnValue(utxos) + return utxos @staticmethod def inputs(tx): diff --git a/torba/baseaccount.py b/torba/baseaccount.py index a53712465..108147963 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -357,10 +357,10 @@ class BaseAccount: } def get_unspent_outputs(self, **constraints): - return self.ledger.db.get_utxos_for_account(self, **constraints) + return self.ledger.db.get_utxos(account=self, **constraints) def get_transactions(self) -> List['basetransaction.BaseTransaction']: - return self.ledger.db.get_transactions(self) + return self.ledger.db.get_transactions(account=self) @defer.inlineCallbacks def fund(self, to_account, amount=None, everything=False, diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 898c7e62f..8dd65d8f6 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -27,6 +27,20 @@ def constraints_to_sql(constraints, joiner=' AND ', prepend_sql=' AND ', prepend col, op = key[:-len('__gt')], '>' elif key.endswith('__like'): col, op = key[:-len('__like')], 'LIKE' + elif key.endswith('__in') or key.endswith('__not_in'): + if key.endswith('__in'): + col, op = key[:-len('__in')], 'IN' + else: + col, op = key[:-len('__not_in')], 'NOT IN' + items = constraints.pop(key) + if isinstance(items, list): + placeholders = [] + for item_no, item in enumerate(items, 1): + constraints['{}_{}'.format(col, item_no)] = item + placeholders.append(':{}_{}'.format(col, item_no)) + items = ', '.join(placeholders) + extras.append('{} {} ({})'.format(col, op, items)) + continue elif key.endswith('__any'): subconstraints = constraints.pop(key) extras.append('({})'.format( @@ -46,6 +60,7 @@ class SQLiteMixin: def __init__(self, path): self._db_path = path self.db: adbapi.ConnectionPool = None + self.ledger = None def open(self): log.info("connecting to database: %s", self._db_path) @@ -186,7 +201,7 @@ class BaseDatabase(SQLiteMixin): 'script': sqlite3.Binary(txo.script.source) } - def save_transaction_io(self, save_tx, tx: BaseTransaction, is_verified, address, txhash, history): + def save_transaction_io(self, save_tx, tx: BaseTransaction, address, txhash, history): def _steps(t): if save_tx == 'insert': @@ -195,11 +210,11 @@ class BaseDatabase(SQLiteMixin): 'raw': sqlite3.Binary(tx.raw), 'height': tx.height, 'position': tx.position, - 'is_verified': is_verified + 'is_verified': tx.is_verified })) elif save_tx == 'update': self.execute(t, *self._update_sql("tx", { - 'height': tx.height, 'position': tx.position, 'is_verified': is_verified + 'height': tx.height, 'position': tx.position, 'is_verified': tx.is_verified }, 'txid = ?', (tx.id,))) existing_txos = [r[0] for r in self.execute( @@ -260,32 +275,40 @@ class BaseDatabase(SQLiteMixin): return defer.succeed(True) @defer.inlineCallbacks - def get_transaction(self, txid): - result = yield self.run_query( - "SELECT raw, height, position, is_verified FROM tx WHERE txid = ?", (txid,) - ) - if result: - return result[0] - else: - return None, None, None, False + def get_transaction(self, txid, account=None): + txs = yield self.get_transactions(account=account, txid=txid) + if len(txs) == 1: + return txs[0] @defer.inlineCallbacks - def get_transactions(self, account, offset=0, limit=100): - account_id = account.public_key.address + def get_transactions(self, account=None, txid=None, offset=0, limit=1000): + + tx_where = "" + account_id = account.public_key.address if account is not None else None + + if txid is not None: + tx_where = """ + WHERE txid = :txid + """ + elif account is not None: + tx_where = """ + WHERE txid IN ( + SELECT txo.txid FROM txo + JOIN pubkey_address USING (address) WHERE pubkey_address.account = :account + UNION + SELECT txi.txid FROM txi + JOIN txo USING (txoid) + JOIN pubkey_address USING (address) WHERE pubkey_address.account = :account + ) + """ + tx_rows = yield self.run_query( """ - SELECT txid, raw, height, position FROM tx WHERE txid IN ( - SELECT txo.txid FROM txo - JOIN pubkey_address USING (address) - WHERE pubkey_address.account = :account - UNION - SELECT txo.txid FROM txi - JOIN txo USING (txoid) - JOIN pubkey_address USING (address) - WHERE pubkey_address.account = :account - ) ORDER BY height DESC, position DESC LIMIT :offset, :limit - """, { + SELECT txid, raw, height, position, is_verified FROM tx {} + ORDER BY height DESC, position DESC LIMIT :offset, :limit + """.format(tx_where), { 'account': account_id, + 'txid': txid, 'offset': min(offset, 0), 'limit': max(limit, 100) } @@ -293,8 +316,8 @@ class BaseDatabase(SQLiteMixin): txids, txs = [], [] for row in tx_rows: txids.append(row[0]) - txs.append(account.ledger.transaction_class( - raw=row[1], height=row[2], position=row[3] + txs.append(self.ledger.transaction_class( + raw=row[1], height=row[2], position=row[3], is_verified=row[4] )) txo_rows = yield self.run_query( @@ -311,31 +334,18 @@ class BaseDatabase(SQLiteMixin): 'is_my_account': row[2] == account_id } - referenced_txo_rows = yield self.run_query( - """ - SELECT txoid, txo.amount, txo.script, txo.txid, txo.position, chain, account - FROM txi - JOIN txo USING (txoid) - JOIN pubkey_address USING (address) - WHERE txi.txid IN ({}) - """.format(', '.join(['?']*len(txids))), txids - ) - referenced_txos = {} - output_class = account.ledger.transaction_class.output_class - for row in referenced_txo_rows: - referenced_txos[row[0]] = output_class( - amount=row[1], - script=output_class.script_class(row[2]), - tx_ref=TXRefImmutable.from_id(row[3]), - position=row[4], - is_change=row[5] == 1, - is_my_account=row[6] == account_id + referenced_txos = yield self.get_txos( + account=account, + txoid__in="SELECT txoid FROM txi WHERE txi.txid IN ({})".format( + ','.join("'{}'".format(txid) for txid in txids) ) + ) + referenced_txos_map = {txo.id: txo for txo in referenced_txos} for tx in txs: for txi in tx.inputs: - if txi.txo_ref.id in referenced_txos: - txi.txo_ref = TXORefResolvable(referenced_txos[txi.txo_ref.id]) + if txi.txo_ref.id in referenced_txos_map: + txi.txo_ref = TXORefResolvable(referenced_txos_map[txi.txo_ref.id]) for txo in tx.outputs: txo_meta = txos.get(txo.id) if txo_meta is not None: @@ -347,6 +357,35 @@ class BaseDatabase(SQLiteMixin): return txs + @defer.inlineCallbacks + def get_txos(self, account=None, **constraints): + account_id = None + if account is not None: + account_id = account.public_key.address + constraints['account'] = account_id + rows = yield self.run_query( + """ + SELECT amount, script, txid, txo.position, chain, account + FROM txo JOIN pubkey_address USING (address) + """+constraints_to_sql(constraints, prepend_sql='WHERE '), constraints + ) + output_class = self.ledger.transaction_class.output_class + return [ + output_class( + amount=row[0], + script=output_class.script_class(row[1]), + tx_ref=TXRefImmutable.from_id(row[2]), + position=row[3], + is_change=row[4] == 1, + is_my_account=row[5] == account_id + ) for row in rows + ] + + def get_utxos(self, **constraints): + constraints['txoid__not_in'] = 'SELECT txoid FROM txi' + constraints['is_reserved'] = 0 + return self.get_txos(**constraints) + def get_balance_for_account(self, account, include_reserved=False, **constraints): if not include_reserved: constraints['is_reserved'] = 0 @@ -364,26 +403,6 @@ class BaseDatabase(SQLiteMixin): """+constraints_to_sql(constraints), values, 0 ) - @defer.inlineCallbacks - def get_utxos_for_account(self, account, **constraints): - constraints['account'] = account.public_key.address - utxos = yield self.run_query( - """ - SELECT amount, script, txid, txo.position - FROM txo JOIN pubkey_address ON pubkey_address.address=txo.address - WHERE account=:account AND txo.is_reserved=0 AND txoid NOT IN (SELECT txoid FROM txi) - """+constraints_to_sql(constraints), constraints - ) - output_class = account.ledger.transaction_class.output_class - return [ - output_class( - values[0], - output_class.script_class(values[1]), - TXRefImmutable.from_id(values[2]), - position=values[3] - ) for values in utxos - ] - def add_keys(self, account, chain, keys): sql = ( "insert into pubkey_address " diff --git a/torba/baseledger.py b/torba/baseledger.py index 8a7ca4de8..a9b186f90 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -40,7 +40,7 @@ class LedgerRegistry(type): return mcs.ledgers[ledger_id] -class TransactionEvent(namedtuple('TransactionEvent', ('address', 'tx', 'is_verified'))): +class TransactionEvent(namedtuple('TransactionEvent', ('address', 'tx'))): pass @@ -73,6 +73,7 @@ class BaseLedger(metaclass=LedgerRegistry): self.db: BaseDatabase = self.config.get('db') or self.database_class( os.path.join(self.path, "blockchain.db") ) + self.db.ledger = self self.headers: BaseHeaders = self.config.get('headers') or self.headers_class( os.path.join(self.path, "headers") ) @@ -87,7 +88,7 @@ class BaseLedger(metaclass=LedgerRegistry): self.on_transaction.listen( lambda e: log.info( '(%s) on_transaction: address=%s, height=%s, is_verified=%s, tx.id=%s', - self.get_id(), e.address, e.tx.height, e.is_verified, e.tx.id + self.get_id(), e.address, e.tx.height, e.tx.is_verified, e.tx.id ) ) @@ -214,7 +215,7 @@ class BaseLedger(metaclass=LedgerRegistry): merkle_root = self.get_root_of_merkle_tree(merkle['merkle'], merkle['pos'], tx.hash) header = self.headers[height] tx.position = merkle['pos'] - return merkle_root == header['merkle_root'] + tx.is_verified = merkle_root == header['merkle_root'] @defer.inlineCallbacks def start(self): @@ -366,32 +367,31 @@ class BaseLedger(metaclass=LedgerRegistry): try: # see if we have a local copy of transaction, otherwise fetch it from server - raw, _, position, is_verified = yield self.db.get_transaction(hex_id) + tx = yield self.db.get_transaction(hex_id) save_tx = None - if raw is None: + if tx is None: _raw = yield self.network.get_transaction(hex_id) - tx = self.transaction_class(unhexlify(_raw), height=remote_height) + tx = self.transaction_class(unhexlify(_raw)) save_tx = 'insert' - else: - tx = self.transaction_class(raw, height=remote_height) - if remote_height > 0 and (not is_verified or position is None): - is_verified = yield self.validate_transaction_and_set_position(tx, remote_height) - is_verified = 1 if is_verified else 0 + tx.height = remote_height + + if remote_height > 0 and (not tx.is_verified or tx.position == -1): + yield self.validate_transaction_and_set_position(tx, remote_height) if save_tx is None: save_tx = 'update' yield self.db.save_transaction_io( - save_tx, tx, is_verified, address, self.address_to_hash160(address), + save_tx, tx, address, self.address_to_hash160(address), ''.join('{}:{}:'.format(tx_id, tx_height) for tx_id, tx_height in synced_history) ) log.debug( "%s: sync'ed tx %s for address: %s, height: %s, verified: %s", - self.get_id(), hex_id, address, remote_height, is_verified + self.get_id(), hex_id, address, tx.height, tx.is_verified ) - self._on_transaction_controller.add(TransactionEvent(address, tx, is_verified)) + self._on_transaction_controller.add(TransactionEvent(address, tx)) except Exception: log.exception('Failed to synchronize transaction:') diff --git a/torba/basetransaction.py b/torba/basetransaction.py index d19a855b0..42986e94d 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -141,7 +141,7 @@ class BaseInput(InputOutput): def is_my_account(self) -> Optional[bool]: """ True if the output this input spends is yours. """ if self.txo_ref.txo is None: - raise ValueError('Cannot resolve output to determine ownership.') + return False return self.txo_ref.txo.is_my_account @classmethod @@ -237,7 +237,7 @@ class BaseTransaction: input_class = BaseInput output_class = BaseOutput - def __init__(self, raw=None, version: int = 1, locktime: int = 0, + def __init__(self, raw=None, version: int = 1, locktime: int = 0, is_verified: bool = False, height: int = -1, position: int = -1) -> None: self._raw = raw self.ref = TXRefMutable(self) @@ -245,6 +245,7 @@ class BaseTransaction: self.locktime = locktime self._inputs: List[BaseInput] = [] self._outputs: List[BaseOutput] = [] + self.is_verified = is_verified self.height = height self.position = position if raw is not None: From 1f4a9cff26e47fc6fbd95e400ce4e91968cc10e5 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 3 Oct 2018 09:36:31 -0400 Subject: [PATCH 137/383] ignore too-many-branches pylint issue --- setup.cfg | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.cfg b/setup.cfg index 30f659a16..ab05b38df 100644 --- a/setup.cfg +++ b/setup.cfg @@ -25,6 +25,7 @@ disable= inconsistent-return-statements, too-few-public-methods, too-many-locals, + too-many-branches, too-many-arguments, too-many-public-methods, too-many-instance-attributes, From 0960762694714b31bb2d787580aee7c29a9d8a84 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 3 Oct 2018 11:51:42 -0400 Subject: [PATCH 138/383] sql constraints support table.column dot delimited column names --- tests/unit/test_database.py | 39 ++++++++++++++++++++++++------------- torba/__init__.py | 2 +- torba/basedatabase.py | 29 ++++++++++++++++----------- 3 files changed, 45 insertions(+), 25 deletions(-) diff --git a/tests/unit/test_database.py b/tests/unit/test_database.py index f22be4769..45cb029cd 100644 --- a/tests/unit/test_database.py +++ b/tests/unit/test_database.py @@ -11,53 +11,66 @@ from .test_transaction import get_output, NULL_HASH class TestConstraintBuilder(unittest.TestCase): + def test_dot(self): + constraints = {'txo.position': 18} + self.assertEqual( + constraints_to_sql(constraints, prepend_sql=''), + 'txo.position = :txo_position' + ) + self.assertEqual(constraints, {'txo_position': 18}) + def test_any(self): constraints = { 'ages__any': { - 'age__gt': 18, - 'age__lt': 38 + 'txo.age__gt': 18, + 'txo.age__lt': 38 } } self.assertEqual( constraints_to_sql(constraints, prepend_sql=''), - '(age > :ages__any_age__gt OR age < :ages__any_age__lt)' + '(txo.age > :ages__any_txo_age__gt OR txo.age < :ages__any_txo_age__lt)' ) self.assertEqual( constraints, { - 'ages__any_age__gt': 18, - 'ages__any_age__lt': 38 + 'ages__any_txo_age__gt': 18, + 'ages__any_txo_age__lt': 38 } ) def test_in_list(self): - constraints = {'ages__in': [18, 38]} + constraints = {'txo.age__in': [18, 38]} self.assertEqual( constraints_to_sql(constraints, prepend_sql=''), - 'ages IN (:ages_1, :ages_2)' + 'txo.age IN (:txo_age_1, :txo_age_2)' ) self.assertEqual( constraints, { - 'ages_1': 18, - 'ages_2': 38 + 'txo_age_1': 18, + 'txo_age_2': 38 } ) def test_in_query(self): - constraints = {'ages__in': 'SELECT age from ages_table'} + constraints = {'txo.age__in': 'SELECT age from ages_table'} self.assertEqual( constraints_to_sql(constraints, prepend_sql=''), - 'ages IN (SELECT age from ages_table)' + 'txo.age IN (SELECT age from ages_table)' ) self.assertEqual(constraints, {}) def test_not_in_query(self): - constraints = {'ages__not_in': 'SELECT age from ages_table'} + constraints = {'txo.age__not_in': 'SELECT age from ages_table'} self.assertEqual( constraints_to_sql(constraints, prepend_sql=''), - 'ages NOT IN (SELECT age from ages_table)' + 'txo.age NOT IN (SELECT age from ages_table)' ) self.assertEqual(constraints, {}) + def test_in_invalid(self): + constraints = {'ages__in': 9} + with self.assertRaisesRegex(ValueError, 'list or string'): + constraints_to_sql(constraints, prepend_sql='') + class TestQueries(unittest.TestCase): diff --git a/torba/__init__.py b/torba/__init__.py index 2123d238e..c5362f6e8 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.0.5' +__version__ = '0.0.7' diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 8dd65d8f6..375fa4337 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -11,12 +11,16 @@ from torba.basetransaction import BaseTransaction, TXORefResolvable log = logging.getLogger(__name__) +def clean_arg_name(arg): + return arg.replace('.', '_') + + def constraints_to_sql(constraints, joiner=' AND ', prepend_sql=' AND ', prepend_key=''): if not constraints: return '' extras = [] for key in list(constraints): - col, op = key, '=' + col, op, constraint = key, '=', constraints.pop(key) if key.endswith('__not'): col, op = key[:-len('__not')], '!=' elif key.endswith('__lt'): @@ -32,24 +36,27 @@ def constraints_to_sql(constraints, joiner=' AND ', prepend_sql=' AND ', prepend col, op = key[:-len('__in')], 'IN' else: col, op = key[:-len('__not_in')], 'NOT IN' - items = constraints.pop(key) - if isinstance(items, list): + if isinstance(constraint, list): placeholders = [] - for item_no, item in enumerate(items, 1): - constraints['{}_{}'.format(col, item_no)] = item - placeholders.append(':{}_{}'.format(col, item_no)) + for item_no, item in enumerate(constraint, 1): + constraints['{}_{}'.format(clean_arg_name(col), item_no)] = item + placeholders.append(':{}_{}'.format(clean_arg_name(col), item_no)) items = ', '.join(placeholders) + elif isinstance(constraint, str): + items = constraint + else: + raise ValueError("{} requires a list or string as constraint value.".format(key)) extras.append('{} {} ({})'.format(col, op, items)) continue elif key.endswith('__any'): - subconstraints = constraints.pop(key) extras.append('({})'.format( - constraints_to_sql(subconstraints, ' OR ', '', key+'_') + constraints_to_sql(constraint, ' OR ', '', key+'_') )) - for subkey, val in subconstraints.items(): - constraints['{}_{}'.format(key, subkey)] = val + for subkey, val in constraint.items(): + constraints['{}_{}'.format(clean_arg_name(key), clean_arg_name(subkey))] = val continue - extras.append('{} {} :{}'.format(col, op, prepend_key+key)) + constraints[clean_arg_name(key)] = constraint + extras.append('{} {} :{}'.format(col, op, prepend_key+clean_arg_name(key))) return prepend_sql + joiner.join(extras) if extras else '' From 356ab9666f3076b19afc0a72c4faf06bccaeca1e Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 4 Oct 2018 19:27:39 -0400 Subject: [PATCH 139/383] refactored get_transactions and get_txos --- torba/basedatabase.py | 116 +++++++++++++++++++-------------------- torba/baseledger.py | 5 +- torba/basetransaction.py | 8 +++ 3 files changed, 64 insertions(+), 65 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 375fa4337..e89f23293 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -7,6 +7,7 @@ from twisted.enterprise import adbapi from torba.hash import TXRefImmutable from torba.basetransaction import BaseTransaction, TXORefResolvable +from torba.baseaccount import BaseAccount log = logging.getLogger(__name__) @@ -15,6 +16,13 @@ def clean_arg_name(arg): return arg.replace('.', '_') +def prepare_constraints(constraints): + if 'account' in constraints: + if isinstance(constraints['account'], BaseAccount): + constraints['account'] = constraints['account'].public_key.address + return constraints.pop('my_account', constraints.get('account')) + + def constraints_to_sql(constraints, joiner=' AND ', prepend_sql=' AND ', prepend_key=''): if not constraints: return '' @@ -36,7 +44,7 @@ def constraints_to_sql(constraints, joiner=' AND ', prepend_sql=' AND ', prepend col, op = key[:-len('__in')], 'IN' else: col, op = key[:-len('__not_in')], 'NOT IN' - if isinstance(constraint, list): + if isinstance(constraint, (list, set)): placeholders = [] for item_no, item in enumerate(constraint, 1): constraints['{}_{}'.format(clean_arg_name(col), item_no)] = item @@ -288,38 +296,34 @@ class BaseDatabase(SQLiteMixin): return txs[0] @defer.inlineCallbacks - def get_transactions(self, account=None, txid=None, offset=0, limit=1000): + def get_transactions(self, offset=0, limit=1000000, **constraints): + my_account = prepare_constraints(constraints) + account = constraints.pop('account', None) - tx_where = "" - account_id = account.public_key.address if account is not None else None + if 'txid' not in constraints and account is not None: + constraints['txid__in'] = """ + SELECT txo.txid FROM txo + JOIN pubkey_address USING (address) WHERE pubkey_address.account = :account + UNION + SELECT txi.txid FROM txi + JOIN txo USING (txoid) + JOIN pubkey_address USING (address) WHERE pubkey_address.account = :account + """ - if txid is not None: - tx_where = """ - WHERE txid = :txid - """ - elif account is not None: - tx_where = """ - WHERE txid IN ( - SELECT txo.txid FROM txo - JOIN pubkey_address USING (address) WHERE pubkey_address.account = :account - UNION - SELECT txi.txid FROM txi - JOIN txo USING (txoid) - JOIN pubkey_address USING (address) WHERE pubkey_address.account = :account - ) - """ + where = constraints_to_sql(constraints, prepend_sql='WHERE ') tx_rows = yield self.run_query( """ SELECT txid, raw, height, position, is_verified FROM tx {} ORDER BY height DESC, position DESC LIMIT :offset, :limit - """.format(tx_where), { - 'account': account_id, - 'txid': txid, - 'offset': min(offset, 0), - 'limit': max(limit, 100) + """.format(where), { + **constraints, + 'account': account, + 'offset': max(offset, 0), + 'limit': max(limit, 1) } ) + txids, txs = [], [] for row in tx_rows: txids.append(row[0]) @@ -327,49 +331,39 @@ class BaseDatabase(SQLiteMixin): raw=row[1], height=row[2], position=row[3], is_verified=row[4] )) - txo_rows = yield self.run_query( - """ - SELECT txoid, chain, account - FROM txo JOIN pubkey_address USING (address) - WHERE txid IN ({}) - """.format(', '.join(['?']*len(txids))), txids - ) - txos = {} - for row in txo_rows: - txos[row[0]] = { - 'is_change': row[1] == 1, - 'is_my_account': row[2] == account_id - } + annotated_txos = { + txo.id: txo for txo in + (yield self.get_txos( + my_account=my_account, + txid__in=txids + )) + } - referenced_txos = yield self.get_txos( - account=account, - txoid__in="SELECT txoid FROM txi WHERE txi.txid IN ({})".format( - ','.join("'{}'".format(txid) for txid in txids) - ) - ) - referenced_txos_map = {txo.id: txo for txo in referenced_txos} + referenced_txos = { + txo.id: txo for txo in + (yield self.get_txos( + my_account=my_account, + txoid__in="SELECT txoid FROM txi WHERE txi.txid IN ({})".format( + ','.join("'{}'".format(txid) for txid in txids) + ) + )) + } for tx in txs: for txi in tx.inputs: - if txi.txo_ref.id in referenced_txos_map: - txi.txo_ref = TXORefResolvable(referenced_txos_map[txi.txo_ref.id]) + txo = referenced_txos.get(txi.txo_ref.id) + if txo: + txi.txo_ref = txo.ref for txo in tx.outputs: - txo_meta = txos.get(txo.id) - if txo_meta is not None: - txo.is_change = txo_meta['is_change'] - txo.is_my_account = txo_meta['is_my_account'] - else: - txo.is_change = False - txo.is_my_account = False + _txo = annotated_txos.get(txo.id) + if _txo: + txo.update_annotations(_txo) return txs @defer.inlineCallbacks - def get_txos(self, account=None, **constraints): - account_id = None - if account is not None: - account_id = account.public_key.address - constraints['account'] = account_id + def get_txos(self, **constraints): + my_account = prepare_constraints(constraints) rows = yield self.run_query( """ SELECT amount, script, txid, txo.position, chain, account @@ -384,18 +378,18 @@ class BaseDatabase(SQLiteMixin): tx_ref=TXRefImmutable.from_id(row[2]), position=row[3], is_change=row[4] == 1, - is_my_account=row[5] == account_id + is_my_account=row[5] == my_account ) for row in rows ] def get_utxos(self, **constraints): constraints['txoid__not_in'] = 'SELECT txoid FROM txi' - constraints['is_reserved'] = 0 + constraints['is_reserved'] = False return self.get_txos(**constraints) def get_balance_for_account(self, account, include_reserved=False, **constraints): if not include_reserved: - constraints['is_reserved'] = 0 + constraints['is_reserved'] = False values = {'account': account.public_key.address} values.update(constraints) return self.query_one_value( diff --git a/torba/baseledger.py b/torba/baseledger.py index a9b186f90..50c00a607 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -133,11 +133,8 @@ class BaseLedger(metaclass=LedgerRegistry): def add_account(self, account: baseaccount.BaseAccount): self.accounts.append(account) - @defer.inlineCallbacks def get_transaction(self, txhash): - raw, _, _, _ = yield self.db.get_transaction(txhash) - if raw is not None: - return self.transaction_class(raw) + return self.db.get_transaction(txhash) @defer.inlineCallbacks def get_private_key_for_address(self, address): diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 42986e94d..745e0c2f4 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -200,6 +200,14 @@ class BaseOutput(InputOutput): self.is_change = is_change self.is_my_account = is_my_account + def update_annotations(self, annotated): + if annotated is None: + self.is_change = False + self.is_my_account = False + else: + self.is_change = annotated.is_change + self.is_my_account = annotated.is_my_account + @property def ref(self): return TXORefResolvable(self) From fe59ed0105180f0bd9427bba49752967ddbd53a8 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 4 Oct 2018 19:33:14 -0400 Subject: [PATCH 140/383] remove unused import --- torba/basedatabase.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index e89f23293..5170c57af 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -6,7 +6,7 @@ from twisted.internet import defer from twisted.enterprise import adbapi from torba.hash import TXRefImmutable -from torba.basetransaction import BaseTransaction, TXORefResolvable +from torba.basetransaction import BaseTransaction from torba.baseaccount import BaseAccount log = logging.getLogger(__name__) From 38b1fb5fbabec0a9e04897cbe57d363d2c3fe746 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 4 Oct 2018 19:42:29 -0400 Subject: [PATCH 141/383] fix get_transaction unit test --- tests/unit/test_database.py | 4 ++-- torba/basedatabase.py | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/tests/unit/test_database.py b/tests/unit/test_database.py index 45cb029cd..bb3e284f7 100644 --- a/tests/unit/test_database.py +++ b/tests/unit/test_database.py @@ -139,14 +139,14 @@ class TestQueries(unittest.TestCase): self.assertEqual([tx3.id, tx2.id, tx1.id], [tx.id for tx in txs]) self.assertEqual([3, 2, 1], [tx.height for tx in txs]) - txs = yield self.ledger.db.get_transactions(account1) + txs = yield self.ledger.db.get_transactions(account=account1) self.assertEqual([tx2.id, tx1.id], [tx.id for tx in txs]) self.assertEqual(txs[0].inputs[0].is_my_account, True) self.assertEqual(txs[0].outputs[0].is_my_account, False) self.assertEqual(txs[1].inputs[0].is_my_account, False) self.assertEqual(txs[1].outputs[0].is_my_account, True) - txs = yield self.ledger.db.get_transactions(account2) + txs = yield self.ledger.db.get_transactions(account=account2) self.assertEqual([tx3.id, tx2.id], [tx.id for tx in txs]) self.assertEqual(txs[0].inputs[0].is_my_account, True) self.assertEqual(txs[0].outputs[0].is_my_account, False) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 5170c57af..b70be1d73 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -358,6 +358,8 @@ class BaseDatabase(SQLiteMixin): _txo = annotated_txos.get(txo.id) if _txo: txo.update_annotations(_txo) + else: + txo.update_annotations(None) return txs From 95cbdcb1313b92802fd5bbbf5c1efa9f0956181f Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 7 Oct 2018 14:53:44 -0400 Subject: [PATCH 142/383] refactored sql queries, added full pagination support: limit, offset and count --- tests/integration/test_transactions.py | 2 +- tests/unit/test_account.py | 5 +- tests/unit/test_database.py | 106 +++++--- tests/unit/test_transaction.py | 2 +- torba/baseaccount.py | 51 ++-- torba/basedatabase.py | 327 +++++++++++++------------ torba/baseledger.py | 6 +- 7 files changed, 270 insertions(+), 229 deletions(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 3cc2c8073..697397ba1 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -43,7 +43,7 @@ class BasicTransactionTests(IntegrationTestCase): self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 3.5) self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) - utxos = await d2f(self.account.get_unspent_outputs()) + utxos = await d2f(self.account.get_utxos()) tx = await d2f(self.ledger.transaction_class.create( [self.ledger.transaction_class.input_class.spend(utxos[0])], [], diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index f23f29c0d..912c3bbce 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -223,7 +223,10 @@ class TestSingleKeyAccount(unittest.TestCase): self.assertEqual(new_keys[0], account.public_key.address) records = yield account.receiving.get_address_records() self.assertEqual(records, [{ - 'position': 0, 'address': account.public_key.address, 'used_times': 0 + 'position': 0, 'chain': 0, + 'account': account.public_key.address, + 'address': account.public_key.address, + 'used_times': 0 }]) # case #1: no new addresses needed diff --git a/tests/unit/test_database.py b/tests/unit/test_database.py index bb3e284f7..231480610 100644 --- a/tests/unit/test_database.py +++ b/tests/unit/test_database.py @@ -4,72 +4,100 @@ from twisted.internet import defer from torba.wallet import Wallet from torba.constants import COIN from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class -from torba.basedatabase import constraints_to_sql +from torba.basedatabase import query, constraints_to_sql from .test_transaction import get_output, NULL_HASH -class TestConstraintBuilder(unittest.TestCase): +class TestQueryBuilder(unittest.TestCase): def test_dot(self): - constraints = {'txo.position': 18} self.assertEqual( - constraints_to_sql(constraints, prepend_sql=''), - 'txo.position = :txo_position' + constraints_to_sql({'txo.position': 18}), + ('txo.position = :txo_position', {'txo_position': 18}) ) - self.assertEqual(constraints, {'txo_position': 18}) def test_any(self): - constraints = { - 'ages__any': { - 'txo.age__gt': 18, - 'txo.age__lt': 38 - } - } self.assertEqual( - constraints_to_sql(constraints, prepend_sql=''), - '(txo.age > :ages__any_txo_age__gt OR txo.age < :ages__any_txo_age__lt)' - ) - self.assertEqual( - constraints, { + constraints_to_sql({ + 'ages__any': { + 'txo.age__gt': 18, + 'txo.age__lt': 38 + } + }), + ('(txo.age > :ages__any_txo_age__gt OR txo.age < :ages__any_txo_age__lt)', { 'ages__any_txo_age__gt': 18, 'ages__any_txo_age__lt': 38 - } + }) ) def test_in_list(self): - constraints = {'txo.age__in': [18, 38]} self.assertEqual( - constraints_to_sql(constraints, prepend_sql=''), - 'txo.age IN (:txo_age_1, :txo_age_2)' + constraints_to_sql({'txo.age__in': [18, 38]}), + ('txo.age IN (18, 38)', {}) ) self.assertEqual( - constraints, { - 'txo_age_1': 18, - 'txo_age_2': 38 - } + constraints_to_sql({'txo.age__in': ['abc123', 'def456']}), + ("txo.age IN ('abc123', 'def456')", {}) ) def test_in_query(self): - constraints = {'txo.age__in': 'SELECT age from ages_table'} self.assertEqual( - constraints_to_sql(constraints, prepend_sql=''), - 'txo.age IN (SELECT age from ages_table)' + constraints_to_sql({'txo.age__in': 'SELECT age from ages_table'}), + ('txo.age IN (SELECT age from ages_table)', {}) ) - self.assertEqual(constraints, {}) def test_not_in_query(self): - constraints = {'txo.age__not_in': 'SELECT age from ages_table'} self.assertEqual( - constraints_to_sql(constraints, prepend_sql=''), - 'txo.age NOT IN (SELECT age from ages_table)' + constraints_to_sql({'txo.age__not_in': 'SELECT age from ages_table'}), + ('txo.age NOT IN (SELECT age from ages_table)', {}) ) - self.assertEqual(constraints, {}) def test_in_invalid(self): - constraints = {'ages__in': 9} - with self.assertRaisesRegex(ValueError, 'list or string'): - constraints_to_sql(constraints, prepend_sql='') + with self.assertRaisesRegex(ValueError, 'list, set or string'): + constraints_to_sql({'ages__in': 9}) + + def test_query(self): + self.assertEqual( + query("select * from foo"), + ("select * from foo", {}) + ) + self.assertEqual( + query( + "select * from foo", + a='b', b__in='select * from blah where c=:$c', + d__any={'one': 1, 'two': 2}, limit=10, order_by='b', **{'$c': 3}), + ( + "select * from foo WHERE a = :a AND " + "b IN (select * from blah where c=:$c) AND " + "(one = :d__any_one OR two = :d__any_two) ORDER BY b LIMIT 10", + {'a': 'b', 'd__any_one': 1, 'd__any_two': 2, '$c': 3} + ) + ) + + def test_query_order_by(self): + self.assertEqual( + query("select * from foo", order_by='foo'), + ("select * from foo ORDER BY foo", {}) + ) + self.assertEqual( + query("select * from foo", order_by=['foo', 'bar']), + ("select * from foo ORDER BY foo, bar", {}) + ) + + def test_query_limit_offset(self): + self.assertEqual( + query("select * from foo", limit=10), + ("select * from foo LIMIT 10", {}) + ) + self.assertEqual( + query("select * from foo", offset=10), + ("select * from foo OFFSET 10", {}) + ) + self.assertEqual( + query("select * from foo", limit=20, offset=10), + ("select * from foo OFFSET 10 LIMIT 20", {}) + ) class TestQueries(unittest.TestCase): @@ -153,13 +181,13 @@ class TestQueries(unittest.TestCase): self.assertEqual(txs[1].inputs[0].is_my_account, False) self.assertEqual(txs[1].outputs[0].is_my_account, True) - tx = yield self.ledger.db.get_transaction(tx2.id) + tx = yield self.ledger.db.get_transaction(txid=tx2.id) self.assertEqual(tx.id, tx2.id) self.assertEqual(tx.inputs[0].is_my_account, False) self.assertEqual(tx.outputs[0].is_my_account, False) - tx = yield self.ledger.db.get_transaction(tx2.id, account1) + tx = yield self.ledger.db.get_transaction(txid=tx2.id, account=account1) self.assertEqual(tx.inputs[0].is_my_account, True) self.assertEqual(tx.outputs[0].is_my_account, False) - tx = yield self.ledger.db.get_transaction(tx2.id, account2) + tx = yield self.ledger.db.get_transaction(txid=tx2.id, account=account2) self.assertEqual(tx.inputs[0].is_my_account, False) self.assertEqual(tx.outputs[0].is_my_account, True) diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index dca00f7e7..26c5f6d8d 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -201,7 +201,7 @@ class TestTransactionSigning(unittest.TestCase): ) yield account.ensure_address_gap() - address1, address2 = yield account.receiving.get_addresses(2) + address1, address2 = yield account.receiving.get_addresses(limit=2) pubkey_hash1 = self.ledger.address_to_hash160(address1) pubkey_hash2 = self.ledger.address_to_hash160(address2) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 108147963..b2c5fb8d7 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -47,9 +47,11 @@ class AddressManager: def db(self): return self.account.ledger.db - def _query_addresses(self, limit: int = None, max_used_times: int = None, order_by=None): + def _query_addresses(self, **constraints): return self.db.get_addresses( - self.account, self.chain_number, limit, max_used_times, order_by + account=self.account, + chain=self.chain_number, + **constraints ) def get_private_key(self, index: int) -> PrivateKey: @@ -61,17 +63,17 @@ class AddressManager: def ensure_address_gap(self) -> defer.Deferred: raise NotImplementedError - def get_address_records(self, limit: int = None, only_usable: bool = False) -> defer.Deferred: + def get_address_records(self, only_usable: bool = False, **constraints) -> defer.Deferred: raise NotImplementedError @defer.inlineCallbacks - def get_addresses(self, limit: int = None, only_usable: bool = False) -> defer.Deferred: - records = yield self.get_address_records(limit=limit, only_usable=only_usable) + def get_addresses(self, only_usable: bool = False, **constraints) -> defer.Deferred: + records = yield self.get_address_records(only_usable=only_usable, **constraints) return [r['address'] for r in records] @defer.inlineCallbacks def get_or_create_usable_address(self) -> defer.Deferred: - addresses = yield self.get_addresses(limit=1, only_usable=True) + addresses = yield self.get_addresses(only_usable=True, limit=1) if addresses: return addresses[0] addresses = yield self.ensure_address_gap() @@ -128,7 +130,7 @@ class HierarchicalDeterministic(AddressManager): @defer.inlineCallbacks def ensure_address_gap(self) -> defer.Deferred: - addresses = yield self._query_addresses(self.gap, None, "position DESC") + addresses = yield self._query_addresses(limit=self.gap, order_by="position DESC") existing_gap = 0 for address in addresses: @@ -145,11 +147,10 @@ class HierarchicalDeterministic(AddressManager): new_keys = yield self.generate_keys(start, end-1) return new_keys - def get_address_records(self, limit: int = None, only_usable: bool = False): - return self._query_addresses( - limit, self.maximum_uses_per_address if only_usable else None, - "used_times ASC, position ASC" - ) + def get_address_records(self, only_usable: bool = False, **constraints): + if only_usable: + constraints['used_times__lte'] = self.maximum_uses_per_address + return self._query_addresses(order_by="used_times ASC, position ASC", **constraints) class SingleKey(AddressManager): @@ -184,8 +185,8 @@ class SingleKey(AddressManager): return [self.public_key.address] return [] - def get_address_records(self, limit: int = None, only_usable: bool = False) -> defer.Deferred: - return self._query_addresses() + def get_address_records(self, only_usable: bool = False, **constraints) -> defer.Deferred: + return self._query_addresses(**constraints) class BaseAccount: @@ -329,23 +330,23 @@ class BaseAccount: return addresses @defer.inlineCallbacks - def get_addresses(self, limit: int = None, max_used_times: int = None) -> defer.Deferred: - records = yield self.get_address_records(limit, max_used_times) - return [r['address'] for r in records] + def get_addresses(self, **constraints) -> defer.Deferred: + rows = yield self.ledger.db.select_addresses('address', **constraints) + return [r[0] for r in rows] - def get_address_records(self, limit: int = None, max_used_times: int = None) -> defer.Deferred: - return self.ledger.db.get_addresses(self, None, limit, max_used_times) + def get_address_records(self, **constraints) -> defer.Deferred: + return self.ledger.db.get_addresses(account=self, **constraints) def get_private_key(self, chain: int, index: int) -> PrivateKey: assert not self.encrypted, "Cannot get private key on encrypted wallet account." address_manager = {0: self.receiving, 1: self.change}[chain] return address_manager.get_private_key(index) - def get_balance(self, confirmations: int = 6, **constraints): + def get_balance(self, confirmations: int = 0, **constraints): if confirmations > 0: height = self.ledger.headers.height - (confirmations-1) constraints.update({'height__lte': height, 'height__gt': 0}) - return self.ledger.db.get_balance_for_account(self, **constraints) + return self.ledger.db.get_balance(account=self, **constraints) @defer.inlineCallbacks def get_max_gap(self): @@ -356,11 +357,11 @@ class BaseAccount: 'max_receiving_gap': receiving_gap, } - def get_unspent_outputs(self, **constraints): + def get_utxos(self, **constraints): return self.ledger.db.get_utxos(account=self, **constraints) - def get_transactions(self) -> List['basetransaction.BaseTransaction']: - return self.ledger.db.get_transactions(account=self) + def get_transactions(self, **constraints) -> List['basetransaction.BaseTransaction']: + return self.ledger.db.get_transactions(account=self, **constraints) @defer.inlineCallbacks def fund(self, to_account, amount=None, everything=False, @@ -368,7 +369,7 @@ class BaseAccount: assert self.ledger == to_account.ledger, 'Can only transfer between accounts of the same ledger.' tx_class = self.ledger.transaction_class if everything: - utxos = yield self.get_unspent_outputs(**constraints) + utxos = yield self.get_utxos(**constraints) yield self.ledger.reserve_outputs(utxos) tx = yield tx_class.create( inputs=[tx_class.input_class.spend(txo) for txo in utxos], diff --git a/torba/basedatabase.py b/torba/basedatabase.py index b70be1d73..a6846b6ae 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -12,60 +12,97 @@ from torba.baseaccount import BaseAccount log = logging.getLogger(__name__) -def clean_arg_name(arg): - return arg.replace('.', '_') - - -def prepare_constraints(constraints): - if 'account' in constraints: - if isinstance(constraints['account'], BaseAccount): - constraints['account'] = constraints['account'].public_key.address - return constraints.pop('my_account', constraints.get('account')) - - -def constraints_to_sql(constraints, joiner=' AND ', prepend_sql=' AND ', prepend_key=''): - if not constraints: - return '' - extras = [] - for key in list(constraints): - col, op, constraint = key, '=', constraints.pop(key) - if key.endswith('__not'): - col, op = key[:-len('__not')], '!=' +def constraints_to_sql(constraints, joiner=' AND ', prepend_key=''): + sql, values = [], {} + for key, constraint in constraints.items(): + col, op, key = key, '=', key.replace('.', '_') + if key.startswith('$'): + values[key] = constraint + continue + elif key.endswith('__not'): + col, op = col[:-len('__not')], '!=' elif key.endswith('__lt'): - col, op = key[:-len('__lt')], '<' + col, op = col[:-len('__lt')], '<' elif key.endswith('__lte'): - col, op = key[:-len('__lte')], '<=' + col, op = col[:-len('__lte')], '<=' elif key.endswith('__gt'): - col, op = key[:-len('__gt')], '>' + col, op = col[:-len('__gt')], '>' elif key.endswith('__like'): - col, op = key[:-len('__like')], 'LIKE' + col, op = col[:-len('__like')], 'LIKE' elif key.endswith('__in') or key.endswith('__not_in'): if key.endswith('__in'): - col, op = key[:-len('__in')], 'IN' + col, op = col[:-len('__in')], 'IN' else: - col, op = key[:-len('__not_in')], 'NOT IN' + col, op = col[:-len('__not_in')], 'NOT IN' if isinstance(constraint, (list, set)): - placeholders = [] - for item_no, item in enumerate(constraint, 1): - constraints['{}_{}'.format(clean_arg_name(col), item_no)] = item - placeholders.append(':{}_{}'.format(clean_arg_name(col), item_no)) - items = ', '.join(placeholders) + items = ', '.join( + "'{}'".format(item) if isinstance(item, str) else str(item) + for item in constraint + ) elif isinstance(constraint, str): items = constraint else: - raise ValueError("{} requires a list or string as constraint value.".format(key)) - extras.append('{} {} ({})'.format(col, op, items)) + raise ValueError("{} requires a list, set or string as constraint value.".format(col)) + sql.append('{} {} ({})'.format(col, op, items)) continue elif key.endswith('__any'): - extras.append('({})'.format( - constraints_to_sql(constraint, ' OR ', '', key+'_') - )) - for subkey, val in constraint.items(): - constraints['{}_{}'.format(clean_arg_name(key), clean_arg_name(subkey))] = val + where, subvalues = constraints_to_sql(constraint, ' OR ', key+'_') + sql.append('({})'.format(where)) + values.update(subvalues) continue - constraints[clean_arg_name(key)] = constraint - extras.append('{} {} :{}'.format(col, op, prepend_key+clean_arg_name(key))) - return prepend_sql + joiner.join(extras) if extras else '' + sql.append('{} {} :{}'.format(col, op, prepend_key+key)) + values[prepend_key+key] = constraint + return joiner.join(sql) if sql else '', values + + +def query(select, **constraints): + sql = [select] + limit = constraints.pop('limit', None) + offset = constraints.pop('offset', None) + order_by = constraints.pop('order_by', None) + + constraints.pop('my_account', None) + account = constraints.pop('account', None) + if account is not None: + if not isinstance(account, list): + account = [account] + constraints['account__in'] = [ + (a.public_key.address if isinstance(a, BaseAccount) else a) for a in account + ] + + where, values = constraints_to_sql(constraints) + if where: + sql.append('WHERE') + sql.append(where) + + if order_by is not None: + sql.append('ORDER BY') + if isinstance(order_by, str): + sql.append(order_by) + elif isinstance(order_by, list): + sql.append(', '.join(order_by)) + else: + raise ValueError("order_by must be string or list") + + if offset is not None: + sql.append('OFFSET {}'.format(offset)) + + if limit is not None: + sql.append('LIMIT {}'.format(limit)) + + return ' '.join(sql), values + + +def rows_to_dict(rows, fields): + if rows: + return [dict(zip(fields, r)) for r in rows] + else: + return [] + + +def row_dict_or_default(rows, fields, default=None): + dicts = rows_to_dict(rows, fields) + return dicts[0] if dicts else default class SQLiteMixin: @@ -121,22 +158,6 @@ class SQLiteMixin: else: return default - @defer.inlineCallbacks - def query_dict_value_list(self, query, fields, params=None): - result = yield self.run_query(query.format(', '.join(fields)), params) - if result: - return [dict(zip(fields, r)) for r in result] - else: - return [] - - @defer.inlineCallbacks - def query_dict_value(self, query, fields, params=None, default=None): - result = yield self.query_dict_value_list(query, fields, params) - if result: - return result[0] - else: - return default - @staticmethod def execute(t, sql, values): log.debug(sql) @@ -232,9 +253,9 @@ class BaseDatabase(SQLiteMixin): 'height': tx.height, 'position': tx.position, 'is_verified': tx.is_verified }, 'txid = ?', (tx.id,))) - existing_txos = [r[0] for r in self.execute( - t, "SELECT position FROM txo WHERE txid = ?", (tx.id,) - ).fetchall()] + existing_txos = [r[0] for r in self.execute(t, *query( + "SELECT position FROM txo", txid=tx.id + )).fetchall()] for txo in tx.outputs: if txo.position in existing_txos: @@ -246,16 +267,14 @@ class BaseDatabase(SQLiteMixin): print('Database.save_transaction_io: pay script hash is not implemented!') # lookup the address associated with each TXI (via its TXO) - txoids = [txi.txo_ref.id for txi in tx.inputs] - txoid_place_holders = ','.join(['?']*len(txoids)) - txoid_to_address = {r[0]: r[1] for r in self.execute( - t, "SELECT txoid, address FROM txo WHERE txoid in ({})".format(txoid_place_holders), txoids - ).fetchall()} + txoid_to_address = {r[0]: r[1] for r in self.execute(t, *query( + "SELECT txoid, address FROM txo", txoid__in=[txi.txo_ref.id for txi in tx.inputs] + )).fetchall()} # list of TXIs that have already been added - existing_txis = [r[0] for r in self.execute( - t, "SELECT txoid FROM txi WHERE txid = ?", (tx.id,) - ).fetchall()] + existing_txis = [r[0] for r in self.execute(t, *query( + "SELECT txoid FROM txi", txid=tx.id + )).fetchall()] for txi in tx.inputs: txoid = txi.txo_ref.id @@ -289,39 +308,27 @@ class BaseDatabase(SQLiteMixin): # 2. update address histories removing deleted TXs return defer.succeed(True) - @defer.inlineCallbacks - def get_transaction(self, txid, account=None): - txs = yield self.get_transactions(account=account, txid=txid) - if len(txs) == 1: - return txs[0] - - @defer.inlineCallbacks - def get_transactions(self, offset=0, limit=1000000, **constraints): - my_account = prepare_constraints(constraints) - account = constraints.pop('account', None) - + def select_transactions(self, cols, account=None, **constraints): if 'txid' not in constraints and account is not None: + constraints['$account'] = account.public_key.address constraints['txid__in'] = """ SELECT txo.txid FROM txo - JOIN pubkey_address USING (address) WHERE pubkey_address.account = :account + JOIN pubkey_address USING (address) WHERE pubkey_address.account = :$account UNION SELECT txi.txid FROM txi JOIN txo USING (txoid) - JOIN pubkey_address USING (address) WHERE pubkey_address.account = :account + JOIN pubkey_address USING (address) WHERE pubkey_address.account = :$account """ + return self.run_query(*query("SELECT {} FROM tx".format(cols), **constraints)) - where = constraints_to_sql(constraints, prepend_sql='WHERE ') + @defer.inlineCallbacks + def get_transactions(self, my_account=None, **constraints): + my_account = my_account or constraints.get('account', None) - tx_rows = yield self.run_query( - """ - SELECT txid, raw, height, position, is_verified FROM tx {} - ORDER BY height DESC, position DESC LIMIT :offset, :limit - """.format(where), { - **constraints, - 'account': account, - 'offset': max(offset, 0), - 'limit': max(limit, 1) - } + tx_rows = yield self.select_transactions( + 'txid, raw, height, position, is_verified', + order_by=["height DESC", "position DESC"], + **constraints ) txids, txs = [], [] @@ -343,9 +350,7 @@ class BaseDatabase(SQLiteMixin): txo.id: txo for txo in (yield self.get_txos( my_account=my_account, - txoid__in="SELECT txoid FROM txi WHERE txi.txid IN ({})".format( - ','.join("'{}'".format(txid) for txid in txids) - ) + txoid__in=query("SELECT txoid FROM txi", **{'txid__in': txids})[0] )) } @@ -364,13 +369,28 @@ class BaseDatabase(SQLiteMixin): return txs @defer.inlineCallbacks - def get_txos(self, **constraints): - my_account = prepare_constraints(constraints) - rows = yield self.run_query( - """ - SELECT amount, script, txid, txo.position, chain, account - FROM txo JOIN pubkey_address USING (address) - """+constraints_to_sql(constraints, prepend_sql='WHERE '), constraints + def get_transaction_count(self, **constraints): + count = yield self.select_transactions('count(*)', **constraints) + return count[0][0] + + @defer.inlineCallbacks + def get_transaction(self, **constraints): + txs = yield self.get_transactions(limit=1, **constraints) + if txs: + return txs[0] + + def select_txos(self, cols, **constraints): + return self.run_query(*query( + "SELECT {} FROM txo JOIN pubkey_address USING (address)".format(cols), **constraints + )) + + @defer.inlineCallbacks + def get_txos(self, my_account=None, **constraints): + my_account = my_account or constraints.get('account', None) + if isinstance(my_account, BaseAccount): + my_account = my_account.public_key.address + rows = yield self.select_txos( + "amount, script, txid, txo.position, chain, account", **constraints ) output_class = self.ledger.transaction_class.output_class return [ @@ -384,34 +404,60 @@ class BaseDatabase(SQLiteMixin): ) for row in rows ] - def get_utxos(self, **constraints): - constraints['txoid__not_in'] = 'SELECT txoid FROM txi' + @defer.inlineCallbacks + def get_txo_count(self, **constraints): + count = yield self.select_txos('count(*)', **constraints) + return count[0][0] + + @staticmethod + def constrain_utxo(constraints): constraints['is_reserved'] = False + constraints['txoid__not_in'] = "SELECT txoid FROM txi" + + def get_utxos(self, **constraints): + self.constrain_utxo(constraints) return self.get_txos(**constraints) - def get_balance_for_account(self, account, include_reserved=False, **constraints): - if not include_reserved: - constraints['is_reserved'] = False - values = {'account': account.public_key.address} - values.update(constraints) - return self.query_one_value( - """ - SELECT SUM(amount) - FROM txo - JOIN tx ON tx.txid=txo.txid - JOIN pubkey_address ON pubkey_address.address=txo.address - WHERE - pubkey_address.account=:account AND - txoid NOT IN (SELECT txoid FROM txi) - """+constraints_to_sql(constraints), values, 0 + def get_utxos_count(self, **constraints): + self.constrain_utxo(constraints) + return self.get_txo_count(**constraints) + + @defer.inlineCallbacks + def get_balance(self, **constraints): + self.constrain_utxo(constraints) + balance = yield self.select_txos('SUM(amount)', **constraints) + return balance[0][0] or 0 + + def select_addresses(self, cols, **constraints): + return self.run_query(*query( + "SELECT {} FROM pubkey_address".format(cols), **constraints + )) + + @defer.inlineCallbacks + def get_addresses(self, cols=('address', 'account', 'chain', 'position', 'used_times'), **constraints): + addresses = yield self.select_addresses(', '.join(cols), **constraints) + return rows_to_dict(addresses, cols) + + @defer.inlineCallbacks + def get_address_count(self, **constraints): + count = yield self.select_addresses('count(*)', **constraints) + return count[0][0] + + @defer.inlineCallbacks + def get_address(self, address): + addresses = yield self.get_addresses( + cols=('address', 'account', 'chain', 'position', 'pubkey', 'history', 'used_times'), + address=address, limit=1 ) + if addresses: + return addresses[0] def add_keys(self, account, chain, keys): sql = ( - "insert into pubkey_address " - "(address, account, chain, position, pubkey) " - "values " - ) + ', '.join(['(?, ?, ?, ?, ?)'] * len(keys)) + "insert into pubkey_address " + "(address, account, chain, position, pubkey) " + "values " + ) + ', '.join(['(?, ?, ?, ?, ?)'] * len(keys)) values = [] for position, pubkey in keys: values.append(pubkey.address) @@ -430,40 +476,3 @@ class BaseDatabase(SQLiteMixin): def set_address_history(self, address, history): return self.db.runInteraction(lambda t: self._set_address_history(t, address, history)) - - def get_addresses(self, account, chain, limit=None, max_used_times=None, order_by=None): - columns = ['account', 'chain', 'position', 'address', 'used_times'] - sql = ["SELECT {} FROM pubkey_address"] - - where = [] - params = {} - if account is not None: - params["account"] = account.public_key.address - where.append("account = :account") - columns.remove("account") - if chain is not None: - params["chain"] = chain - where.append("chain = :chain") - columns.remove("chain") - if max_used_times is not None: - params["used_times"] = max_used_times - where.append("used_times <= :used_times") - - if where: - sql.append("WHERE") - sql.append(" AND ".join(where)) - - if order_by: - sql.append("ORDER BY {}".format(order_by)) - - if limit is not None: - sql.append("LIMIT {}".format(limit)) - - return self.query_dict_value_list(" ".join(sql), columns, params) - - def get_address(self, address): - return self.query_dict_value( - "SELECT {} FROM pubkey_address WHERE address = :address", - ('address', 'account', 'chain', 'position', 'pubkey', 'history', 'used_times'), - {'address': address} - ) diff --git a/torba/baseledger.py b/torba/baseledger.py index 50c00a607..a19347518 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -148,7 +148,7 @@ class BaseLedger(metaclass=LedgerRegistry): def get_effective_amount_estimators(self, funding_accounts: Iterable[baseaccount.BaseAccount]): estimators = [] for account in funding_accounts: - utxos = yield account.get_unspent_outputs() + utxos = yield account.get_utxos() for utxo in utxos: estimators.append(utxo.get_estimator(self)) return estimators @@ -330,7 +330,7 @@ class BaseLedger(metaclass=LedgerRegistry): # need to update anyways. Continue to get history and create more addresses until # all missing addresses are created and history for them is fully restored. yield account.ensure_address_gap() - addresses = yield account.get_addresses(max_used_times=0) + addresses = yield account.get_addresses(used_times=0) while addresses: yield defer.DeferredList([ self.update_history(a) for a in addresses @@ -364,7 +364,7 @@ class BaseLedger(metaclass=LedgerRegistry): try: # see if we have a local copy of transaction, otherwise fetch it from server - tx = yield self.db.get_transaction(hex_id) + tx = yield self.db.get_transaction(txid=hex_id) save_tx = None if tx is None: _raw = yield self.network.get_transaction(hex_id) From 944238d5421aa3807530eee934aa7b1885bb9199 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 7 Oct 2018 14:59:27 -0400 Subject: [PATCH 143/383] removed unused method and minor pylint fix --- torba/basedatabase.py | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index a6846b6ae..5d2aa0972 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -150,14 +150,6 @@ class SQLiteMixin: ) return sql, values - @defer.inlineCallbacks - def query_one_value(self, query, params=None, default=None): - result = yield self.run_query(query, params) - if result: - return result[0][0] or default - else: - return default - @staticmethod def execute(t, sql, values): log.debug(sql) @@ -454,10 +446,10 @@ class BaseDatabase(SQLiteMixin): def add_keys(self, account, chain, keys): sql = ( - "insert into pubkey_address " - "(address, account, chain, position, pubkey) " - "values " - ) + ', '.join(['(?, ?, ?, ?, ?)'] * len(keys)) + "insert into pubkey_address " + "(address, account, chain, position, pubkey) " + "values " + ) + ', '.join(['(?, ?, ?, ?, ?)'] * len(keys)) values = [] for position, pubkey in keys: values.append(pubkey.address) From 9cea8d27259d4c11d5116260542a53927481a635 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 7 Oct 2018 20:14:27 -0400 Subject: [PATCH 144/383] db.get_utxos_count -> db.get_utxo_count --- torba/basedatabase.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 5d2aa0972..b05c15fae 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -410,7 +410,7 @@ class BaseDatabase(SQLiteMixin): self.constrain_utxo(constraints) return self.get_txos(**constraints) - def get_utxos_count(self, **constraints): + def get_utxo_count(self, **constraints): self.constrain_utxo(constraints) return self.get_txo_count(**constraints) From 9aa22e1071b01d420d034d4efbc3bbcc90efbd65 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 8 Oct 2018 10:37:52 -0400 Subject: [PATCH 145/383] sql: pop offset/limit/order_by when doing simple count(*) query --- torba/basedatabase.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index b05c15fae..637706adc 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -362,6 +362,9 @@ class BaseDatabase(SQLiteMixin): @defer.inlineCallbacks def get_transaction_count(self, **constraints): + constraints.pop('offset', None) + constraints.pop('limit', None) + constraints.pop('order_by', None) count = yield self.select_transactions('count(*)', **constraints) return count[0][0] @@ -398,6 +401,9 @@ class BaseDatabase(SQLiteMixin): @defer.inlineCallbacks def get_txo_count(self, **constraints): + constraints.pop('offset', None) + constraints.pop('limit', None) + constraints.pop('order_by', None) count = yield self.select_txos('count(*)', **constraints) return count[0][0] From 1d84440b74d1790927813203566db66bf33946ff Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 8 Oct 2018 10:53:53 -0400 Subject: [PATCH 146/383] select_txos needs a join on tx table --- torba/basedatabase.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 637706adc..dc360af47 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -376,7 +376,9 @@ class BaseDatabase(SQLiteMixin): def select_txos(self, cols, **constraints): return self.run_query(*query( - "SELECT {} FROM txo JOIN pubkey_address USING (address)".format(cols), **constraints + "SELECT {} FROM txo" + " JOIN pubkey_address USING (address)" + " JOIN tx USING (txid)".format(cols), **constraints )) @defer.inlineCallbacks From d9c21ce37bea3659e7d5cc2c6358de7b7789eaa9 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 8 Oct 2018 14:53:57 -0400 Subject: [PATCH 147/383] v0.0.8 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index c5362f6e8..797f4c1b5 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.0.7' +__version__ = '0.0.8' From 9c4dfa7f84bb60c42f4e79c253fd5f7070ba5487 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Mon, 8 Oct 2018 18:04:56 -0300 Subject: [PATCH 148/383] attach subscriptions to on_connected and stop service before discarding the object --- torba/baseledger.py | 5 +++++ torba/basenetwork.py | 2 ++ 2 files changed, 7 insertions(+) diff --git a/torba/baseledger.py b/torba/baseledger.py index a19347518..692610668 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -223,8 +223,13 @@ class BaseLedger(metaclass=LedgerRegistry): self.headers.open() ]) first_connection = self.network.on_connected.first + self.network.on_connected.listen(self.join_network) self.network.start() yield first_connection + + @defer.inlineCallbacks + def join_network(self, *args): + log.info("Subscribing and updating accounts.") yield self.update_headers() yield self.network.subscribe_headers() yield self.update_accounts() diff --git a/torba/basenetwork.py b/torba/basenetwork.py index dc1397a64..eec68577d 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -167,6 +167,8 @@ class BaseNetwork: log.exception("Connecting to %s raised an exception:", connection_string) finally: self.client = None + if self.service is not None: + self.service.stopService() if not self.running: return From 3a264c1eecb7b50dcff7debafb045586706bc1e6 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 8 Oct 2018 18:50:45 -0400 Subject: [PATCH 149/383] drop ledger.get_transaction() in favor of just using ledger.db.get_transaction() directly --- torba/baseledger.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index 692610668..8eb888264 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -133,9 +133,6 @@ class BaseLedger(metaclass=LedgerRegistry): def add_account(self, account: baseaccount.BaseAccount): self.accounts.append(account) - def get_transaction(self, txhash): - return self.db.get_transaction(txhash) - @defer.inlineCallbacks def get_private_key_for_address(self, address): match = yield self.db.get_address(address) From eebfe2be086b0aea6f143cdd9e9efae9132f5e05 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 8 Oct 2018 22:44:30 -0400 Subject: [PATCH 150/383] get_address fix --- torba/basedatabase.py | 6 +++--- torba/baseledger.py | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index dc360af47..ae2f48ce8 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -327,7 +327,7 @@ class BaseDatabase(SQLiteMixin): for row in tx_rows: txids.append(row[0]) txs.append(self.ledger.transaction_class( - raw=row[1], height=row[2], position=row[3], is_verified=row[4] + raw=row[1], height=row[2], position=row[3], is_verified=bool(row[4]) )) annotated_txos = { @@ -444,10 +444,10 @@ class BaseDatabase(SQLiteMixin): return count[0][0] @defer.inlineCallbacks - def get_address(self, address): + def get_address(self, **constraints): addresses = yield self.get_addresses( cols=('address', 'account', 'chain', 'position', 'pubkey', 'history', 'used_times'), - address=address, limit=1 + limit=1, **constraints ) if addresses: return addresses[0] diff --git a/torba/baseledger.py b/torba/baseledger.py index 8eb888264..d5e2af3e4 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -177,14 +177,14 @@ class BaseLedger(metaclass=LedgerRegistry): @defer.inlineCallbacks def get_local_status(self, address): - address_details = yield self.db.get_address(address) + address_details = yield self.db.get_address(address=address) history = address_details['history'] or '' h = sha256(history.encode()) return hexlify(h) @defer.inlineCallbacks def get_local_history(self, address): - address_details = yield self.db.get_address(address) + address_details = yield self.db.get_address(address=address) history = address_details['history'] or '' parts = history.split(':')[:-1] return list(zip(parts[0::2], map(int, parts[1::2]))) From 75dd93436c84e1e0712a0cca45d43ad13e0171f6 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 8 Oct 2018 22:49:50 -0400 Subject: [PATCH 151/383] more get_address fixes --- torba/baseledger.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index d5e2af3e4..49b06ab77 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -135,7 +135,7 @@ class BaseLedger(metaclass=LedgerRegistry): @defer.inlineCallbacks def get_private_key_for_address(self, address): - match = yield self.db.get_address(address) + match = yield self.db.get_address(address=address) if match: for account in self.accounts: if match['account'] == account.public_key.address: From 462fd8bad1ed0e7f93675d3c68df5af42e69b6f9 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 8 Oct 2018 23:26:11 -0400 Subject: [PATCH 152/383] get_address test fixes --- tests/unit/test_ledger.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index 7a8baa5f6..fa9b8f10c 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -73,7 +73,7 @@ class TestSynchronization(LedgerTestCase): def test_update_history(self): account = self.ledger.account_class.generate(self.ledger, Wallet(), "torba") address = yield account.receiving.get_or_create_usable_address() - address_details = yield self.ledger.db.get_address(address) + address_details = yield self.ledger.db.get_address(address=address) self.assertEqual(address_details['history'], None) self.add_header(block_height=0, merkle_root=b'abcd04') @@ -93,7 +93,7 @@ class TestSynchronization(LedgerTestCase): self.assertEqual(self.ledger.network.get_history_called, [address]) self.assertEqual(self.ledger.network.get_transaction_called, ['abcd01', 'abcd02', 'abcd03']) - address_details = yield self.ledger.db.get_address(address) + address_details = yield self.ledger.db.get_address(address=address) self.assertEqual(address_details['history'], 'abcd01:0:abcd02:1:abcd03:2:') self.ledger.network.get_history_called = [] @@ -109,7 +109,7 @@ class TestSynchronization(LedgerTestCase): yield self.ledger.update_history(address) self.assertEqual(self.ledger.network.get_history_called, [address]) self.assertEqual(self.ledger.network.get_transaction_called, ['abcd04']) - address_details = yield self.ledger.db.get_address(address) + address_details = yield self.ledger.db.get_address(address=address) self.assertEqual(address_details['history'], 'abcd01:0:abcd02:1:abcd03:2:abcd04:3:') From d02da2f3a543b3a83b441d71dff8ee3e6ef82d88 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 8 Oct 2018 23:26:45 -0400 Subject: [PATCH 153/383] fix test method name to make sure it gets run --- tests/unit/test_utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/unit/test_utils.py b/tests/unit/test_utils.py index 565f11bed..d46c9d5d9 100644 --- a/tests/unit/test_utils.py +++ b/tests/unit/test_utils.py @@ -1,11 +1,11 @@ -import unittest +from twisted.trial import unittest from torba.util import ArithUint256 class TestArithUint256(unittest.TestCase): - def test(self): + def test_arithunit256(self): # https://github.com/bitcoin/bitcoin/blob/master/src/test/arith_uint256_tests.cpp from_compact = ArithUint256.from_compact From 2723a55766e2f1a2fdf3e0f2015e8f2134902fc3 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 8 Oct 2018 23:27:32 -0400 Subject: [PATCH 154/383] start() should not return until ledger has finished starting, which means self.join_network() needs to be yielded on the first connection --- torba/baseledger.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index 49b06ab77..b8c218b05 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -220,9 +220,10 @@ class BaseLedger(metaclass=LedgerRegistry): self.headers.open() ]) first_connection = self.network.on_connected.first - self.network.on_connected.listen(self.join_network) self.network.start() yield first_connection + yield self.join_network() + self.network.on_connected.listen(self.join_network) @defer.inlineCallbacks def join_network(self, *args): From 689c578081a8a2c719d73c381fd51e009a18aad7 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 9 Oct 2018 13:13:46 -0400 Subject: [PATCH 155/383] get_or_create_usable_address returns a random choice when returning an existing unused address --- torba/baseaccount.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index b2c5fb8d7..f332d7a93 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -1,3 +1,4 @@ +import random import typing from typing import List, Dict, Tuple, Type, Optional, Any from twisted.internet import defer @@ -73,9 +74,9 @@ class AddressManager: @defer.inlineCallbacks def get_or_create_usable_address(self) -> defer.Deferred: - addresses = yield self.get_addresses(only_usable=True, limit=1) + addresses = yield self.get_addresses(only_usable=True, limit=10) if addresses: - return addresses[0] + return random.choice(addresses) addresses = yield self.ensure_address_gap() return addresses[0] From c60e17b34172e482c8e96a7cbe7cb1db687799e3 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 9 Oct 2018 14:44:26 -0400 Subject: [PATCH 156/383] fix LIMIT OFFSET syntax error --- torba/basedatabase.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index ae2f48ce8..674b10ebc 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -84,12 +84,12 @@ def query(select, **constraints): else: raise ValueError("order_by must be string or list") - if offset is not None: - sql.append('OFFSET {}'.format(offset)) - if limit is not None: sql.append('LIMIT {}'.format(limit)) + if offset is not None: + sql.append('OFFSET {}'.format(offset)) + return ' '.join(sql), values From 3ed03c267af0bce379c5fc048e1be851ffbe7e59 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 9 Oct 2018 14:44:49 -0400 Subject: [PATCH 157/383] v0.0.9 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 797f4c1b5..a872644df 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.0.8' +__version__ = '0.0.9' From 6a97f96745a9a6c449315849256d31e0e851165f Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 9 Oct 2018 16:49:37 -0400 Subject: [PATCH 158/383] fixed database unit test --- tests/unit/test_database.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/test_database.py b/tests/unit/test_database.py index 231480610..9c3409d8b 100644 --- a/tests/unit/test_database.py +++ b/tests/unit/test_database.py @@ -96,7 +96,7 @@ class TestQueryBuilder(unittest.TestCase): ) self.assertEqual( query("select * from foo", limit=20, offset=10), - ("select * from foo OFFSET 10 LIMIT 20", {}) + ("select * from foo LIMIT 20 OFFSET 10", {}) ) From 4aea68ecd1718a7442e9a04e4c779f3a833b84bd Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 9 Oct 2018 19:29:20 -0400 Subject: [PATCH 159/383] + account.get_*_count() methods --- torba/baseaccount.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index f332d7a93..7f5bd106c 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -338,6 +338,9 @@ class BaseAccount: def get_address_records(self, **constraints) -> defer.Deferred: return self.ledger.db.get_addresses(account=self, **constraints) + def get_address_count(self, **constraints) -> defer.Deferred: + return self.ledger.db.get_address_count(account=self, **constraints) + def get_private_key(self, chain: int, index: int) -> PrivateKey: assert not self.encrypted, "Cannot get private key on encrypted wallet account." address_manager = {0: self.receiving, 1: self.change}[chain] @@ -361,9 +364,15 @@ class BaseAccount: def get_utxos(self, **constraints): return self.ledger.db.get_utxos(account=self, **constraints) + def get_utxo_count(self, **constraints): + return self.ledger.db.get_utxo_count(account=self, **constraints) + def get_transactions(self, **constraints) -> List['basetransaction.BaseTransaction']: return self.ledger.db.get_transactions(account=self, **constraints) + def get_transaction_count(self, **constraints): + return self.ledger.db.get_transaction_count(account=self, **constraints) + @defer.inlineCallbacks def fund(self, to_account, amount=None, everything=False, outputs=1, broadcast=False, **constraints): From febadc5dd6a7a2da87760b5da6a3ce53b625277a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 9 Oct 2018 20:36:58 -0400 Subject: [PATCH 160/383] fix get_addresses where it was returned all addresses instead of for specific account --- torba/baseaccount.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 7f5bd106c..6f1c90bf6 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -332,7 +332,7 @@ class BaseAccount: @defer.inlineCallbacks def get_addresses(self, **constraints) -> defer.Deferred: - rows = yield self.ledger.db.select_addresses('address', **constraints) + rows = yield self.ledger.db.select_addresses('address', account=self, **constraints) return [r[0] for r in rows] def get_address_records(self, **constraints) -> defer.Deferred: From e37da81dc619b934a7cdbb28fd9dfaf69ad78722 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 9 Oct 2018 22:52:43 -0400 Subject: [PATCH 161/383] added database indexes --- torba/basedatabase.py | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 674b10ebc..8d92a8f11 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -180,6 +180,9 @@ class BaseDatabase(SQLiteMixin): used_times integer not null default 0 ); """ + CREATE_PUBKEY_ADDRESS_INDEX = """ + create index if not exists pubkey_address_account_idx on pubkey_address (account); + """ CREATE_TX_TABLE = """ create table if not exists tx ( @@ -202,6 +205,9 @@ class BaseDatabase(SQLiteMixin): is_reserved boolean not null default 0 ); """ + CREATE_TXO_INDEX = """ + create index if not exists txo_address_idx on txo (address); + """ CREATE_TXI_TABLE = """ create table if not exists txi ( @@ -210,12 +216,18 @@ class BaseDatabase(SQLiteMixin): address text references pubkey_address ); """ + CREATE_TXI_INDEX = """ + create index if not exists txi_address_idx on txi (address); + """ CREATE_TABLES_QUERY = ( CREATE_TX_TABLE + CREATE_PUBKEY_ADDRESS_TABLE + + CREATE_PUBKEY_ADDRESS_INDEX + CREATE_TXO_TABLE + - CREATE_TXI_TABLE + CREATE_TXO_INDEX + + CREATE_TXI_TABLE + + CREATE_TXI_INDEX ) @staticmethod @@ -308,7 +320,6 @@ class BaseDatabase(SQLiteMixin): JOIN pubkey_address USING (address) WHERE pubkey_address.account = :$account UNION SELECT txi.txid FROM txi - JOIN txo USING (txoid) JOIN pubkey_address USING (address) WHERE pubkey_address.account = :$account """ return self.run_query(*query("SELECT {} FROM tx".format(cols), **constraints)) From 7f094053352250165a88b35bc0f0ca0bc076d245 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 9 Oct 2018 23:39:00 -0400 Subject: [PATCH 162/383] txi (txoid) index added --- torba/basedatabase.py | 1 + 1 file changed, 1 insertion(+) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 8d92a8f11..03b353f40 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -218,6 +218,7 @@ class BaseDatabase(SQLiteMixin): """ CREATE_TXI_INDEX = """ create index if not exists txi_address_idx on txi (address); + create index if not exists txi_txoid_idx on txi (txoid); """ CREATE_TABLES_QUERY = ( From d4f964ef8e6de11372eb2aeae961ca3226fc6e13 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 9 Oct 2018 23:57:41 -0400 Subject: [PATCH 163/383] short circuit adding annotations when get_transaction does not return anything --- torba/basedatabase.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 03b353f40..cdbfe08ce 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -335,6 +335,9 @@ class BaseDatabase(SQLiteMixin): **constraints ) + if not tx_rows: + return [] + txids, txs = [], [] for row in tx_rows: txids.append(row[0]) From 64a626cbb56164eaeb0a0530bad5258445c984b1 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 9 Oct 2018 23:59:57 -0400 Subject: [PATCH 164/383] v0.1.0 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index a872644df..2b36b5a11 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.0.9' +__version__ = '0.1.0' From b23481bd21eccc6f1d836b0652ac03f0e7f987b6 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 10 Oct 2018 21:29:29 -0400 Subject: [PATCH 165/383] add height to TXRef --- torba/basedatabase.py | 10 +++++----- torba/basetransaction.py | 4 ++++ torba/hash.py | 16 +++++++++++++--- 3 files changed, 22 insertions(+), 8 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index cdbfe08ce..4a9422a04 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -402,17 +402,17 @@ class BaseDatabase(SQLiteMixin): if isinstance(my_account, BaseAccount): my_account = my_account.public_key.address rows = yield self.select_txos( - "amount, script, txid, txo.position, chain, account", **constraints + "amount, script, txid, tx.height, txo.position, chain, account", **constraints ) output_class = self.ledger.transaction_class.output_class return [ output_class( amount=row[0], script=output_class.script_class(row[1]), - tx_ref=TXRefImmutable.from_id(row[2]), - position=row[3], - is_change=row[4] == 1, - is_my_account=row[5] == my_account + tx_ref=TXRefImmutable.from_id(row[2], row[3]), + position=row[4], + is_change=row[5] == 1, + is_my_account=row[6] == my_account ) for row in rows ] diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 745e0c2f4..0a4609d73 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -39,6 +39,10 @@ class TXRefMutable(TXRef): self._hash = sha256(sha256(self.tx.raw)) return self._hash + @property + def height(self): + return self.tx.height + def reset(self): self._id = None self._hash = None diff --git a/torba/hash.py b/torba/hash.py index 656dec2a6..bd641b03f 100644 --- a/torba/hash.py +++ b/torba/hash.py @@ -38,6 +38,10 @@ class TXRef: def hash(self): return self._hash + @property + def height(self): + return -1 + @property def is_null(self): return self.hash == NULL_HASH32 @@ -45,22 +49,28 @@ class TXRef: class TXRefImmutable(TXRef): - __slots__ = () + __slots__ = '_height', @classmethod - def from_hash(cls, tx_hash): # type: (bytes) -> TXRefImmutable + def from_hash(cls, tx_hash: bytes, height: int) -> 'TXRefImmutable': ref = cls() ref._hash = tx_hash ref._id = hexlify(tx_hash[::-1]).decode() + ref._height = height return ref @classmethod - def from_id(cls, tx_id): # type: (str) -> TXRefImmutable + def from_id(cls, tx_id: str, height: int) -> 'TXRefImmutable': ref = cls() ref._id = tx_id ref._hash = unhexlify(tx_id)[::-1] + ref._height = height return ref + @property + def height(self): + return self._height + def sha256(x): """ Simple wrapper of hashlib sha256. """ From c6f2d8b6fc0df58a5f758849e8adaf9f2936123d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 10 Oct 2018 21:39:36 -0400 Subject: [PATCH 166/383] fix pylint --- torba/basetransaction.py | 2 +- torba/hash.py | 6 +++++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 0a4609d73..a5fa2fce1 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -150,7 +150,7 @@ class BaseInput(InputOutput): @classmethod def deserialize_from(cls, stream): - tx_ref = TXRefImmutable.from_hash(stream.read(32)) + tx_ref = TXRefImmutable.from_hash(stream.read(32), -1) position = stream.read_uint32() script = stream.read_string() sequence = stream.read_uint32() diff --git a/torba/hash.py b/torba/hash.py index bd641b03f..049cde243 100644 --- a/torba/hash.py +++ b/torba/hash.py @@ -49,7 +49,11 @@ class TXRef: class TXRefImmutable(TXRef): - __slots__ = '_height', + __slots__ = ('_height',) + + def __init__(self): + super().__init__() + self._height = -1 @classmethod def from_hash(cls, tx_hash: bytes, height: int) -> 'TXRefImmutable': From 4b9c3e8409ad1544a4062f3906f143f82e87cd56 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 10 Oct 2018 17:21:38 -0300 Subject: [PATCH 167/383] generate keys in batches of 2000s --- torba/baseaccount.py | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 6f1c90bf6..cd6b97b5a 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -108,13 +108,22 @@ class HierarchicalDeterministic(AddressManager): @defer.inlineCallbacks def generate_keys(self, start: int, end: int) -> defer.Deferred: - new_keys = [] + keys_batch, final_keys = [], [] for index in range(start, end+1): - new_keys.append((index, self.public_key.child(index))) - yield self.db.add_keys( - self.account, self.chain_number, new_keys - ) - return [key[1].address for key in new_keys] + keys_batch.append((index, self.public_key.child(index))) + if len(keys_batch) % 2000 == 0: + yield self.db.add_keys( + self.account, self.chain_number, keys_batch + ) + final_keys.extend(keys_batch) + keys_batch.clear() + if keys_batch: + yield self.db.add_keys( + self.account, self.chain_number, keys_batch + ) + final_keys.extend(keys_batch) + keys_batch.clear() + return [key[1].address for key in final_keys] @defer.inlineCallbacks def get_max_gap(self) -> defer.Deferred: From 87c210952b1521914096e82762dd40cfffb08379 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 10 Oct 2018 17:23:50 -0300 Subject: [PATCH 168/383] enable WAL --- torba/basedatabase.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 4a9422a04..a2aa91ccb 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -221,7 +221,12 @@ class BaseDatabase(SQLiteMixin): create index if not exists txi_txoid_idx on txi (txoid); """ + PRAGMAS = """ + pragma journal_mode=WAL; + """ + CREATE_TABLES_QUERY = ( + PRAGMAS + CREATE_TX_TABLE + CREATE_PUBKEY_ADDRESS_TABLE + CREATE_PUBKEY_ADDRESS_INDEX + From 6bdd9c9d78556a0e88aee18251e59966315de703 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 10 Oct 2018 17:24:24 -0300 Subject: [PATCH 169/383] optimize insert key loop --- torba/basedatabase.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index a2aa91ccb..d47b05173 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -480,11 +480,10 @@ class BaseDatabase(SQLiteMixin): ) + ', '.join(['(?, ?, ?, ?, ?)'] * len(keys)) values = [] for position, pubkey in keys: - values.append(pubkey.address) - values.append(account.public_key.address) - values.append(chain) - values.append(position) - values.append(sqlite3.Binary(pubkey.pubkey_bytes)) + values.extend([ + pubkey.address, account.public_key.address, chain, position, + sqlite3.Binary(pubkey.pubkey_bytes) + ]) return self.run_operation(sql, values) @classmethod From b19fd8ed85a23d2b97c7c78f8625423cea136b7e Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 10 Oct 2018 19:07:36 -0300 Subject: [PATCH 170/383] lower batch size so it works on restricted platforms Windows and maybe some other platforms have a lower limit on sqlite variables. --- torba/baseaccount.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index cd6b97b5a..a8616b650 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -111,7 +111,7 @@ class HierarchicalDeterministic(AddressManager): keys_batch, final_keys = [], [] for index in range(start, end+1): keys_batch.append((index, self.public_key.child(index))) - if len(keys_batch) % 2000 == 0: + if len(keys_batch) % 180 == 0: yield self.db.add_keys( self.account, self.chain_number, keys_batch ) From 52b7bb0fce9f5a72c2acb1d264f6d039929b1f05 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 10 Oct 2018 20:47:11 -0300 Subject: [PATCH 171/383] add test for checking db records when generating keys above the batch threshold --- tests/unit/test_account.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index 912c3bbce..2e840c20b 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -42,6 +42,12 @@ class TestHierarchicalDeterministicAccount(unittest.TestCase): addresses = yield account.get_addresses() self.assertEqual(len(addresses), 26) + @defer.inlineCallbacks + def test_generate_keys_over_batch_threshold_saves_it_properly(self): + yield self.account.receiving.generate_keys(0, 200) + records = yield self.account.receiving.get_address_records() + self.assertEqual(201, len(records)) + @defer.inlineCallbacks def test_ensure_address_gap(self): account = self.account From 55f5c7491c7fa04a522e293f3059e410866ade6c Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Thu, 11 Oct 2018 00:51:00 -0300 Subject: [PATCH 172/383] fixes from review for readability --- torba/baseaccount.py | 8 +------- torba/basedatabase.py | 12 ++++++------ 2 files changed, 7 insertions(+), 13 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index a8616b650..fe35d9b37 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -111,18 +111,12 @@ class HierarchicalDeterministic(AddressManager): keys_batch, final_keys = [], [] for index in range(start, end+1): keys_batch.append((index, self.public_key.child(index))) - if len(keys_batch) % 180 == 0: + if index % 180 == 0 or index == end: yield self.db.add_keys( self.account, self.chain_number, keys_batch ) final_keys.extend(keys_batch) keys_batch.clear() - if keys_batch: - yield self.db.add_keys( - self.account, self.chain_number, keys_batch - ) - final_keys.extend(keys_batch) - keys_batch.clear() return [key[1].address for key in final_keys] @defer.inlineCallbacks diff --git a/torba/basedatabase.py b/torba/basedatabase.py index d47b05173..186c98d56 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -169,6 +169,10 @@ class SQLiteMixin: class BaseDatabase(SQLiteMixin): + PRAGMAS = """ + pragma journal_mode=WAL; + """ + CREATE_PUBKEY_ADDRESS_TABLE = """ create table if not exists pubkey_address ( address text primary key, @@ -221,10 +225,6 @@ class BaseDatabase(SQLiteMixin): create index if not exists txi_txoid_idx on txi (txoid); """ - PRAGMAS = """ - pragma journal_mode=WAL; - """ - CREATE_TABLES_QUERY = ( PRAGMAS + CREATE_TX_TABLE + @@ -480,10 +480,10 @@ class BaseDatabase(SQLiteMixin): ) + ', '.join(['(?, ?, ?, ?, ?)'] * len(keys)) values = [] for position, pubkey in keys: - values.extend([ + values.extend(( pubkey.address, account.public_key.address, chain, position, sqlite3.Binary(pubkey.pubkey_bytes) - ]) + )) return self.run_operation(sql, values) @classmethod From b999abb9ea7e0a60a6ce0392fd997975fb49008c Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 10 Oct 2018 15:45:14 -0300 Subject: [PATCH 173/383] improve request cancelling and timeouts during switches --- torba/basenetwork.py | 10 ++++++++++ torba/constants.py | 2 ++ 2 files changed, 12 insertions(+) diff --git a/torba/basenetwork.py b/torba/basenetwork.py index eec68577d..452386120 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -6,9 +6,11 @@ from twisted.internet import defer, reactor, protocol from twisted.application.internet import ClientService, CancelledError from twisted.internet.endpoints import clientFromString from twisted.protocols.basic import LineOnlyReceiver +from twisted.python import failure from torba import __version__ from torba.stream import StreamController +from torba.constants import TIMEOUT log = logging.getLogger(__name__) @@ -69,7 +71,11 @@ class StratumClientProtocol(LineOnlyReceiver): log.warning("Error setting up socket: %s", err) def connectionLost(self, reason=None): + self.connected = 0 self.on_disconnected_controller.add(True) + for deferred in self.lookup_table.values(): + if not deferred.called: + deferred.errback(TimeoutError("Connection dropped.")) def lineReceived(self, line): log.debug('received: %s', line) @@ -105,6 +111,10 @@ class StratumClientProtocol(LineOnlyReceiver): log.debug('sent: %s', message) self.sendLine(message.encode('latin-1')) d = self.lookup_table[message_id] = defer.Deferred() + d.addTimeout( + TIMEOUT, reactor, onTimeoutCancel=lambda *_: failure.Failure(TimeoutError( + "Timeout: Stratum request for '%s' took more than %s seconds" % (method, TIMEOUT))) + ) return d diff --git a/torba/constants.py b/torba/constants.py index c1497ac19..6c790f02c 100644 --- a/torba/constants.py +++ b/torba/constants.py @@ -2,3 +2,5 @@ NULL_HASH32 = b'\x00'*32 CENT = 1000000 COIN = 100*CENT + +TIMEOUT = 30.0 From 36ad834d4342709671a6b9580df7033794623285 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Thu, 11 Oct 2018 00:07:38 -0300 Subject: [PATCH 174/383] add reconnection test --- tests/integration/test_reconnect.py | 33 +++++++++++++++++++++++++++++ tox.ini | 1 + 2 files changed, 34 insertions(+) create mode 100644 tests/integration/test_reconnect.py diff --git a/tests/integration/test_reconnect.py b/tests/integration/test_reconnect.py new file mode 100644 index 000000000..bb8c9b8ac --- /dev/null +++ b/tests/integration/test_reconnect.py @@ -0,0 +1,33 @@ +import asyncio +from orchstr8.testcase import IntegrationTestCase, d2f +from torba.constants import COIN + + +class ReconnectTests(IntegrationTestCase): + + VERBOSE = False + + async def test_connection_drop_still_receives_events_after_reconnected(self): + address1 = await d2f(self.account.receiving.get_or_create_usable_address()) + self.ledger.network.client.connectionLost() + sendtxid = await self.blockchain.send_to_address(address1, 1.1337) + await self.on_transaction_id(sendtxid) # mempool + await self.blockchain.generate(1) + await self.on_transaction_id(sendtxid) # confirmed + + self.assertEqual(round(await self.get_balance(self.account)/COIN, 4), 1.1337) + # is it real? are we rich!? let me see this tx... + d = self.ledger.network.get_transaction(sendtxid) + # what's that smoke on my ethernet cable? oh no! + self.ledger.network.client.connectionLost() + with self.assertRaisesRegex(TimeoutError, 'Connection dropped'): + await d2f(d) + # rich but offline? no way, no water, let's retry + with self.assertRaisesRegex(ConnectionError, 'connection is not available'): + await d2f(self.ledger.network.get_transaction(sendtxid)) + # * goes to pick some water outside... * time passes by and another donation comes in + sendtxid = await self.blockchain.send_to_address(address1, 42) + await self.blockchain.generate(1) + # omg, the burned cable still works! torba is fire proof! + await d2f(self.ledger.network.get_transaction(sendtxid)) + diff --git a/tox.ini b/tox.ini index e17f52069..ef05764eb 100644 --- a/tox.ini +++ b/tox.ini @@ -20,5 +20,6 @@ commands = unit: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial unit integration: orchstr8 download integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_transactions + integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_reconnect # Too slow on Travis # integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_blockchain_reorganization From cab89817161985f208b2e7d2421f0d4d40c7f9b4 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 10 Oct 2018 17:55:40 -0300 Subject: [PATCH 175/383] avoid reconstructing the history during loop --- torba/baseledger.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index b8c218b05..1b623336a 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -1,6 +1,8 @@ import os import logging from binascii import hexlify, unhexlify +from io import StringIO + from typing import Dict, Type, Iterable from operator import itemgetter from collections import namedtuple @@ -352,10 +354,10 @@ class BaseLedger(metaclass=LedgerRegistry): remote_history = yield self.network.get_history(address) local_history = yield self.get_local_history(address) - synced_history = [] + synced_history = StringIO() for i, (hex_id, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): - synced_history.append((hex_id, remote_height)) + synced_history.write('{}:{}:'.format(hex_id, remote_height)) if i < len(local_history) and local_history[i] == (hex_id, remote_height): continue @@ -383,7 +385,7 @@ class BaseLedger(metaclass=LedgerRegistry): yield self.db.save_transaction_io( save_tx, tx, address, self.address_to_hash160(address), - ''.join('{}:{}:'.format(tx_id, tx_height) for tx_id, tx_height in synced_history) + synced_history.getvalue() ) log.debug( From 7bdcaa6737b83e071b56f3e33ff6505e05d56ade Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 10 Oct 2018 18:59:12 -0300 Subject: [PATCH 176/383] sync: fetch proofs and txs in batches --- tests/unit/test_ledger.py | 2 +- torba/baseledger.py | 17 ++++++++++++----- 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index fa9b8f10c..771ab1426 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -24,7 +24,7 @@ class MockNetwork: return defer.succeed(self.history) def get_merkle(self, txid, height): - return {'merkle': ['abcd01'], 'pos': 1} + return defer.succeed({'merkle': ['abcd01'], 'pos': 1}) def get_transaction(self, tx_hash): self.get_transaction_called.append(tx_hash) diff --git a/torba/baseledger.py b/torba/baseledger.py index 1b623336a..921fba232 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -203,11 +203,9 @@ class BaseLedger(metaclass=LedgerRegistry): working_branch = double_sha256(combined) return hexlify(working_branch[::-1]) - @defer.inlineCallbacks - def validate_transaction_and_set_position(self, tx, height): + def validate_transaction_and_set_position(self, tx, height, merkle): if not height <= len(self.headers): return False - merkle = yield self.network.get_merkle(tx.id, height) merkle_root = self.get_root_of_merkle_tree(merkle['merkle'], merkle['pos'], tx.hash) header = self.headers[height] tx.position = merkle['pos'] @@ -353,6 +351,15 @@ class BaseLedger(metaclass=LedgerRegistry): def update_history(self, address): remote_history = yield self.network.get_history(address) local_history = yield self.get_local_history(address) + proofs = { + entry['tx_hash']: self.network.get_merkle(entry['tx_hash'], entry['height']) + for index, entry in enumerate(remote_history) + if index >= len(local_history) or (entry['tx_hash'], entry['height']) != local_history[index] + } + network_txs = {key: self.network.get_transaction(key) for key in proofs.keys()} + yield defer.DeferredList(list(proofs.values()) + list(network_txs.values())) + proofs = {key: value.result for key, value in proofs.items()} + network_txs = {key: value.result for key, value in network_txs.items()} synced_history = StringIO() for i, (hex_id, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): @@ -372,14 +379,14 @@ class BaseLedger(metaclass=LedgerRegistry): tx = yield self.db.get_transaction(txid=hex_id) save_tx = None if tx is None: - _raw = yield self.network.get_transaction(hex_id) + _raw = network_txs[hex_id] tx = self.transaction_class(unhexlify(_raw)) save_tx = 'insert' tx.height = remote_height if remote_height > 0 and (not tx.is_verified or tx.position == -1): - yield self.validate_transaction_and_set_position(tx, remote_height) + self.validate_transaction_and_set_position(tx, remote_height, proofs[hex_id]) if save_tx is None: save_tx = 'update' From 44b1178cfe39e6fd85c80cc4457f8ffead422db2 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 10 Oct 2018 20:34:53 -0300 Subject: [PATCH 177/383] fix prefetch proofs for unconfirmed and separate prefetch logic --- torba/baseledger.py | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index 921fba232..beb4e51a2 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -348,18 +348,25 @@ class BaseLedger(metaclass=LedgerRegistry): ) @defer.inlineCallbacks - def update_history(self, address): - remote_history = yield self.network.get_history(address) - local_history = yield self.get_local_history(address) + def _prefetch_history(self, remote_history, local_history): proofs = { - entry['tx_hash']: self.network.get_merkle(entry['tx_hash'], entry['height']) + entry['tx_hash']: ( + self.network.get_merkle(entry['tx_hash'], entry['height']) if entry['height'] > 0 else None + ) for index, entry in enumerate(remote_history) if index >= len(local_history) or (entry['tx_hash'], entry['height']) != local_history[index] } network_txs = {key: self.network.get_transaction(key) for key in proofs.keys()} - yield defer.DeferredList(list(proofs.values()) + list(network_txs.values())) - proofs = {key: value.result for key, value in proofs.items()} + yield defer.DeferredList(list(filter(None, proofs.values())) + list(network_txs.values())) + proofs = {key: value.result for key, value in proofs.items() if value} network_txs = {key: value.result for key, value in network_txs.items()} + return proofs, network_txs + + @defer.inlineCallbacks + def update_history(self, address): + remote_history = yield self.network.get_history(address) + local_history = yield self.get_local_history(address) + proofs, network_txs = yield self._prefetch_history(remote_history, local_history) synced_history = StringIO() for i, (hex_id, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): From 0ce4b9a7de9c7b20c364cbf19d9d29584fe268ea Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Thu, 11 Oct 2018 02:54:02 -0300 Subject: [PATCH 178/383] tentatively refactor prefetch --- torba/baseledger.py | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index beb4e51a2..ab99bd3ca 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -349,17 +349,20 @@ class BaseLedger(metaclass=LedgerRegistry): @defer.inlineCallbacks def _prefetch_history(self, remote_history, local_history): - proofs = { - entry['tx_hash']: ( - self.network.get_merkle(entry['tx_hash'], entry['height']) if entry['height'] > 0 else None + proofs, network_txs, deferreds = {}, {}, [] + for i, (hex_id, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): + if i < len(local_history) and local_history[i] == (hex_id, remote_height): + continue + if remote_height > 0: + deferreds.append( + self.network.get_merkle(hex_id, remote_height).addBoth( + lambda result, txid: proofs.__setitem__(txid, result), hex_id) + ) + deferreds.append( + self.network.get_transaction(hex_id).addBoth( + lambda result, txid: network_txs.__setitem__(txid, result), hex_id) ) - for index, entry in enumerate(remote_history) - if index >= len(local_history) or (entry['tx_hash'], entry['height']) != local_history[index] - } - network_txs = {key: self.network.get_transaction(key) for key in proofs.keys()} - yield defer.DeferredList(list(filter(None, proofs.values())) + list(network_txs.values())) - proofs = {key: value.result for key, value in proofs.items() if value} - network_txs = {key: value.result for key, value in network_txs.items()} + yield defer.DeferredList(deferreds) return proofs, network_txs @defer.inlineCallbacks From 2c5fd4aade53d07888e8a090a28029024e4a88db Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 14 Oct 2018 22:16:51 -0400 Subject: [PATCH 179/383] twisted -> asyncio --- tests/integration/test_transactions.py | 20 +-- tests/unit/test_account.py | 169 ++++++++++--------- tests/unit/test_bcd_data_stream.py | 2 +- tests/unit/test_bip32.py | 2 +- tests/unit/test_coinselection.py | 2 +- tests/unit/test_database.py | 65 ++++---- tests/unit/test_hash.py | 7 +- tests/unit/test_headers.py | 23 ++- tests/unit/test_ledger.py | 56 +++---- tests/unit/test_script.py | 2 +- tests/unit/test_transaction.py | 68 ++++---- tests/unit/test_utils.py | 2 +- tests/unit/test_wallet.py | 2 +- torba/baseaccount.py | 98 +++++------ torba/basedatabase.py | 214 ++++++++++++------------- torba/baseheader.py | 26 ++- torba/baseledger.py | 185 ++++++++------------- torba/basemanager.py | 21 ++- torba/basenetwork.py | 174 +++----------------- torba/basetransaction.py | 20 +-- torba/stream.py | 43 +++-- 21 files changed, 480 insertions(+), 721 deletions(-) diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 697397ba1..8b5c7a263 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -1,5 +1,5 @@ import asyncio -from orchstr8.testcase import IntegrationTestCase, d2f +from orchstr8.testcase import IntegrationTestCase from torba.constants import COIN @@ -9,14 +9,14 @@ class BasicTransactionTests(IntegrationTestCase): async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) - await d2f(self.ledger.update_account(account2)) + await self.ledger.update_account(account2) self.assertEqual(await self.get_balance(account1), 0) self.assertEqual(await self.get_balance(account2), 0) sendtxids = [] for i in range(5): - address1 = await d2f(account1.receiving.get_or_create_usable_address()) + address1 = await account1.receiving.get_or_create_usable_address() sendtxid = await self.blockchain.send_to_address(address1, 1.1) sendtxids.append(sendtxid) await self.on_transaction_id(sendtxid) # mempool @@ -28,13 +28,13 @@ class BasicTransactionTests(IntegrationTestCase): self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 5.5) self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 0) - address2 = await d2f(account2.receiving.get_or_create_usable_address()) + address2 = await account2.receiving.get_or_create_usable_address() hash2 = self.ledger.address_to_hash160(address2) - tx = await d2f(self.ledger.transaction_class.create( + tx = await self.ledger.transaction_class.create( [], [self.ledger.transaction_class.output_class.pay_pubkey_hash(2*COIN, hash2)], [account1], account1 - )) + ) await self.broadcast(tx) await self.on_transaction(tx) # mempool await self.blockchain.generate(1) @@ -43,18 +43,18 @@ class BasicTransactionTests(IntegrationTestCase): self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 3.5) self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) - utxos = await d2f(self.account.get_utxos()) - tx = await d2f(self.ledger.transaction_class.create( + utxos = await self.account.get_utxos() + tx = await self.ledger.transaction_class.create( [self.ledger.transaction_class.input_class.spend(utxos[0])], [], [account1], account1 - )) + ) await self.broadcast(tx) await self.on_transaction(tx) # mempool await self.blockchain.generate(1) await self.on_transaction(tx) # confirmed - txs = await d2f(account1.get_transactions()) + txs = await account1.get_transactions() tx = txs[1] self.assertEqual(round(tx.inputs[0].txo_ref.txo.amount/COIN, 1), 1.1) self.assertEqual(round(tx.inputs[1].txo_ref.txo.amount/COIN, 1), 1.1) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index 2e840c20b..347c0f843 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -1,25 +1,26 @@ from binascii import hexlify -from twisted.trial import unittest -from twisted.internet import defer + +from orchstr8.testcase import AsyncioTestCase from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class from torba.baseaccount import HierarchicalDeterministic, SingleKey from torba.wallet import Wallet -class TestHierarchicalDeterministicAccount(unittest.TestCase): +class TestHierarchicalDeterministicAccount(AsyncioTestCase): - @defer.inlineCallbacks - def setUp(self): + async def asyncSetUp(self): self.ledger = ledger_class({ 'db': ledger_class.database_class(':memory:'), 'headers': ledger_class.headers_class(':memory:'), }) - yield self.ledger.db.open() + await self.ledger.db.open() self.account = self.ledger.account_class.generate(self.ledger, Wallet(), "torba") - @defer.inlineCallbacks - def test_generate_account(self): + async def asyncTearDown(self): + await self.ledger.db.close() + + async def test_generate_account(self): account = self.account self.assertEqual(account.ledger, self.ledger) @@ -27,81 +28,77 @@ class TestHierarchicalDeterministicAccount(unittest.TestCase): self.assertEqual(account.public_key.ledger, self.ledger) self.assertEqual(account.private_key.public_key, account.public_key) - addresses = yield account.receiving.get_addresses() + addresses = await account.receiving.get_addresses() self.assertEqual(len(addresses), 0) - addresses = yield account.change.get_addresses() + addresses = await account.change.get_addresses() self.assertEqual(len(addresses), 0) - yield account.ensure_address_gap() + await account.ensure_address_gap() - addresses = yield account.receiving.get_addresses() + addresses = await account.receiving.get_addresses() self.assertEqual(len(addresses), 20) - addresses = yield account.change.get_addresses() + addresses = await account.change.get_addresses() self.assertEqual(len(addresses), 6) - addresses = yield account.get_addresses() + addresses = await account.get_addresses() self.assertEqual(len(addresses), 26) - @defer.inlineCallbacks - def test_generate_keys_over_batch_threshold_saves_it_properly(self): - yield self.account.receiving.generate_keys(0, 200) - records = yield self.account.receiving.get_address_records() + async def test_generate_keys_over_batch_threshold_saves_it_properly(self): + await self.account.receiving.generate_keys(0, 200) + records = await self.account.receiving.get_address_records() self.assertEqual(201, len(records)) - @defer.inlineCallbacks - def test_ensure_address_gap(self): + async def test_ensure_address_gap(self): account = self.account self.assertIsInstance(account.receiving, HierarchicalDeterministic) - yield account.receiving.generate_keys(4, 7) - yield account.receiving.generate_keys(0, 3) - yield account.receiving.generate_keys(8, 11) - records = yield account.receiving.get_address_records() + await account.receiving.generate_keys(4, 7) + await account.receiving.generate_keys(0, 3) + await account.receiving.generate_keys(8, 11) + records = await account.receiving.get_address_records() self.assertEqual( [r['position'] for r in records], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] ) # we have 12, but default gap is 20 - new_keys = yield account.receiving.ensure_address_gap() + new_keys = await account.receiving.ensure_address_gap() self.assertEqual(len(new_keys), 8) - records = yield account.receiving.get_address_records() + records = await account.receiving.get_address_records() self.assertEqual( [r['position'] for r in records], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] ) # case #1: no new addresses needed - empty = yield account.receiving.ensure_address_gap() + empty = await account.receiving.ensure_address_gap() self.assertEqual(len(empty), 0) # case #2: only one new addressed needed - records = yield account.receiving.get_address_records() - yield self.ledger.db.set_address_history(records[0]['address'], 'a:1:') - new_keys = yield account.receiving.ensure_address_gap() + records = await account.receiving.get_address_records() + await self.ledger.db.set_address_history(records[0]['address'], 'a:1:') + new_keys = await account.receiving.ensure_address_gap() self.assertEqual(len(new_keys), 1) # case #3: 20 addresses needed - yield self.ledger.db.set_address_history(new_keys[0], 'a:1:') - new_keys = yield account.receiving.ensure_address_gap() + await self.ledger.db.set_address_history(new_keys[0], 'a:1:') + new_keys = await account.receiving.ensure_address_gap() self.assertEqual(len(new_keys), 20) - @defer.inlineCallbacks - def test_get_or_create_usable_address(self): + async def test_get_or_create_usable_address(self): account = self.account - keys = yield account.receiving.get_addresses() + keys = await account.receiving.get_addresses() self.assertEqual(len(keys), 0) - address = yield account.receiving.get_or_create_usable_address() + address = await account.receiving.get_or_create_usable_address() self.assertIsNotNone(address) - keys = yield account.receiving.get_addresses() + keys = await account.receiving.get_addresses() self.assertEqual(len(keys), 20) - @defer.inlineCallbacks - def test_generate_account_from_seed(self): + async def test_generate_account_from_seed(self): account = self.ledger.account_class.from_dict( self.ledger, Wallet(), { "seed": "carbon smart garage balance margin twelve chest sword " @@ -123,17 +120,17 @@ class TestHierarchicalDeterministicAccount(unittest.TestCase): 'xpub661MyMwAqRbcFwwe67Bfjd53h5WXmKm6tqfBJZZH3pQLoy8Nb6mKUMJFc7UbpV' 'NzmwFPN2evn3YHnig1pkKVYcvCV8owTd2yAcEkJfCX53g' ) - address = yield account.receiving.ensure_address_gap() + address = await account.receiving.ensure_address_gap() self.assertEqual(address[0], '1CDLuMfwmPqJiNk5C2Bvew6tpgjAGgUk8J') - private_key = yield self.ledger.get_private_key_for_address('1CDLuMfwmPqJiNk5C2Bvew6tpgjAGgUk8J') + private_key = await self.ledger.get_private_key_for_address('1CDLuMfwmPqJiNk5C2Bvew6tpgjAGgUk8J') self.assertEqual( private_key.extended_key_string(), 'xprv9xV7rhbg6M4yWrdTeLorz3Q1GrQb4aQzzGWboP3du7W7UUztzNTUrEYTnDfz7o' 'ptBygDxXYRppyiuenJpoBTgYP2C26E1Ah5FEALM24CsWi' ) - invalid_key = yield self.ledger.get_private_key_for_address('BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX') + invalid_key = await self.ledger.get_private_key_for_address('BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX') self.assertIsNone(invalid_key) self.assertEqual( @@ -141,8 +138,7 @@ class TestHierarchicalDeterministicAccount(unittest.TestCase): b'1c01ae1e4c7d89e39f6d3aa7792c097a30ca7d40be249b6de52c81ec8cf9aab48b01' ) - @defer.inlineCallbacks - def test_load_and_save_account(self): + async def test_load_and_save_account(self): account_data = { 'name': 'My Account', 'seed': @@ -164,11 +160,11 @@ class TestHierarchicalDeterministicAccount(unittest.TestCase): account = self.ledger.account_class.from_dict(self.ledger, Wallet(), account_data) - yield account.ensure_address_gap() + await account.ensure_address_gap() - addresses = yield account.receiving.get_addresses() + addresses = await account.receiving.get_addresses() self.assertEqual(len(addresses), 5) - addresses = yield account.change.get_addresses() + addresses = await account.change.get_addresses() self.assertEqual(len(addresses), 5) self.maxDiff = None @@ -176,20 +172,21 @@ class TestHierarchicalDeterministicAccount(unittest.TestCase): self.assertDictEqual(account_data, account.to_dict()) -class TestSingleKeyAccount(unittest.TestCase): +class TestSingleKeyAccount(AsyncioTestCase): - @defer.inlineCallbacks - def setUp(self): + async def asyncSetUp(self): self.ledger = ledger_class({ 'db': ledger_class.database_class(':memory:'), 'headers': ledger_class.headers_class(':memory:'), }) - yield self.ledger.db.open() + await self.ledger.db.open() self.account = self.ledger.account_class.generate( self.ledger, Wallet(), "torba", {'name': 'single-address'}) - @defer.inlineCallbacks - def test_generate_account(self): + async def asyncTearDown(self): + await self.ledger.db.close() + + async def test_generate_account(self): account = self.account self.assertEqual(account.ledger, self.ledger) @@ -197,37 +194,36 @@ class TestSingleKeyAccount(unittest.TestCase): self.assertEqual(account.public_key.ledger, self.ledger) self.assertEqual(account.private_key.public_key, account.public_key) - addresses = yield account.receiving.get_addresses() + addresses = await account.receiving.get_addresses() self.assertEqual(len(addresses), 0) - addresses = yield account.change.get_addresses() + addresses = await account.change.get_addresses() self.assertEqual(len(addresses), 0) - yield account.ensure_address_gap() + await account.ensure_address_gap() - addresses = yield account.receiving.get_addresses() + addresses = await account.receiving.get_addresses() self.assertEqual(len(addresses), 1) self.assertEqual(addresses[0], account.public_key.address) - addresses = yield account.change.get_addresses() + addresses = await account.change.get_addresses() self.assertEqual(len(addresses), 1) self.assertEqual(addresses[0], account.public_key.address) - addresses = yield account.get_addresses() + addresses = await account.get_addresses() self.assertEqual(len(addresses), 1) self.assertEqual(addresses[0], account.public_key.address) - @defer.inlineCallbacks - def test_ensure_address_gap(self): + async def test_ensure_address_gap(self): account = self.account self.assertIsInstance(account.receiving, SingleKey) - addresses = yield account.receiving.get_addresses() + addresses = await account.receiving.get_addresses() self.assertEqual(addresses, []) # we have 12, but default gap is 20 - new_keys = yield account.receiving.ensure_address_gap() + new_keys = await account.receiving.ensure_address_gap() self.assertEqual(len(new_keys), 1) self.assertEqual(new_keys[0], account.public_key.address) - records = yield account.receiving.get_address_records() + records = await account.receiving.get_address_records() self.assertEqual(records, [{ 'position': 0, 'chain': 0, 'account': account.public_key.address, @@ -236,37 +232,35 @@ class TestSingleKeyAccount(unittest.TestCase): }]) # case #1: no new addresses needed - empty = yield account.receiving.ensure_address_gap() + empty = await account.receiving.ensure_address_gap() self.assertEqual(len(empty), 0) # case #2: after use, still no new address needed - records = yield account.receiving.get_address_records() - yield self.ledger.db.set_address_history(records[0]['address'], 'a:1:') - empty = yield account.receiving.ensure_address_gap() + records = await account.receiving.get_address_records() + await self.ledger.db.set_address_history(records[0]['address'], 'a:1:') + empty = await account.receiving.ensure_address_gap() self.assertEqual(len(empty), 0) - @defer.inlineCallbacks - def test_get_or_create_usable_address(self): + async def test_get_or_create_usable_address(self): account = self.account - addresses = yield account.receiving.get_addresses() + addresses = await account.receiving.get_addresses() self.assertEqual(len(addresses), 0) - address1 = yield account.receiving.get_or_create_usable_address() + address1 = await account.receiving.get_or_create_usable_address() self.assertIsNotNone(address1) - yield self.ledger.db.set_address_history(address1, 'a:1:b:2:c:3:') - records = yield account.receiving.get_address_records() + await self.ledger.db.set_address_history(address1, 'a:1:b:2:c:3:') + records = await account.receiving.get_address_records() self.assertEqual(records[0]['used_times'], 3) - address2 = yield account.receiving.get_or_create_usable_address() + address2 = await account.receiving.get_or_create_usable_address() self.assertEqual(address1, address2) - keys = yield account.receiving.get_addresses() + keys = await account.receiving.get_addresses() self.assertEqual(len(keys), 1) - @defer.inlineCallbacks - def test_generate_account_from_seed(self): + async def test_generate_account_from_seed(self): account = self.ledger.account_class.from_dict( self.ledger, Wallet(), { "seed": @@ -285,17 +279,17 @@ class TestSingleKeyAccount(unittest.TestCase): 'xpub661MyMwAqRbcFwwe67Bfjd53h5WXmKm6tqfBJZZH3pQLoy8Nb6mKUMJFc7' 'UbpVNzmwFPN2evn3YHnig1pkKVYcvCV8owTd2yAcEkJfCX53g', ) - address = yield account.receiving.ensure_address_gap() + address = await account.receiving.ensure_address_gap() self.assertEqual(address[0], account.public_key.address) - private_key = yield self.ledger.get_private_key_for_address(address[0]) + private_key = await self.ledger.get_private_key_for_address(address[0]) self.assertEqual( private_key.extended_key_string(), 'xprv9s21ZrQH143K3TsAz5efNV8K93g3Ms3FXcjaWB9fVUsMwAoE3ZT4vYymkp' '5BxKKfnpz8J6sHDFriX1SnpvjNkzcks8XBnxjGLS83BTyfpna', ) - invalid_key = yield self.ledger.get_private_key_for_address('BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX') + invalid_key = await self.ledger.get_private_key_for_address('BcQjRlhDOIrQez1WHfz3whnB33Bp34sUgX') self.assertIsNone(invalid_key) self.assertEqual( @@ -303,8 +297,7 @@ class TestSingleKeyAccount(unittest.TestCase): b'1c92caa0ef99bfd5e2ceb73b66da8cd726a9370be8c368d448a322f3c5b23aaab901' ) - @defer.inlineCallbacks - def test_load_and_save_account(self): + async def test_load_and_save_account(self): account_data = { 'name': 'My Account', 'seed': @@ -322,11 +315,11 @@ class TestSingleKeyAccount(unittest.TestCase): account = self.ledger.account_class.from_dict(self.ledger, Wallet(), account_data) - yield account.ensure_address_gap() + await account.ensure_address_gap() - addresses = yield account.receiving.get_addresses() + addresses = await account.receiving.get_addresses() self.assertEqual(len(addresses), 1) - addresses = yield account.change.get_addresses() + addresses = await account.change.get_addresses() self.assertEqual(len(addresses), 1) self.maxDiff = None @@ -334,7 +327,7 @@ class TestSingleKeyAccount(unittest.TestCase): self.assertDictEqual(account_data, account.to_dict()) -class AccountEncryptionTests(unittest.TestCase): +class AccountEncryptionTests(AsyncioTestCase): password = "password" init_vector = b'0000000000000000' unencrypted_account = { @@ -368,7 +361,7 @@ class AccountEncryptionTests(unittest.TestCase): 'address_generator': {'name': 'single-address'} } - def setUp(self): + async def asyncSetUp(self): self.ledger = ledger_class({ 'db': ledger_class.database_class(':memory:'), 'headers': ledger_class.headers_class(':memory:'), diff --git a/tests/unit/test_bcd_data_stream.py b/tests/unit/test_bcd_data_stream.py index 577c0ebf2..d15a92f4f 100644 --- a/tests/unit/test_bcd_data_stream.py +++ b/tests/unit/test_bcd_data_stream.py @@ -1,4 +1,4 @@ -from twisted.trial import unittest +import unittest from torba.bcd_data_stream import BCDataStream diff --git a/tests/unit/test_bip32.py b/tests/unit/test_bip32.py index 12d69089e..b96c5a894 100644 --- a/tests/unit/test_bip32.py +++ b/tests/unit/test_bip32.py @@ -1,5 +1,5 @@ +import unittest from binascii import unhexlify, hexlify -from twisted.trial import unittest from .key_fixtures import expected_ids, expected_privkeys, expected_hardened_privkeys from torba.bip32 import PubKey, PrivateKey, from_extended_key_string diff --git a/tests/unit/test_coinselection.py b/tests/unit/test_coinselection.py index b3b577ce8..610a20715 100644 --- a/tests/unit/test_coinselection.py +++ b/tests/unit/test_coinselection.py @@ -1,4 +1,4 @@ -from twisted.trial import unittest +import unittest from types import GeneratorType from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class diff --git a/tests/unit/test_database.py b/tests/unit/test_database.py index 9c3409d8b..860223bea 100644 --- a/tests/unit/test_database.py +++ b/tests/unit/test_database.py @@ -1,11 +1,12 @@ -from twisted.trial import unittest -from twisted.internet import defer +import unittest from torba.wallet import Wallet from torba.constants import COIN from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class from torba.basedatabase import query, constraints_to_sql +from orchstr8.testcase import AsyncioTestCase + from .test_transaction import get_output, NULL_HASH @@ -100,53 +101,52 @@ class TestQueryBuilder(unittest.TestCase): ) -class TestQueries(unittest.TestCase): +class TestQueries(AsyncioTestCase): - def setUp(self): + async def asyncSetUp(self): self.ledger = ledger_class({ 'db': ledger_class.database_class(':memory:'), 'headers': ledger_class.headers_class(':memory:'), }) - return self.ledger.db.open() + await self.ledger.db.open() - @defer.inlineCallbacks - def create_account(self): + async def asyncTearDown(self): + await self.ledger.db.close() + + async def create_account(self): account = self.ledger.account_class.generate(self.ledger, Wallet()) - yield account.ensure_address_gap() + await account.ensure_address_gap() return account - @defer.inlineCallbacks - def create_tx_from_nothing(self, my_account, height): - to_address = yield my_account.receiving.get_or_create_usable_address() + async def create_tx_from_nothing(self, my_account, height): + to_address = await my_account.receiving.get_or_create_usable_address() to_hash = ledger_class.address_to_hash160(to_address) tx = ledger_class.transaction_class(height=height, is_verified=True) \ .add_inputs([self.txi(self.txo(1, NULL_HASH))]) \ .add_outputs([self.txo(1, to_hash)]) - yield self.ledger.db.save_transaction_io('insert', tx, to_address, to_hash, '') + await self.ledger.db.save_transaction_io('insert', tx, to_address, to_hash, '') return tx - @defer.inlineCallbacks - def create_tx_from_txo(self, txo, to_account, height): + async def create_tx_from_txo(self, txo, to_account, height): from_hash = txo.script.values['pubkey_hash'] from_address = self.ledger.hash160_to_address(from_hash) - to_address = yield to_account.receiving.get_or_create_usable_address() + to_address = await to_account.receiving.get_or_create_usable_address() to_hash = ledger_class.address_to_hash160(to_address) tx = ledger_class.transaction_class(height=height, is_verified=True) \ .add_inputs([self.txi(txo)]) \ .add_outputs([self.txo(1, to_hash)]) - yield self.ledger.db.save_transaction_io('insert', tx, from_address, from_hash, '') - yield self.ledger.db.save_transaction_io('', tx, to_address, to_hash, '') + await self.ledger.db.save_transaction_io('insert', tx, from_address, from_hash, '') + await self.ledger.db.save_transaction_io('', tx, to_address, to_hash, '') return tx - @defer.inlineCallbacks - def create_tx_to_nowhere(self, txo, height): + async def create_tx_to_nowhere(self, txo, height): from_hash = txo.script.values['pubkey_hash'] from_address = self.ledger.hash160_to_address(from_hash) to_hash = NULL_HASH tx = ledger_class.transaction_class(height=height, is_verified=True) \ .add_inputs([self.txi(txo)]) \ .add_outputs([self.txo(1, to_hash)]) - yield self.ledger.db.save_transaction_io('insert', tx, from_address, from_hash, '') + await self.ledger.db.save_transaction_io('insert', tx, from_address, from_hash, '') return tx def txo(self, amount, address): @@ -155,39 +155,38 @@ class TestQueries(unittest.TestCase): def txi(self, txo): return ledger_class.transaction_class.input_class.spend(txo) - @defer.inlineCallbacks - def test_get_transactions(self): - account1 = yield self.create_account() - account2 = yield self.create_account() - tx1 = yield self.create_tx_from_nothing(account1, 1) - tx2 = yield self.create_tx_from_txo(tx1.outputs[0], account2, 2) - tx3 = yield self.create_tx_to_nowhere(tx2.outputs[0], 3) + async def test_get_transactions(self): + account1 = await self.create_account() + account2 = await self.create_account() + tx1 = await self.create_tx_from_nothing(account1, 1) + tx2 = await self.create_tx_from_txo(tx1.outputs[0], account2, 2) + tx3 = await self.create_tx_to_nowhere(tx2.outputs[0], 3) - txs = yield self.ledger.db.get_transactions() + txs = await self.ledger.db.get_transactions() self.assertEqual([tx3.id, tx2.id, tx1.id], [tx.id for tx in txs]) self.assertEqual([3, 2, 1], [tx.height for tx in txs]) - txs = yield self.ledger.db.get_transactions(account=account1) + txs = await self.ledger.db.get_transactions(account=account1) self.assertEqual([tx2.id, tx1.id], [tx.id for tx in txs]) self.assertEqual(txs[0].inputs[0].is_my_account, True) self.assertEqual(txs[0].outputs[0].is_my_account, False) self.assertEqual(txs[1].inputs[0].is_my_account, False) self.assertEqual(txs[1].outputs[0].is_my_account, True) - txs = yield self.ledger.db.get_transactions(account=account2) + txs = await self.ledger.db.get_transactions(account=account2) self.assertEqual([tx3.id, tx2.id], [tx.id for tx in txs]) self.assertEqual(txs[0].inputs[0].is_my_account, True) self.assertEqual(txs[0].outputs[0].is_my_account, False) self.assertEqual(txs[1].inputs[0].is_my_account, False) self.assertEqual(txs[1].outputs[0].is_my_account, True) - tx = yield self.ledger.db.get_transaction(txid=tx2.id) + tx = await self.ledger.db.get_transaction(txid=tx2.id) self.assertEqual(tx.id, tx2.id) self.assertEqual(tx.inputs[0].is_my_account, False) self.assertEqual(tx.outputs[0].is_my_account, False) - tx = yield self.ledger.db.get_transaction(txid=tx2.id, account=account1) + tx = await self.ledger.db.get_transaction(txid=tx2.id, account=account1) self.assertEqual(tx.inputs[0].is_my_account, True) self.assertEqual(tx.outputs[0].is_my_account, False) - tx = yield self.ledger.db.get_transaction(txid=tx2.id, account=account2) + tx = await self.ledger.db.get_transaction(txid=tx2.id, account=account2) self.assertEqual(tx.inputs[0].is_my_account, False) self.assertEqual(tx.outputs[0].is_my_account, True) diff --git a/tests/unit/test_hash.py b/tests/unit/test_hash.py index 4f4d31526..4a7f2331d 100644 --- a/tests/unit/test_hash.py +++ b/tests/unit/test_hash.py @@ -1,11 +1,6 @@ -from unittest import TestCase +from unittest import TestCase, mock from torba.hash import aes_decrypt, aes_encrypt -try: - from unittest import mock -except ImportError: - import mock - class TestAESEncryptDecrypt(TestCase): message = 'The Times 03/Jan/2009 Chancellor on brink of second bailout for banks' diff --git a/tests/unit/test_headers.py b/tests/unit/test_headers.py index 92654bde5..46489e733 100644 --- a/tests/unit/test_headers.py +++ b/tests/unit/test_headers.py @@ -1,8 +1,7 @@ import os from urllib.request import Request, urlopen -from twisted.trial import unittest -from twisted.internet import defer +from orchstr8.testcase import AsyncioTestCase from torba.coin.bitcoinsegwit import MainHeaders @@ -11,7 +10,7 @@ def block_bytes(blocks): return blocks * MainHeaders.header_size -class BitcoinHeadersTestCase(unittest.TestCase): +class BitcoinHeadersTestCase(AsyncioTestCase): # Download headers instead of storing them in git. HEADER_URL = 'http://headers.electrum.org/blockchain_headers' @@ -39,7 +38,7 @@ class BitcoinHeadersTestCase(unittest.TestCase): headers.seek(after, os.SEEK_SET) return headers.read(upto) - def get_headers(self, upto: int = -1): + async def get_headers(self, upto: int = -1): h = MainHeaders(':memory:') h.io.write(self.get_bytes(upto)) return h @@ -47,8 +46,8 @@ class BitcoinHeadersTestCase(unittest.TestCase): class BasicHeadersTests(BitcoinHeadersTestCase): - def test_serialization(self): - h = self.get_headers() + async def test_serialization(self): + h = await self.get_headers() self.assertEqual(h[0], { 'bits': 486604799, 'block_height': 0, @@ -94,18 +93,16 @@ class BasicHeadersTests(BitcoinHeadersTestCase): h.get_raw_header(self.RETARGET_BLOCK) ) - @defer.inlineCallbacks - def test_connect_from_genesis_to_3000_past_first_chunk_at_2016(self): + async def test_connect_from_genesis_to_3000_past_first_chunk_at_2016(self): headers = MainHeaders(':memory:') self.assertEqual(headers.height, -1) - yield headers.connect(0, self.get_bytes(block_bytes(3001))) + await headers.connect(0, self.get_bytes(block_bytes(3001))) self.assertEqual(headers.height, 3000) - @defer.inlineCallbacks - def test_connect_9_blocks_passing_a_retarget_at_32256(self): + async def test_connect_9_blocks_passing_a_retarget_at_32256(self): retarget = block_bytes(self.RETARGET_BLOCK-5) - headers = self.get_headers(upto=retarget) + headers = await self.get_headers(upto=retarget) remainder = self.get_bytes(after=retarget) self.assertEqual(headers.height, 32250) - yield headers.connect(len(headers), remainder) + await headers.connect(len(headers), remainder) self.assertEqual(headers.height, 32259) diff --git a/tests/unit/test_ledger.py b/tests/unit/test_ledger.py index 771ab1426..3f6d3ba7c 100644 --- a/tests/unit/test_ledger.py +++ b/tests/unit/test_ledger.py @@ -1,6 +1,5 @@ import os from binascii import hexlify -from twisted.internet import defer from torba.coin.bitcoinsegwit import MainNetLedger from torba.wallet import Wallet @@ -18,32 +17,30 @@ class MockNetwork: self.get_history_called = [] self.get_transaction_called = [] - def get_history(self, address): + async def get_history(self, address): self.get_history_called.append(address) self.address = address - return defer.succeed(self.history) + return self.history - def get_merkle(self, txid, height): - return defer.succeed({'merkle': ['abcd01'], 'pos': 1}) + async def get_merkle(self, txid, height): + return {'merkle': ['abcd01'], 'pos': 1} - def get_transaction(self, tx_hash): + async def get_transaction(self, tx_hash): self.get_transaction_called.append(tx_hash) - return defer.succeed(self.transaction[tx_hash]) + return self.transaction[tx_hash] class LedgerTestCase(BitcoinHeadersTestCase): - def setUp(self): - super().setUp() + async def asyncSetUp(self): self.ledger = MainNetLedger({ 'db': MainNetLedger.database_class(':memory:'), 'headers': MainNetLedger.headers_class(':memory:') }) - return self.ledger.db.open() + await self.ledger.db.open() - def tearDown(self): - super().tearDown() - return self.ledger.db.close() + async def asyncTearDown(self): + await self.ledger.db.close() def make_header(self, **kwargs): header = { @@ -69,11 +66,10 @@ class LedgerTestCase(BitcoinHeadersTestCase): class TestSynchronization(LedgerTestCase): - @defer.inlineCallbacks - def test_update_history(self): + async def test_update_history(self): account = self.ledger.account_class.generate(self.ledger, Wallet(), "torba") - address = yield account.receiving.get_or_create_usable_address() - address_details = yield self.ledger.db.get_address(address=address) + address = await account.receiving.get_or_create_usable_address() + address_details = await self.ledger.db.get_address(address=address) self.assertEqual(address_details['history'], None) self.add_header(block_height=0, merkle_root=b'abcd04') @@ -89,16 +85,16 @@ class TestSynchronization(LedgerTestCase): 'abcd02': hexlify(get_transaction(get_output(2)).raw), 'abcd03': hexlify(get_transaction(get_output(3)).raw), }) - yield self.ledger.update_history(address) + await self.ledger.update_history(address) self.assertEqual(self.ledger.network.get_history_called, [address]) self.assertEqual(self.ledger.network.get_transaction_called, ['abcd01', 'abcd02', 'abcd03']) - address_details = yield self.ledger.db.get_address(address=address) + address_details = await self.ledger.db.get_address(address=address) self.assertEqual(address_details['history'], 'abcd01:0:abcd02:1:abcd03:2:') self.ledger.network.get_history_called = [] self.ledger.network.get_transaction_called = [] - yield self.ledger.update_history(address) + await self.ledger.update_history(address) self.assertEqual(self.ledger.network.get_history_called, [address]) self.assertEqual(self.ledger.network.get_transaction_called, []) @@ -106,10 +102,10 @@ class TestSynchronization(LedgerTestCase): self.ledger.network.transaction['abcd04'] = hexlify(get_transaction(get_output(4)).raw) self.ledger.network.get_history_called = [] self.ledger.network.get_transaction_called = [] - yield self.ledger.update_history(address) + await self.ledger.update_history(address) self.assertEqual(self.ledger.network.get_history_called, [address]) self.assertEqual(self.ledger.network.get_transaction_called, ['abcd04']) - address_details = yield self.ledger.db.get_address(address=address) + address_details = await self.ledger.db.get_address(address=address) self.assertEqual(address_details['history'], 'abcd01:0:abcd02:1:abcd03:2:abcd04:3:') @@ -117,14 +113,13 @@ class MocHeaderNetwork: def __init__(self, responses): self.responses = responses - def get_headers(self, height, blocks): + async def get_headers(self, height, blocks): return self.responses[height] class BlockchainReorganizationTests(LedgerTestCase): - @defer.inlineCallbacks - def test_1_block_reorganization(self): + async def test_1_block_reorganization(self): self.ledger.network = MocHeaderNetwork({ 20: {'height': 20, 'count': 5, 'hex': hexlify( self.get_bytes(after=block_bytes(20), upto=block_bytes(5)) @@ -132,15 +127,14 @@ class BlockchainReorganizationTests(LedgerTestCase): 25: {'height': 25, 'count': 0, 'hex': b''} }) headers = self.ledger.headers - yield headers.connect(0, self.get_bytes(upto=block_bytes(20))) + await headers.connect(0, self.get_bytes(upto=block_bytes(20))) self.add_header(block_height=len(headers)) self.assertEqual(headers.height, 20) - yield self.ledger.receive_header([{ + await self.ledger.receive_header([{ 'height': 21, 'hex': hexlify(self.make_header(block_height=21)) }]) - @defer.inlineCallbacks - def test_3_block_reorganization(self): + async def test_3_block_reorganization(self): self.ledger.network = MocHeaderNetwork({ 20: {'height': 20, 'count': 5, 'hex': hexlify( self.get_bytes(after=block_bytes(20), upto=block_bytes(5)) @@ -150,11 +144,11 @@ class BlockchainReorganizationTests(LedgerTestCase): 25: {'height': 25, 'count': 0, 'hex': b''} }) headers = self.ledger.headers - yield headers.connect(0, self.get_bytes(upto=block_bytes(20))) + await headers.connect(0, self.get_bytes(upto=block_bytes(20))) self.add_header(block_height=len(headers)) self.add_header(block_height=len(headers)) self.add_header(block_height=len(headers)) self.assertEqual(headers.height, 22) - yield self.ledger.receive_header(({ + await self.ledger.receive_header(({ 'height': 23, 'hex': hexlify(self.make_header(block_height=23)) },)) diff --git a/tests/unit/test_script.py b/tests/unit/test_script.py index 1bb832123..ffcbc5b12 100644 --- a/tests/unit/test_script.py +++ b/tests/unit/test_script.py @@ -1,5 +1,5 @@ +import unittest from binascii import hexlify, unhexlify -from twisted.trial import unittest from torba.bcd_data_stream import BCDataStream from torba.basescript import Template, ParseError, tokenize, push_data diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index 26c5f6d8d..b082b6035 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -1,7 +1,8 @@ +import unittest from binascii import hexlify, unhexlify from itertools import cycle -from twisted.trial import unittest -from twisted.internet import defer + +from orchstr8.testcase import AsyncioTestCase from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class from torba.wallet import Wallet @@ -29,9 +30,9 @@ def get_transaction(txo=None): .add_outputs([txo or ledger_class.transaction_class.output_class.pay_pubkey_hash(CENT, NULL_HASH)]) -class TestSizeAndFeeEstimation(unittest.TestCase): +class TestSizeAndFeeEstimation(AsyncioTestCase): - def setUp(self): + async def asyncSetUp(self): self.ledger = ledger_class({ 'db': ledger_class.database_class(':memory:'), 'headers': ledger_class.headers_class(':memory:'), @@ -181,17 +182,19 @@ class TestTransactionSerialization(unittest.TestCase): self.assertEqual(tx.raw, raw) -class TestTransactionSigning(unittest.TestCase): +class TestTransactionSigning(AsyncioTestCase): - def setUp(self): + async def asyncSetUp(self): self.ledger = ledger_class({ 'db': ledger_class.database_class(':memory:'), 'headers': ledger_class.headers_class(':memory:'), }) - return self.ledger.db.open() + await self.ledger.db.open() - @defer.inlineCallbacks - def test_sign(self): + async def asyncTearDown(self): + await self.ledger.db.close() + + async def test_sign(self): account = self.ledger.account_class.from_dict( self.ledger, Wallet(), { "seed": "carbon smart garage balance margin twelve chest sword " @@ -200,8 +203,8 @@ class TestTransactionSigning(unittest.TestCase): } ) - yield account.ensure_address_gap() - address1, address2 = yield account.receiving.get_addresses(limit=2) + await account.ensure_address_gap() + address1, address2 = await account.receiving.get_addresses(limit=2) pubkey_hash1 = self.ledger.address_to_hash160(address1) pubkey_hash2 = self.ledger.address_to_hash160(address2) @@ -211,9 +214,8 @@ class TestTransactionSigning(unittest.TestCase): .add_inputs([tx_class.input_class.spend(get_output(2*COIN, pubkey_hash1))]) \ .add_outputs([tx_class.output_class.pay_pubkey_hash(int(1.9*COIN), pubkey_hash2)]) \ - yield tx.sign([account]) + await tx.sign([account]) - print(hexlify(tx.inputs[0].script.values['signature'])) self.assertEqual( hexlify(tx.inputs[0].script.values['signature']), b'304402205a1df8cd5d2d2fa5934b756883d6c07e4f83e1350c740992d47a12422' @@ -221,15 +223,14 @@ class TestTransactionSigning(unittest.TestCase): ) -class TransactionIOBalancing(unittest.TestCase): +class TransactionIOBalancing(AsyncioTestCase): - @defer.inlineCallbacks - def setUp(self): + async def asyncSetUp(self): self.ledger = ledger_class({ 'db': ledger_class.database_class(':memory:'), 'headers': ledger_class.headers_class(':memory:'), }) - yield self.ledger.db.open() + await self.ledger.db.open() self.account = self.ledger.account_class.from_dict( self.ledger, Wallet(), { "seed": "carbon smart garage balance margin twelve chest sword " @@ -237,10 +238,13 @@ class TransactionIOBalancing(unittest.TestCase): } ) - addresses = yield self.account.ensure_address_gap() + addresses = await self.account.ensure_address_gap() self.pubkey_hash = [self.ledger.address_to_hash160(a) for a in addresses] self.hash_cycler = cycle(self.pubkey_hash) + async def asyncTearDown(self): + await self.ledger.db.close() + def txo(self, amount, address=None): return get_output(int(amount*COIN), address or next(self.hash_cycler)) @@ -250,8 +254,7 @@ class TransactionIOBalancing(unittest.TestCase): def tx(self, inputs, outputs): return ledger_class.transaction_class.create(inputs, outputs, [self.account], self.account) - @defer.inlineCallbacks - def create_utxos(self, amounts): + async def create_utxos(self, amounts): utxos = [self.txo(amount) for amount in amounts] self.funding_tx = ledger_class.transaction_class(is_verified=True) \ @@ -260,7 +263,7 @@ class TransactionIOBalancing(unittest.TestCase): save_tx = 'insert' for utxo in utxos: - yield self.ledger.db.save_transaction_io( + await self.ledger.db.save_transaction_io( save_tx, self.funding_tx, self.ledger.hash160_to_address(utxo.script.values['pubkey_hash']), utxo.script.values['pubkey_hash'], '' @@ -277,17 +280,16 @@ class TransactionIOBalancing(unittest.TestCase): def outputs(tx): return [round(o.amount/COIN, 2) for o in tx.outputs] - @defer.inlineCallbacks - def test_basic_use_cases(self): + async def test_basic_use_cases(self): self.ledger.fee_per_byte = int(.01*CENT) # available UTXOs for filling missing inputs - utxos = yield self.create_utxos([ + utxos = await self.create_utxos([ 1, 1, 3, 5, 10 ]) # pay 3 coins (3.02 w/ fees) - tx = yield self.tx( + tx = await self.tx( [], # inputs [self.txo(3)] # outputs ) @@ -296,10 +298,10 @@ class TransactionIOBalancing(unittest.TestCase): # a change of 1.98 is added to reach balance self.assertEqual(self.outputs(tx), [3, 1.98]) - yield self.ledger.release_outputs(utxos) + await self.ledger.release_outputs(utxos) # pay 2.98 coins (3.00 w/ fees) - tx = yield self.tx( + tx = await self.tx( [], # inputs [self.txo(2.98)] # outputs ) @@ -307,10 +309,10 @@ class TransactionIOBalancing(unittest.TestCase): self.assertEqual(self.inputs(tx), [3]) self.assertEqual(self.outputs(tx), [2.98]) - yield self.ledger.release_outputs(utxos) + await self.ledger.release_outputs(utxos) # supplied input and output, but input is not enough to cover output - tx = yield self.tx( + tx = await self.tx( [self.txi(self.txo(10))], # inputs [self.txo(11)] # outputs ) @@ -319,10 +321,10 @@ class TransactionIOBalancing(unittest.TestCase): # change is now needed to consume extra input self.assertEqual([11, 1.96], self.outputs(tx)) - yield self.ledger.release_outputs(utxos) + await self.ledger.release_outputs(utxos) # liquidating a UTXO - tx = yield self.tx( + tx = await self.tx( [self.txi(self.txo(10))], # inputs [] # outputs ) @@ -330,10 +332,10 @@ class TransactionIOBalancing(unittest.TestCase): # missing change added to consume the amount self.assertEqual([9.98], self.outputs(tx)) - yield self.ledger.release_outputs(utxos) + await self.ledger.release_outputs(utxos) # liquidating at a loss, requires adding extra inputs - tx = yield self.tx( + tx = await self.tx( [self.txi(self.txo(0.01))], # inputs [] # outputs ) diff --git a/tests/unit/test_utils.py b/tests/unit/test_utils.py index d46c9d5d9..197591ce5 100644 --- a/tests/unit/test_utils.py +++ b/tests/unit/test_utils.py @@ -1,4 +1,4 @@ -from twisted.trial import unittest +import unittest from torba.util import ArithUint256 diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index 9f825834f..bebcf1585 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -1,5 +1,5 @@ +import unittest import tempfile -from twisted.trial import unittest from torba.coin.bitcoinsegwit import MainNetLedger as BTCLedger from torba.coin.bitcoincash import MainNetLedger as BCHLedger diff --git a/torba/baseaccount.py b/torba/baseaccount.py index fe35d9b37..7369f9394 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -1,7 +1,6 @@ import random import typing from typing import List, Dict, Tuple, Type, Optional, Any -from twisted.internet import defer from torba.mnemonic import Mnemonic from torba.bip32 import PrivateKey, PubKey, from_extended_key_string @@ -44,12 +43,8 @@ class AddressManager: def to_dict_instance(self) -> Optional[dict]: raise NotImplementedError - @property - def db(self): - return self.account.ledger.db - def _query_addresses(self, **constraints): - return self.db.get_addresses( + return self.account.ledger.db.get_addresses( account=self.account, chain=self.chain_number, **constraints @@ -58,26 +53,24 @@ class AddressManager: def get_private_key(self, index: int) -> PrivateKey: raise NotImplementedError - def get_max_gap(self) -> defer.Deferred: + async def get_max_gap(self): raise NotImplementedError - def ensure_address_gap(self) -> defer.Deferred: + async def ensure_address_gap(self): raise NotImplementedError - def get_address_records(self, only_usable: bool = False, **constraints) -> defer.Deferred: + def get_address_records(self, only_usable: bool = False, **constraints): raise NotImplementedError - @defer.inlineCallbacks - def get_addresses(self, only_usable: bool = False, **constraints) -> defer.Deferred: - records = yield self.get_address_records(only_usable=only_usable, **constraints) + async def get_addresses(self, only_usable: bool = False, **constraints): + records = await self.get_address_records(only_usable=only_usable, **constraints) return [r['address'] for r in records] - @defer.inlineCallbacks - def get_or_create_usable_address(self) -> defer.Deferred: - addresses = yield self.get_addresses(only_usable=True, limit=10) + async def get_or_create_usable_address(self): + addresses = await self.get_addresses(only_usable=True, limit=10) if addresses: return random.choice(addresses) - addresses = yield self.ensure_address_gap() + addresses = await self.ensure_address_gap() return addresses[0] @@ -106,22 +99,20 @@ class HierarchicalDeterministic(AddressManager): def get_private_key(self, index: int) -> PrivateKey: return self.account.private_key.child(self.chain_number).child(index) - @defer.inlineCallbacks - def generate_keys(self, start: int, end: int) -> defer.Deferred: + async def generate_keys(self, start: int, end: int): keys_batch, final_keys = [], [] for index in range(start, end+1): keys_batch.append((index, self.public_key.child(index))) if index % 180 == 0 or index == end: - yield self.db.add_keys( + await self.account.ledger.db.add_keys( self.account, self.chain_number, keys_batch ) final_keys.extend(keys_batch) keys_batch.clear() return [key[1].address for key in final_keys] - @defer.inlineCallbacks - def get_max_gap(self) -> defer.Deferred: - addresses = yield self._query_addresses(order_by="position ASC") + async def get_max_gap(self): + addresses = await self._query_addresses(order_by="position ASC") max_gap = 0 current_gap = 0 for address in addresses: @@ -132,9 +123,8 @@ class HierarchicalDeterministic(AddressManager): current_gap = 0 return max_gap - @defer.inlineCallbacks - def ensure_address_gap(self) -> defer.Deferred: - addresses = yield self._query_addresses(limit=self.gap, order_by="position DESC") + async def ensure_address_gap(self): + addresses = await self._query_addresses(limit=self.gap, order_by="position DESC") existing_gap = 0 for address in addresses: @@ -148,7 +138,7 @@ class HierarchicalDeterministic(AddressManager): start = addresses[0]['position']+1 if addresses else 0 end = start + (self.gap - existing_gap) - new_keys = yield self.generate_keys(start, end-1) + new_keys = await self.generate_keys(start, end-1) return new_keys def get_address_records(self, only_usable: bool = False, **constraints): @@ -176,20 +166,19 @@ class SingleKey(AddressManager): def get_private_key(self, index: int) -> PrivateKey: return self.account.private_key - def get_max_gap(self) -> defer.Deferred: - return defer.succeed(0) + async def get_max_gap(self): + return 0 - @defer.inlineCallbacks - def ensure_address_gap(self) -> defer.Deferred: - exists = yield self.get_address_records() + async def ensure_address_gap(self): + exists = await self.get_address_records() if not exists: - yield self.db.add_keys( + await self.account.ledger.db.add_keys( self.account, self.chain_number, [(0, self.public_key)] ) return [self.public_key.address] return [] - def get_address_records(self, only_usable: bool = False, **constraints) -> defer.Deferred: + def get_address_records(self, only_usable: bool = False, **constraints): return self._query_addresses(**constraints) @@ -289,9 +278,8 @@ class BaseAccount: 'address_generator': self.address_generator.to_dict(self.receiving, self.change) } - @defer.inlineCallbacks - def get_details(self, show_seed=False, **kwargs): - satoshis = yield self.get_balance(**kwargs) + async def get_details(self, show_seed=False, **kwargs): + satoshis = await self.get_balance(**kwargs) details = { 'id': self.id, 'name': self.name, @@ -325,23 +313,21 @@ class BaseAccount: self.password = None self.encrypted = True - @defer.inlineCallbacks - def ensure_address_gap(self): + async def ensure_address_gap(self): addresses = [] for address_manager in self.address_managers: - new_addresses = yield address_manager.ensure_address_gap() + new_addresses = await address_manager.ensure_address_gap() addresses.extend(new_addresses) return addresses - @defer.inlineCallbacks - def get_addresses(self, **constraints) -> defer.Deferred: - rows = yield self.ledger.db.select_addresses('address', account=self, **constraints) + async def get_addresses(self, **constraints): + rows = await self.ledger.db.select_addresses('address', account=self, **constraints) return [r[0] for r in rows] - def get_address_records(self, **constraints) -> defer.Deferred: + def get_address_records(self, **constraints): return self.ledger.db.get_addresses(account=self, **constraints) - def get_address_count(self, **constraints) -> defer.Deferred: + def get_address_count(self, **constraints): return self.ledger.db.get_address_count(account=self, **constraints) def get_private_key(self, chain: int, index: int) -> PrivateKey: @@ -355,10 +341,9 @@ class BaseAccount: constraints.update({'height__lte': height, 'height__gt': 0}) return self.ledger.db.get_balance(account=self, **constraints) - @defer.inlineCallbacks - def get_max_gap(self): - change_gap = yield self.change.get_max_gap() - receiving_gap = yield self.receiving.get_max_gap() + async def get_max_gap(self): + change_gap = await self.change.get_max_gap() + receiving_gap = await self.receiving.get_max_gap() return { 'max_change_gap': change_gap, 'max_receiving_gap': receiving_gap, @@ -376,24 +361,23 @@ class BaseAccount: def get_transaction_count(self, **constraints): return self.ledger.db.get_transaction_count(account=self, **constraints) - @defer.inlineCallbacks - def fund(self, to_account, amount=None, everything=False, + async def fund(self, to_account, amount=None, everything=False, outputs=1, broadcast=False, **constraints): assert self.ledger == to_account.ledger, 'Can only transfer between accounts of the same ledger.' tx_class = self.ledger.transaction_class if everything: - utxos = yield self.get_utxos(**constraints) - yield self.ledger.reserve_outputs(utxos) - tx = yield tx_class.create( + utxos = await self.get_utxos(**constraints) + await self.ledger.reserve_outputs(utxos) + tx = await tx_class.create( inputs=[tx_class.input_class.spend(txo) for txo in utxos], outputs=[], funding_accounts=[self], change_account=to_account ) elif amount > 0: - to_address = yield to_account.change.get_or_create_usable_address() + to_address = await to_account.change.get_or_create_usable_address() to_hash160 = to_account.ledger.address_to_hash160(to_address) - tx = yield tx_class.create( + tx = await tx_class.create( inputs=[], outputs=[ tx_class.output_class.pay_pubkey_hash(amount//outputs, to_hash160) @@ -406,9 +390,9 @@ class BaseAccount: raise ValueError('An amount is required.') if broadcast: - yield self.ledger.broadcast(tx) + await self.ledger.broadcast(tx) else: - yield self.ledger.release_outputs( + await self.ledger.release_outputs( [txi.txo_ref.txo for txi in tx.inputs] ) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 186c98d56..e6b74ab57 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -1,9 +1,8 @@ import logging -from typing import Tuple, List, Sequence +from typing import Tuple, List import sqlite3 -from twisted.internet import defer -from twisted.enterprise import adbapi +import aiosqlite from torba.hash import TXRefImmutable from torba.basetransaction import BaseTransaction @@ -107,25 +106,21 @@ def row_dict_or_default(rows, fields, default=None): class SQLiteMixin: - CREATE_TABLES_QUERY: Sequence[str] = () + CREATE_TABLES_QUERY: str def __init__(self, path): self._db_path = path - self.db: adbapi.ConnectionPool = None + self.db: aiosqlite.Connection = None self.ledger = None - def open(self): + async def open(self): log.info("connecting to database: %s", self._db_path) - self.db = adbapi.ConnectionPool( - 'sqlite3', self._db_path, cp_min=1, cp_max=1, check_same_thread=False - ) - return self.db.runInteraction( - lambda t: t.executescript(self.CREATE_TABLES_QUERY) - ) + self.db = aiosqlite.connect(self._db_path) + await self.db.__aenter__() + await self.db.executescript(self.CREATE_TABLES_QUERY) - def close(self): - self.db.close() - return defer.succeed(True) + async def close(self): + await self.db.close() @staticmethod def _insert_sql(table: str, data: dict) -> Tuple[str, List]: @@ -247,78 +242,75 @@ class BaseDatabase(SQLiteMixin): 'script': sqlite3.Binary(txo.script.source) } - def save_transaction_io(self, save_tx, tx: BaseTransaction, address, txhash, history): + async def save_transaction_io(self, save_tx, tx: BaseTransaction, address, txhash, history): - def _steps(t): - if save_tx == 'insert': - self.execute(t, *self._insert_sql('tx', { + if save_tx == 'insert': + await self.db.execute(*self._insert_sql('tx', { + 'txid': tx.id, + 'raw': sqlite3.Binary(tx.raw), + 'height': tx.height, + 'position': tx.position, + 'is_verified': tx.is_verified + })) + elif save_tx == 'update': + await self.db.execute(*self._update_sql("tx", { + 'height': tx.height, 'position': tx.position, 'is_verified': tx.is_verified + }, 'txid = ?', (tx.id,))) + + existing_txos = [r[0] for r in await self.db.execute_fetchall(*query( + "SELECT position FROM txo", txid=tx.id + ))] + + for txo in tx.outputs: + if txo.position in existing_txos: + continue + if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == txhash: + await self.db.execute(*self._insert_sql("txo", self.txo_to_row(tx, address, txo))) + elif txo.script.is_pay_script_hash: + # TODO: implement script hash payments + print('Database.save_transaction_io: pay script hash is not implemented!') + + # lookup the address associated with each TXI (via its TXO) + txoid_to_address = {r[0]: r[1] for r in await self.db.execute_fetchall(*query( + "SELECT txoid, address FROM txo", txoid__in=[txi.txo_ref.id for txi in tx.inputs] + ))} + + # list of TXIs that have already been added + existing_txis = [r[0] for r in await self.db.execute_fetchall(*query( + "SELECT txoid FROM txi", txid=tx.id + ))] + + for txi in tx.inputs: + txoid = txi.txo_ref.id + new_txi = txoid not in existing_txis + address_matches = txoid_to_address.get(txoid) == address + if new_txi and address_matches: + await self.db.execute(*self._insert_sql("txi", { 'txid': tx.id, - 'raw': sqlite3.Binary(tx.raw), - 'height': tx.height, - 'position': tx.position, - 'is_verified': tx.is_verified + 'txoid': txoid, + 'address': address, })) - elif save_tx == 'update': - self.execute(t, *self._update_sql("tx", { - 'height': tx.height, 'position': tx.position, 'is_verified': tx.is_verified - }, 'txid = ?', (tx.id,))) - existing_txos = [r[0] for r in self.execute(t, *query( - "SELECT position FROM txo", txid=tx.id - )).fetchall()] + await self._set_address_history(address, history) - for txo in tx.outputs: - if txo.position in existing_txos: - continue - if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == txhash: - self.execute(t, *self._insert_sql("txo", self.txo_to_row(tx, address, txo))) - elif txo.script.is_pay_script_hash: - # TODO: implement script hash payments - print('Database.save_transaction_io: pay script hash is not implemented!') - - # lookup the address associated with each TXI (via its TXO) - txoid_to_address = {r[0]: r[1] for r in self.execute(t, *query( - "SELECT txoid, address FROM txo", txoid__in=[txi.txo_ref.id for txi in tx.inputs] - )).fetchall()} - - # list of TXIs that have already been added - existing_txis = [r[0] for r in self.execute(t, *query( - "SELECT txoid FROM txi", txid=tx.id - )).fetchall()] - - for txi in tx.inputs: - txoid = txi.txo_ref.id - new_txi = txoid not in existing_txis - address_matches = txoid_to_address.get(txoid) == address - if new_txi and address_matches: - self.execute(t, *self._insert_sql("txi", { - 'txid': tx.id, - 'txoid': txoid, - 'address': address, - })) - - self._set_address_history(t, address, history) - - return self.db.runInteraction(_steps) - - def reserve_outputs(self, txos, is_reserved=True): + async def reserve_outputs(self, txos, is_reserved=True): txoids = [txo.id for txo in txos] - return self.run_operation( + await self.db.execute( "UPDATE txo SET is_reserved = ? WHERE txoid IN ({})".format( ', '.join(['?']*len(txoids)) ), [is_reserved]+txoids ) - def release_outputs(self, txos): - return self.reserve_outputs(txos, is_reserved=False) + async def release_outputs(self, txos): + await self.reserve_outputs(txos, is_reserved=False) - def rewind_blockchain(self, above_height): # pylint: disable=no-self-use + async def rewind_blockchain(self, above_height): # pylint: disable=no-self-use # TODO: # 1. delete transactions above_height # 2. update address histories removing deleted TXs - return defer.succeed(True) + return True - def select_transactions(self, cols, account=None, **constraints): + async def select_transactions(self, cols, account=None, **constraints): if 'txid' not in constraints and account is not None: constraints['$account'] = account.public_key.address constraints['txid__in'] = """ @@ -328,13 +320,14 @@ class BaseDatabase(SQLiteMixin): SELECT txi.txid FROM txi JOIN pubkey_address USING (address) WHERE pubkey_address.account = :$account """ - return self.run_query(*query("SELECT {} FROM tx".format(cols), **constraints)) + return await self.db.execute_fetchall( + *query("SELECT {} FROM tx".format(cols), **constraints) + ) - @defer.inlineCallbacks - def get_transactions(self, my_account=None, **constraints): + async def get_transactions(self, my_account=None, **constraints): my_account = my_account or constraints.get('account', None) - tx_rows = yield self.select_transactions( + tx_rows = await self.select_transactions( 'txid, raw, height, position, is_verified', order_by=["height DESC", "position DESC"], **constraints @@ -352,7 +345,7 @@ class BaseDatabase(SQLiteMixin): annotated_txos = { txo.id: txo for txo in - (yield self.get_txos( + (await self.get_txos( my_account=my_account, txid__in=txids )) @@ -360,7 +353,7 @@ class BaseDatabase(SQLiteMixin): referenced_txos = { txo.id: txo for txo in - (yield self.get_txos( + (await self.get_txos( my_account=my_account, txoid__in=query("SELECT txoid FROM txi", **{'txid__in': txids})[0] )) @@ -380,33 +373,30 @@ class BaseDatabase(SQLiteMixin): return txs - @defer.inlineCallbacks - def get_transaction_count(self, **constraints): + async def get_transaction_count(self, **constraints): constraints.pop('offset', None) constraints.pop('limit', None) constraints.pop('order_by', None) - count = yield self.select_transactions('count(*)', **constraints) + count = await self.select_transactions('count(*)', **constraints) return count[0][0] - @defer.inlineCallbacks - def get_transaction(self, **constraints): - txs = yield self.get_transactions(limit=1, **constraints) + async def get_transaction(self, **constraints): + txs = await self.get_transactions(limit=1, **constraints) if txs: return txs[0] - def select_txos(self, cols, **constraints): - return self.run_query(*query( + async def select_txos(self, cols, **constraints): + return await self.db.execute_fetchall(*query( "SELECT {} FROM txo" " JOIN pubkey_address USING (address)" " JOIN tx USING (txid)".format(cols), **constraints )) - @defer.inlineCallbacks - def get_txos(self, my_account=None, **constraints): + async def get_txos(self, my_account=None, **constraints): my_account = my_account or constraints.get('account', None) if isinstance(my_account, BaseAccount): my_account = my_account.public_key.address - rows = yield self.select_txos( + rows = await self.select_txos( "amount, script, txid, tx.height, txo.position, chain, account", **constraints ) output_class = self.ledger.transaction_class.output_class @@ -421,12 +411,11 @@ class BaseDatabase(SQLiteMixin): ) for row in rows ] - @defer.inlineCallbacks - def get_txo_count(self, **constraints): + async def get_txo_count(self, **constraints): constraints.pop('offset', None) constraints.pop('limit', None) constraints.pop('order_by', None) - count = yield self.select_txos('count(*)', **constraints) + count = await self.select_txos('count(*)', **constraints) return count[0][0] @staticmethod @@ -442,37 +431,33 @@ class BaseDatabase(SQLiteMixin): self.constrain_utxo(constraints) return self.get_txo_count(**constraints) - @defer.inlineCallbacks - def get_balance(self, **constraints): + async def get_balance(self, **constraints): self.constrain_utxo(constraints) - balance = yield self.select_txos('SUM(amount)', **constraints) + balance = await self.select_txos('SUM(amount)', **constraints) return balance[0][0] or 0 - def select_addresses(self, cols, **constraints): - return self.run_query(*query( - "SELECT {} FROM pubkey_address".format(cols), **constraints - )) + async def select_addresses(self, cols, **constraints): + return await self.db.execute_fetchall(*query( + "SELECT {} FROM pubkey_address".format(cols), **constraints + )) - @defer.inlineCallbacks - def get_addresses(self, cols=('address', 'account', 'chain', 'position', 'used_times'), **constraints): - addresses = yield self.select_addresses(', '.join(cols), **constraints) + async def get_addresses(self, cols=('address', 'account', 'chain', 'position', 'used_times'), **constraints): + addresses = await self.select_addresses(', '.join(cols), **constraints) return rows_to_dict(addresses, cols) - @defer.inlineCallbacks - def get_address_count(self, **constraints): - count = yield self.select_addresses('count(*)', **constraints) + async def get_address_count(self, **constraints): + count = await self.select_addresses('count(*)', **constraints) return count[0][0] - @defer.inlineCallbacks - def get_address(self, **constraints): - addresses = yield self.get_addresses( + async def get_address(self, **constraints): + addresses = await self.get_addresses( cols=('address', 'account', 'chain', 'position', 'pubkey', 'history', 'used_times'), limit=1, **constraints ) if addresses: return addresses[0] - def add_keys(self, account, chain, keys): + async def add_keys(self, account, chain, keys): sql = ( "insert into pubkey_address " "(address, account, chain, position, pubkey) " @@ -484,14 +469,13 @@ class BaseDatabase(SQLiteMixin): pubkey.address, account.public_key.address, chain, position, sqlite3.Binary(pubkey.pubkey_bytes) )) - return self.run_operation(sql, values) + await self.db.execute(sql, values) - @classmethod - def _set_address_history(cls, t, address, history): - cls.execute( - t, "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", + async def _set_address_history(self, address, history): + await self.db.execute( + "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", (history, history.count(':')//2, address) ) - def set_address_history(self, address, history): - return self.db.runInteraction(lambda t: self._set_address_history(t, address, history)) + async def set_address_history(self, address, history): + await self._set_address_history(address, history) diff --git a/torba/baseheader.py b/torba/baseheader.py index 9fca794f0..5526c3fb6 100644 --- a/torba/baseheader.py +++ b/torba/baseheader.py @@ -1,11 +1,10 @@ import os +import asyncio import logging from io import BytesIO from typing import Optional, Iterator, Tuple from binascii import hexlify -from twisted.internet import threads, defer - from torba.util import ArithUint256 from torba.hash import double_sha256 @@ -36,16 +35,14 @@ class BaseHeaders: self.io = BytesIO() self.path = path self._size: Optional[int] = None - self._header_connect_lock = defer.DeferredLock() + self._header_connect_lock = asyncio.Lock() - def open(self): + async def open(self): if self.path != ':memory:': self.io = open(self.path, 'a+b') - return defer.succeed(True) - def close(self): + async def close(self): self.io.close() - return defer.succeed(True) @staticmethod def serialize(header: dict) -> bytes: @@ -95,16 +92,15 @@ class BaseHeaders: return b'0' * 64 return hexlify(double_sha256(header)[::-1]) - @defer.inlineCallbacks - def connect(self, start: int, headers: bytes): + async def connect(self, start: int, headers: bytes) -> int: added = 0 bail = False - yield self._header_connect_lock.acquire() - try: + loop = asyncio.get_running_loop() + async with self._header_connect_lock: for height, chunk in self._iterate_chunks(start, headers): try: # validate_chunk() is CPU bound and reads previous chunks from file system - yield threads.deferToThread(self.validate_chunk, height, chunk) + await loop.run_in_executor(None, self.validate_chunk, height, chunk) except InvalidHeader as e: bail = True chunk = chunk[:(height-e.height+1)*self.header_size] @@ -115,14 +111,12 @@ class BaseHeaders: self.io.truncate() # .seek()/.write()/.truncate() might also .flush() when needed # the goal here is mainly to ensure we're definitely flush()'ing - yield threads.deferToThread(self.io.flush) + await loop.run_in_executor(None, self.io.flush) self._size = None added += written if bail: break - finally: - self._header_connect_lock.release() - defer.returnValue(added) + return added def validate_chunk(self, height, chunk): previous_hash, previous_header, previous_previous_header = None, None, None diff --git a/torba/baseledger.py b/torba/baseledger.py index ab99bd3ca..b168e1ec6 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -1,4 +1,5 @@ import os +import asyncio import logging from binascii import hexlify, unhexlify from io import StringIO @@ -7,8 +8,6 @@ from typing import Dict, Type, Iterable from operator import itemgetter from collections import namedtuple -from twisted.internet import defer - from torba import baseaccount from torba import basenetwork from torba import basetransaction @@ -104,8 +103,8 @@ class BaseLedger(metaclass=LedgerRegistry): ) self._transaction_processing_locks = {} - self._utxo_reservation_lock = defer.DeferredLock() - self._header_processing_lock = defer.DeferredLock() + self._utxo_reservation_lock = asyncio.Lock() + self._header_processing_lock = asyncio.Lock() @classmethod def get_id(cls): @@ -135,41 +134,32 @@ class BaseLedger(metaclass=LedgerRegistry): def add_account(self, account: baseaccount.BaseAccount): self.accounts.append(account) - @defer.inlineCallbacks - def get_private_key_for_address(self, address): - match = yield self.db.get_address(address=address) + async def get_private_key_for_address(self, address): + match = await self.db.get_address(address=address) if match: for account in self.accounts: if match['account'] == account.public_key.address: return account.get_private_key(match['chain'], match['position']) - @defer.inlineCallbacks - def get_effective_amount_estimators(self, funding_accounts: Iterable[baseaccount.BaseAccount]): + async def get_effective_amount_estimators(self, funding_accounts: Iterable[baseaccount.BaseAccount]): estimators = [] for account in funding_accounts: - utxos = yield account.get_utxos() + utxos = await account.get_utxos() for utxo in utxos: estimators.append(utxo.get_estimator(self)) return estimators - @defer.inlineCallbacks - def get_spendable_utxos(self, amount: int, funding_accounts): - yield self._utxo_reservation_lock.acquire() - try: - txos = yield self.get_effective_amount_estimators(funding_accounts) + async def get_spendable_utxos(self, amount: int, funding_accounts): + async with self._utxo_reservation_lock: + txos = await self.get_effective_amount_estimators(funding_accounts) selector = CoinSelector( txos, amount, self.transaction_class.output_class.pay_pubkey_hash(COIN, NULL_HASH32).get_fee(self) ) spendables = selector.select() if spendables: - yield self.reserve_outputs(s.txo for s in spendables) - except Exception: - log.exception('Failed to get spendable utxos:') - raise - finally: - self._utxo_reservation_lock.release() - return spendables + await self.reserve_outputs(s.txo for s in spendables) + return spendables def reserve_outputs(self, txos): return self.db.reserve_outputs(txos) @@ -177,16 +167,14 @@ class BaseLedger(metaclass=LedgerRegistry): def release_outputs(self, txos): return self.db.release_outputs(txos) - @defer.inlineCallbacks - def get_local_status(self, address): - address_details = yield self.db.get_address(address=address) + async def get_local_status(self, address): + address_details = await self.db.get_address(address=address) history = address_details['history'] or '' h = sha256(history.encode()) return hexlify(h) - @defer.inlineCallbacks - def get_local_history(self, address): - address_details = yield self.db.get_address(address=address) + async def get_local_history(self, address): + address_details = await self.db.get_address(address=address) history = address_details['history'] or '' parts = history.split(':')[:-1] return list(zip(parts[0::2], map(int, parts[1::2]))) @@ -203,43 +191,40 @@ class BaseLedger(metaclass=LedgerRegistry): working_branch = double_sha256(combined) return hexlify(working_branch[::-1]) - def validate_transaction_and_set_position(self, tx, height, merkle): + async def validate_transaction_and_set_position(self, tx, height): if not height <= len(self.headers): return False + merkle = await self.network.get_merkle(tx.id, height) merkle_root = self.get_root_of_merkle_tree(merkle['merkle'], merkle['pos'], tx.hash) header = self.headers[height] tx.position = merkle['pos'] tx.is_verified = merkle_root == header['merkle_root'] - @defer.inlineCallbacks - def start(self): + async def start(self): if not os.path.exists(self.path): os.mkdir(self.path) - yield defer.gatherResults([ + await asyncio.gather( self.db.open(), self.headers.open() - ]) + ) first_connection = self.network.on_connected.first - self.network.start() - yield first_connection - yield self.join_network() + asyncio.ensure_future(self.network.start()) + await first_connection + await self.join_network() self.network.on_connected.listen(self.join_network) - @defer.inlineCallbacks - def join_network(self, *args): + async def join_network(self, *args): log.info("Subscribing and updating accounts.") - yield self.update_headers() - yield self.network.subscribe_headers() - yield self.update_accounts() + await self.update_headers() + await self.network.subscribe_headers() + await self.update_accounts() - @defer.inlineCallbacks - def stop(self): - yield self.network.stop() - yield self.db.close() - yield self.headers.close() + async def stop(self): + await self.network.stop() + await self.db.close() + await self.headers.close() - @defer.inlineCallbacks - def update_headers(self, height=None, headers=None, subscription_update=False): + async def update_headers(self, height=None, headers=None, subscription_update=False): rewound = 0 while True: @@ -251,14 +236,14 @@ class BaseLedger(metaclass=LedgerRegistry): subscription_update = False if not headers: - header_response = yield self.network.get_headers(height, 2001) + header_response = await self.network.get_headers(height, 2001) headers = header_response['hex'] if not headers: # Nothing to do, network thinks we're already at the latest height. return - added = yield self.headers.connect(height, unhexlify(headers)) + added = await self.headers.connect(height, unhexlify(headers)) if added > 0: height += added self._on_header_controller.add( @@ -268,7 +253,7 @@ class BaseLedger(metaclass=LedgerRegistry): # we started rewinding blocks and apparently found # a new chain rewound = 0 - yield self.db.rewind_blockchain(height) + await self.db.rewind_blockchain(height) if subscription_update: # subscription updates are for latest header already @@ -310,66 +295,37 @@ class BaseLedger(metaclass=LedgerRegistry): # robust sync, turn off subscription update shortcut subscription_update = False - @defer.inlineCallbacks - def receive_header(self, response): - yield self._header_processing_lock.acquire() - try: + async def receive_header(self, response): + async with self._header_processing_lock: header = response[0] - yield self.update_headers( + await self.update_headers( height=header['height'], headers=header['hex'], subscription_update=True ) - finally: - self._header_processing_lock.release() - def update_accounts(self): - return defer.DeferredList([ + async def update_accounts(self): + return await asyncio.gather(*( self.update_account(a) for a in self.accounts - ]) + )) - @defer.inlineCallbacks - def update_account(self, account): # type: (baseaccount.BaseAccount) -> defer.Defferred + async def update_account(self, account: baseaccount.BaseAccount): # Before subscribing, download history for any addresses that don't have any, # this avoids situation where we're getting status updates to addresses we know # need to update anyways. Continue to get history and create more addresses until # all missing addresses are created and history for them is fully restored. - yield account.ensure_address_gap() - addresses = yield account.get_addresses(used_times=0) + await account.ensure_address_gap() + addresses = await account.get_addresses(used_times=0) while addresses: - yield defer.DeferredList([ - self.update_history(a) for a in addresses - ]) - addresses = yield account.ensure_address_gap() + await asyncio.gather(*(self.update_history(a) for a in addresses)) + addresses = await account.ensure_address_gap() # By this point all of the addresses should be restored and we # can now subscribe all of them to receive updates. - all_addresses = yield account.get_addresses() - yield defer.DeferredList( - list(map(self.subscribe_history, all_addresses)) - ) + all_addresses = await account.get_addresses() + await asyncio.gather(*(self.subscribe_history(a) for a in all_addresses)) - @defer.inlineCallbacks - def _prefetch_history(self, remote_history, local_history): - proofs, network_txs, deferreds = {}, {}, [] - for i, (hex_id, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): - if i < len(local_history) and local_history[i] == (hex_id, remote_height): - continue - if remote_height > 0: - deferreds.append( - self.network.get_merkle(hex_id, remote_height).addBoth( - lambda result, txid: proofs.__setitem__(txid, result), hex_id) - ) - deferreds.append( - self.network.get_transaction(hex_id).addBoth( - lambda result, txid: network_txs.__setitem__(txid, result), hex_id) - ) - yield defer.DeferredList(deferreds) - return proofs, network_txs - - @defer.inlineCallbacks - def update_history(self, address): - remote_history = yield self.network.get_history(address) - local_history = yield self.get_local_history(address) - proofs, network_txs = yield self._prefetch_history(remote_history, local_history) + async def update_history(self, address): + remote_history = await self.network.get_history(address) + local_history = await self.get_local_history(address) synced_history = StringIO() for i, (hex_id, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): @@ -379,30 +335,29 @@ class BaseLedger(metaclass=LedgerRegistry): if i < len(local_history) and local_history[i] == (hex_id, remote_height): continue - lock = self._transaction_processing_locks.setdefault(hex_id, defer.DeferredLock()) + lock = self._transaction_processing_locks.setdefault(hex_id, asyncio.Lock()) - yield lock.acquire() + await lock.acquire() try: # see if we have a local copy of transaction, otherwise fetch it from server - tx = yield self.db.get_transaction(txid=hex_id) + tx = await self.db.get_transaction(txid=hex_id) save_tx = None if tx is None: - _raw = network_txs[hex_id] + _raw = await self.network.get_transaction(hex_id) tx = self.transaction_class(unhexlify(_raw)) save_tx = 'insert' tx.height = remote_height if remote_height > 0 and (not tx.is_verified or tx.position == -1): - self.validate_transaction_and_set_position(tx, remote_height, proofs[hex_id]) + await self.validate_transaction_and_set_position(tx, remote_height) if save_tx is None: save_tx = 'update' - yield self.db.save_transaction_io( - save_tx, tx, address, self.address_to_hash160(address), - synced_history.getvalue() + await self.db.save_transaction_io( + save_tx, tx, address, self.address_to_hash160(address), synced_history.getvalue() ) log.debug( @@ -412,28 +367,22 @@ class BaseLedger(metaclass=LedgerRegistry): self._on_transaction_controller.add(TransactionEvent(address, tx)) - except Exception: - log.exception('Failed to synchronize transaction:') - raise - finally: lock.release() - if not lock.locked and hex_id in self._transaction_processing_locks: + if not lock.locked() and hex_id in self._transaction_processing_locks: del self._transaction_processing_locks[hex_id] - @defer.inlineCallbacks - def subscribe_history(self, address): - remote_status = yield self.network.subscribe_address(address) - local_status = yield self.get_local_status(address) + async def subscribe_history(self, address): + remote_status = await self.network.subscribe_address(address) + local_status = await self.get_local_status(address) if local_status != remote_status: - yield self.update_history(address) + await self.update_history(address) - @defer.inlineCallbacks - def receive_status(self, response): + async def receive_status(self, response): address, remote_status = response - local_status = yield self.get_local_status(address) + local_status = await self.get_local_status(address) if local_status != remote_status: - yield self.update_history(address) + await self.update_history(address) def broadcast(self, tx): return self.network.broadcast(hexlify(tx.raw).decode()) diff --git a/torba/basemanager.py b/torba/basemanager.py index 40e2acafa..706a6b296 100644 --- a/torba/basemanager.py +++ b/torba/basemanager.py @@ -1,6 +1,6 @@ +import asyncio import logging from typing import Type, MutableSequence, MutableMapping -from twisted.internet import defer from torba.baseledger import BaseLedger, LedgerRegistry from torba.wallet import Wallet, WalletStorage @@ -41,11 +41,10 @@ class BaseWalletManager: self.wallets.append(wallet) return wallet - @defer.inlineCallbacks - def get_detailed_accounts(self, confirmations=6, show_seed=False): + async def get_detailed_accounts(self, confirmations=6, show_seed=False): ledgers = {} for i, account in enumerate(self.accounts): - details = yield account.get_details(confirmations=confirmations, show_seed=True) + details = await account.get_details(confirmations=confirmations, show_seed=True) details['is_default_account'] = i == 0 ledger_id = account.ledger.get_id() ledgers.setdefault(ledger_id, []) @@ -68,16 +67,14 @@ class BaseWalletManager: for account in wallet.accounts: yield account - @defer.inlineCallbacks - def start(self): + async def start(self): self.running = True - yield defer.DeferredList([ + await asyncio.gather(*( l.start() for l in self.ledgers.values() - ]) + )) - @defer.inlineCallbacks - def stop(self): - yield defer.DeferredList([ + async def stop(self): + await asyncio.gather(*( l.stop() for l in self.ledgers.values() - ]) + )) self.running = False diff --git a/torba/basenetwork.py b/torba/basenetwork.py index 452386120..689cab088 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -1,145 +1,36 @@ -import json -import socket import logging from itertools import cycle -from twisted.internet import defer, reactor, protocol -from twisted.application.internet import ClientService, CancelledError -from twisted.internet.endpoints import clientFromString -from twisted.protocols.basic import LineOnlyReceiver -from twisted.python import failure + +from aiorpcx import ClientSession as BaseClientSession from torba import __version__ from torba.stream import StreamController -from torba.constants import TIMEOUT log = logging.getLogger(__name__) -class StratumClientProtocol(LineOnlyReceiver): - delimiter = b'\n' - MAX_LENGTH = 2000000 +class ClientSession(BaseClientSession): - def __init__(self): - self.request_id = 0 - self.lookup_table = {} - self.session = {} - self.network = None - - self.on_disconnected_controller = StreamController() - self.on_disconnected = self.on_disconnected_controller.stream - - def _get_id(self): - self.request_id += 1 - return self.request_id - - @property - def _ip(self): - return self.transport.getPeer().host - - def get_session(self): - return self.session - - def connectionMade(self): - try: - self.transport.setTcpNoDelay(True) - self.transport.setTcpKeepAlive(True) - if hasattr(socket, "TCP_KEEPIDLE"): - self.transport.socket.setsockopt( - socket.SOL_TCP, socket.TCP_KEEPIDLE, 120 - # Seconds before sending keepalive probes - ) - else: - log.debug("TCP_KEEPIDLE not available") - if hasattr(socket, "TCP_KEEPINTVL"): - self.transport.socket.setsockopt( - socket.SOL_TCP, socket.TCP_KEEPINTVL, 1 - # Interval in seconds between keepalive probes - ) - else: - log.debug("TCP_KEEPINTVL not available") - if hasattr(socket, "TCP_KEEPCNT"): - self.transport.socket.setsockopt( - socket.SOL_TCP, socket.TCP_KEEPCNT, 5 - # Failed keepalive probles before declaring other end dead - ) - else: - log.debug("TCP_KEEPCNT not available") - - except Exception as err: # pylint: disable=broad-except - # Supported only by the socket transport, - # but there's really no better place in code to trigger this. - log.warning("Error setting up socket: %s", err) - - def connectionLost(self, reason=None): - self.connected = 0 - self.on_disconnected_controller.add(True) - for deferred in self.lookup_table.values(): - if not deferred.called: - deferred.errback(TimeoutError("Connection dropped.")) - - def lineReceived(self, line): - log.debug('received: %s', line) - - try: - message = json.loads(line) - except (ValueError, TypeError): - raise ValueError("Cannot decode message '{}'".format(line.strip())) - - if message.get('id'): - try: - d = self.lookup_table.pop(message['id']) - if message.get('error'): - d.errback(RuntimeError(message['error'])) - else: - d.callback(message.get('result')) - except KeyError: - raise LookupError( - "Lookup for deferred object for message ID '{}' failed.".format(message['id'])) - elif message.get('method') in self.network.subscription_controllers: - controller = self.network.subscription_controllers[message['method']] - controller.add(message.get('params')) - else: - log.warning("Cannot handle message '%s'", line) - - def rpc(self, method, *args): - message_id = self._get_id() - message = json.dumps({ - 'id': message_id, - 'method': method, - 'params': args - }) - log.debug('sent: %s', message) - self.sendLine(message.encode('latin-1')) - d = self.lookup_table[message_id] = defer.Deferred() - d.addTimeout( - TIMEOUT, reactor, onTimeoutCancel=lambda *_: failure.Failure(TimeoutError( - "Timeout: Stratum request for '%s' took more than %s seconds" % (method, TIMEOUT))) - ) - return d - - -class StratumClientFactory(protocol.ClientFactory): - - protocol = StratumClientProtocol - - def __init__(self, network): + def __init__(self, *args, network, **kwargs): self.network = network - self.client = None + super().__init__(*args, **kwargs) + self._on_disconnect_controller = StreamController() + self.on_disconnected = self._on_disconnect_controller.stream - def buildProtocol(self, addr): - client = self.protocol() - client.factory = self - client.network = self.network - self.client = client - return client + async def handle_request(self, request): + controller = self.network.subscription_controllers[request.method] + controller.add(request.args) + + def connection_lost(self, exc): + super().connection_lost(exc) + self._on_disconnect_controller.add(True) class BaseNetwork: def __init__(self, ledger): self.config = ledger.config - self.client = None - self.service = None + self.client: ClientSession = None self.running = False self._on_connected_controller = StreamController() @@ -156,48 +47,35 @@ class BaseNetwork: 'blockchain.address.subscribe': self._on_status_controller, } - @defer.inlineCallbacks - def start(self): + async def start(self): self.running = True for server in cycle(self.config['default_servers']): connection_string = 'tcp:{}:{}'.format(*server) - endpoint = clientFromString(reactor, connection_string) - log.debug("Attempting connection to SPV wallet server: %s", connection_string) - self.service = ClientService(endpoint, StratumClientFactory(self)) - self.service.startService() + self.client = ClientSession(*server, network=self) try: - self.client = yield self.service.whenConnected(failAfterFailures=2) - yield self.ensure_server_version() - log.info("Successfully connected to SPV wallet server: %s", connection_string) + await self.client.create_connection() + await self.ensure_server_version() + log.info("Successfully connected to SPV wallet server: %s", ) self._on_connected_controller.add(True) - yield self.client.on_disconnected.first - except CancelledError: - return + await self.client.on_disconnected.first except Exception: # pylint: disable=broad-except log.exception("Connecting to %s raised an exception:", connection_string) - finally: - self.client = None - if self.service is not None: - self.service.stopService() if not self.running: return - def stop(self): + async def stop(self): self.running = False - if self.service is not None: - self.service.stopService() if self.is_connected: - return self.client.on_disconnected.first - else: - return defer.succeed(True) + await self.client.close() + await self.client.on_disconnected.first @property def is_connected(self): - return self.client is not None and self.client.connected + return self.client is not None and not self.client.is_closing() def rpc(self, list_or_method, *args): if self.is_connected: - return self.client.rpc(list_or_method, *args) + return self.client.send_request(list_or_method, args) else: raise ConnectionError("Attempting to send rpc request when connection is not available.") diff --git a/torba/basetransaction.py b/torba/basetransaction.py index a5fa2fce1..dca0fb2f8 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -3,8 +3,6 @@ import typing from typing import List, Iterable, Optional from binascii import hexlify -from twisted.internet import defer - from torba.basescript import BaseInputScript, BaseOutputScript from torba.baseaccount import BaseAccount from torba.constants import COIN, NULL_HASH32 @@ -426,8 +424,7 @@ class BaseTransaction: return ledger @classmethod - @defer.inlineCallbacks - def create(cls, inputs: Iterable[BaseInput], outputs: Iterable[BaseOutput], + async def create(cls, inputs: Iterable[BaseInput], outputs: Iterable[BaseOutput], funding_accounts: Iterable[BaseAccount], change_account: BaseAccount): """ Find optimal set of inputs when only outputs are provided; add change outputs if only inputs are provided or if inputs are greater than outputs. """ @@ -450,7 +447,7 @@ class BaseTransaction: if payment < cost: deficit = cost - payment - spendables = yield ledger.get_spendable_utxos(deficit, funding_accounts) + spendables = await ledger.get_spendable_utxos(deficit, funding_accounts) if not spendables: raise ValueError('Not enough funds to cover this transaction.') payment += sum(s.effective_amount for s in spendables) @@ -463,28 +460,27 @@ class BaseTransaction: ) change = payment - cost if change > cost_of_change: - change_address = yield change_account.change.get_or_create_usable_address() + change_address = await change_account.change.get_or_create_usable_address() change_hash160 = change_account.ledger.address_to_hash160(change_address) change_amount = change - cost_of_change change_output = cls.output_class.pay_pubkey_hash(change_amount, change_hash160) change_output.is_change = True tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) - yield tx.sign(funding_accounts) + await tx.sign(funding_accounts) except Exception as e: log.exception('Failed to synchronize transaction:') - yield ledger.release_outputs(tx.outputs) + await ledger.release_outputs(tx.outputs) raise e - defer.returnValue(tx) + return tx @staticmethod def signature_hash_type(hash_type): return hash_type - @defer.inlineCallbacks - def sign(self, funding_accounts: Iterable[BaseAccount]) -> defer.Deferred: + async def sign(self, funding_accounts: Iterable[BaseAccount]): ledger = self.ensure_all_have_same_ledger(funding_accounts) for i, txi in enumerate(self._inputs): assert txi.script is not None @@ -492,7 +488,7 @@ class BaseTransaction: txo_script = txi.txo_ref.txo.script if txo_script.is_pay_pubkey_hash: address = ledger.hash160_to_address(txo_script.values['pubkey_hash']) - private_key = yield ledger.get_private_key_for_address(address) + private_key = await ledger.get_private_key_for_address(address) tx = self._serialize_for_signature(i) txi.script.values['signature'] = \ private_key.sign(tx) + bytes((self.signature_hash_type(1),)) diff --git a/torba/stream.py b/torba/stream.py index 79fbba796..64c1f5e10 100644 --- a/torba/stream.py +++ b/torba/stream.py @@ -1,6 +1,4 @@ import asyncio -from twisted.internet.defer import Deferred -from twisted.python.failure import Failure class BroadcastSubscription: @@ -31,11 +29,13 @@ class BroadcastSubscription: def _add(self, data): if self.can_fire and self._on_data is not None: - self._on_data(data) + maybe_coroutine = self._on_data(data) + if asyncio.iscoroutine(maybe_coroutine): + asyncio.ensure_future(maybe_coroutine) - def _add_error(self, error, traceback): + def _add_error(self, exception): if self.can_fire and self._on_error is not None: - self._on_error(error, traceback) + self._on_error(exception) def _close(self): if self.can_fire and self._on_done is not None: @@ -66,9 +66,9 @@ class StreamController: for subscription in self._iterate_subscriptions: subscription._add(event) - def add_error(self, error, traceback): + def add_error(self, exception): for subscription in self._iterate_subscriptions: - subscription._add_error(error, traceback) + subscription._add_error(exception) def close(self): for subscription in self._iterate_subscriptions: @@ -108,38 +108,35 @@ class Stream: def listen(self, on_data, on_error=None, on_done=None): return self._controller._listen(on_data, on_error, on_done) - def deferred_where(self, condition): - deferred = Deferred() + def where(self, condition) -> asyncio.Future: + future = asyncio.get_event_loop().create_future() def where_test(value): if condition(value): - self._cancel_and_callback(subscription, deferred, value) + self._cancel_and_callback(subscription, future, value) subscription = self.listen( where_test, - lambda error, traceback: self._cancel_and_error(subscription, deferred, error, traceback) + lambda exception: self._cancel_and_error(subscription, future, exception) ) - return deferred - - def where(self, condition): - return self.deferred_where(condition).asFuture(asyncio.get_event_loop()) + return future @property def first(self): - deferred = Deferred() + future = asyncio.get_event_loop().create_future() subscription = self.listen( - lambda value: self._cancel_and_callback(subscription, deferred, value), - lambda error, traceback: self._cancel_and_error(subscription, deferred, error, traceback) + lambda value: self._cancel_and_callback(subscription, future, value), + lambda exception: self._cancel_and_error(subscription, future, exception) ) - return deferred + return future @staticmethod - def _cancel_and_callback(subscription, deferred, value): + def _cancel_and_callback(subscription: BroadcastSubscription, future: asyncio.Future, value): subscription.cancel() - deferred.callback(value) + future.set_result(value) @staticmethod - def _cancel_and_error(subscription, deferred, error, traceback): + def _cancel_and_error(subscription: BroadcastSubscription, future: asyncio.Future, exception): subscription.cancel() - deferred.errback(Failure(error, exc_tb=traceback)) + future.set_exception(exception) From e10f1df3211c428afe2c5d6b2eeb91cc7a9b3f11 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 15 Oct 2018 00:04:25 -0400 Subject: [PATCH 180/383] pylint and mypy fixes --- .travis.yml | 2 +- setup.py | 5 +++-- torba/baseaccount.py | 2 +- torba/basedatabase.py | 22 +++++++--------------- torba/basetransaction.py | 2 +- 5 files changed, 13 insertions(+), 20 deletions(-) diff --git a/.travis.yml b/.travis.yml index 7be2faefb..420998b74 100644 --- a/.travis.yml +++ b/.travis.yml @@ -14,7 +14,7 @@ jobs: - pip install -e . script: - pylint --rcfile=setup.cfg torba - - mypy torba + - mypy --ignore-missing-imports torba after_success: skip - &tests diff --git a/setup.py b/setup.py index f5b827c0c..5d42d03f9 100644 --- a/setup.py +++ b/setup.py @@ -12,7 +12,7 @@ setup( description='Wallet library for bitcoin based currencies.', keywords='wallet,crypto,currency,money,bitcoin,lbry', classifiers=( - 'Framework :: Twisted', + 'Framework :: AsyncIO', 'Intended Audience :: Developers', 'Intended Audience :: System Administrators', 'License :: OSI Approved :: MIT License', @@ -26,7 +26,8 @@ setup( packages=find_packages(exclude=('tests',)), python_requires='>=3.6', install_requires=( - 'twisted', + 'aiorpcx', + 'aiosqlite', 'coincurve', 'pbkdf2', 'cryptography' diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 7369f9394..7551c39c8 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -362,7 +362,7 @@ class BaseAccount: return self.ledger.db.get_transaction_count(account=self, **constraints) async def fund(self, to_account, amount=None, everything=False, - outputs=1, broadcast=False, **constraints): + outputs=1, broadcast=False, **constraints): assert self.ledger == to_account.ledger, 'Can only transfer between accounts of the same ledger.' tx_class = self.ledger.transaction_class if everything: diff --git a/torba/basedatabase.py b/torba/basedatabase.py index e6b74ab57..1493d3c32 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -1,5 +1,5 @@ import logging -from typing import Tuple, List +from typing import Tuple, List, Union import sqlite3 import aiosqlite @@ -134,7 +134,8 @@ class SQLiteMixin: return sql, values @staticmethod - def _update_sql(table: str, data: dict, where: str, constraints: list) -> Tuple[str, list]: + def _update_sql(table: str, data: dict, where: str, + constraints: Union[list, tuple]) -> Tuple[str, list]: columns, values = [], [] for column, value in data.items(): columns.append("{} = ?".format(column)) @@ -151,16 +152,6 @@ class SQLiteMixin: log.debug(values) return t.execute(sql, values) - def run_operation(self, sql, values): - log.debug(sql) - log.debug(values) - return self.db.runOperation(sql, values) - - def run_query(self, sql, values): - log.debug(sql) - log.debug(values) - return self.db.runQuery(sql, values) - class BaseDatabase(SQLiteMixin): @@ -438,10 +429,11 @@ class BaseDatabase(SQLiteMixin): async def select_addresses(self, cols, **constraints): return await self.db.execute_fetchall(*query( - "SELECT {} FROM pubkey_address".format(cols), **constraints - )) + "SELECT {} FROM pubkey_address".format(cols), **constraints + )) - async def get_addresses(self, cols=('address', 'account', 'chain', 'position', 'used_times'), **constraints): + async def get_addresses(self, cols=('address', 'account', 'chain', 'position', 'used_times'), + **constraints): addresses = await self.select_addresses(', '.join(cols), **constraints) return rows_to_dict(addresses, cols) diff --git a/torba/basetransaction.py b/torba/basetransaction.py index dca0fb2f8..3ac582b88 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -425,7 +425,7 @@ class BaseTransaction: @classmethod async def create(cls, inputs: Iterable[BaseInput], outputs: Iterable[BaseOutput], - funding_accounts: Iterable[BaseAccount], change_account: BaseAccount): + funding_accounts: Iterable[BaseAccount], change_account: BaseAccount): """ Find optimal set of inputs when only outputs are provided; add change outputs if only inputs are provided or if inputs are greater than outputs. """ From 2cd1947ef597ed2ad4d7ba56d1a0345fa0525680 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 15 Oct 2018 00:45:21 -0400 Subject: [PATCH 181/383] fixing tests --- tests/integration/test_reconnect.py | 11 +++++------ tests/unit/test_bip32.py | 11 ++++++----- tests/unit/test_coinselection.py | 12 ++++++++---- tests/unit/test_script.py | 2 +- tests/unit/test_wallet.py | 7 ++++--- torba/basenetwork.py | 3 ++- tox.ini | 6 +++--- 7 files changed, 29 insertions(+), 23 deletions(-) diff --git a/tests/integration/test_reconnect.py b/tests/integration/test_reconnect.py index bb8c9b8ac..18b41e868 100644 --- a/tests/integration/test_reconnect.py +++ b/tests/integration/test_reconnect.py @@ -1,5 +1,4 @@ -import asyncio -from orchstr8.testcase import IntegrationTestCase, d2f +from orchstr8.testcase import IntegrationTestCase from torba.constants import COIN @@ -8,7 +7,7 @@ class ReconnectTests(IntegrationTestCase): VERBOSE = False async def test_connection_drop_still_receives_events_after_reconnected(self): - address1 = await d2f(self.account.receiving.get_or_create_usable_address()) + address1 = await self.account.receiving.get_or_create_usable_address() self.ledger.network.client.connectionLost() sendtxid = await self.blockchain.send_to_address(address1, 1.1337) await self.on_transaction_id(sendtxid) # mempool @@ -21,13 +20,13 @@ class ReconnectTests(IntegrationTestCase): # what's that smoke on my ethernet cable? oh no! self.ledger.network.client.connectionLost() with self.assertRaisesRegex(TimeoutError, 'Connection dropped'): - await d2f(d) + await d # rich but offline? no way, no water, let's retry with self.assertRaisesRegex(ConnectionError, 'connection is not available'): - await d2f(self.ledger.network.get_transaction(sendtxid)) + await self.ledger.network.get_transaction(sendtxid) # * goes to pick some water outside... * time passes by and another donation comes in sendtxid = await self.blockchain.send_to_address(address1, 42) await self.blockchain.generate(1) # omg, the burned cable still works! torba is fire proof! - await d2f(self.ledger.network.get_transaction(sendtxid)) + await self.ledger.network.get_transaction(sendtxid) diff --git a/tests/unit/test_bip32.py b/tests/unit/test_bip32.py index b96c5a894..1d3229f09 100644 --- a/tests/unit/test_bip32.py +++ b/tests/unit/test_bip32.py @@ -1,12 +1,13 @@ -import unittest from binascii import unhexlify, hexlify +from orchstr8.testcase import AsyncioTestCase + from .key_fixtures import expected_ids, expected_privkeys, expected_hardened_privkeys from torba.bip32 import PubKey, PrivateKey, from_extended_key_string from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class -class BIP32Tests(unittest.TestCase): +class BIP32Tests(AsyncioTestCase): def test_pubkey_validation(self): with self.assertRaisesRegex(TypeError, 'chain code must be raw bytes'): @@ -39,7 +40,7 @@ class BIP32Tests(unittest.TestCase): self.assertIsInstance(new_key, PubKey) self.assertEqual(hexlify(new_key.identifier()), expected_ids[i]) - def test_private_key_validation(self): + async def test_private_key_validation(self): with self.assertRaisesRegex(TypeError, 'private key must be raw bytes'): PrivateKey(None, None, b'abcd'*8, 0, 255) with self.assertRaisesRegex(ValueError, 'private key must be 32 bytes'): @@ -64,7 +65,7 @@ class BIP32Tests(unittest.TestCase): private_key.child(-1) self.assertIsInstance(private_key.child(PrivateKey.HARDENED), PrivateKey) - def test_private_key_derivation(self): + async def test_private_key_derivation(self): private_key = PrivateKey( ledger_class({ 'db': ledger_class.database_class(':memory:'), @@ -82,7 +83,7 @@ class BIP32Tests(unittest.TestCase): self.assertIsInstance(new_privkey, PrivateKey) self.assertEqual(hexlify(new_privkey.private_key_bytes), expected_hardened_privkeys[i - 1 - PrivateKey.HARDENED]) - def test_from_extended_keys(self): + async def test_from_extended_keys(self): ledger = ledger_class({ 'db': ledger_class.database_class(':memory:'), 'headers': ledger_class.headers_class(':memory:'), diff --git a/tests/unit/test_coinselection.py b/tests/unit/test_coinselection.py index 610a20715..fc54639db 100644 --- a/tests/unit/test_coinselection.py +++ b/tests/unit/test_coinselection.py @@ -1,6 +1,7 @@ -import unittest from types import GeneratorType +from orchstr8.testcase import AsyncioTestCase + from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class from torba.coinselection import CoinSelector, MAXIMUM_TRIES from torba.constants import CENT @@ -16,14 +17,17 @@ def search(*args, **kwargs): return [o.txo.amount for o in selection] if selection else selection -class BaseSelectionTestCase(unittest.TestCase): +class BaseSelectionTestCase(AsyncioTestCase): - def setUp(self): + async def asyncSetUp(self): self.ledger = ledger_class({ 'db': ledger_class.database_class(':memory:'), 'headers': ledger_class.headers_class(':memory:'), }) - return self.ledger.db.open() + await self.ledger.db.open() + + async def asyncTearDown(self): + await self.ledger.db.close() def estimates(self, *args): txos = args[0] if isinstance(args[0], (GeneratorType, list)) else args diff --git a/tests/unit/test_script.py b/tests/unit/test_script.py index ffcbc5b12..f1826353b 100644 --- a/tests/unit/test_script.py +++ b/tests/unit/test_script.py @@ -93,7 +93,7 @@ class TestScriptTemplates(unittest.TestCase): ) def test_push_data_many_not_separated(self): - with self.assertRaisesRegexp(ParseError, 'consecutive PUSH_MANY'): + with self.assertRaisesRegex(ParseError, 'consecutive PUSH_MANY'): parse((PUSH_MANY('Chiefs'), PUSH_MANY('Devs')), (b'jeremy', b'grin', b'lex', b'jack')) diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index bebcf1585..baf65505c 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -1,15 +1,16 @@ -import unittest import tempfile +from orchstr8.testcase import AsyncioTestCase + from torba.coin.bitcoinsegwit import MainNetLedger as BTCLedger from torba.coin.bitcoincash import MainNetLedger as BCHLedger from torba.basemanager import BaseWalletManager from torba.wallet import Wallet, WalletStorage -class TestWalletCreation(unittest.TestCase): +class TestWalletCreation(AsyncioTestCase): - def setUp(self): + async def asyncSetUp(self): self.manager = BaseWalletManager() config = {'data_path': '/tmp/wallet'} self.btc_ledger = self.manager.get_or_create_ledger(BTCLedger.get_id(), config) diff --git a/torba/basenetwork.py b/torba/basenetwork.py index 689cab088..f52d17cd9 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -66,8 +66,9 @@ class BaseNetwork: async def stop(self): self.running = False if self.is_connected: + disconnected = self.client.on_disconnected.first await self.client.close() - await self.client.on_disconnected.first + await disconnected @property def is_connected(self): diff --git a/tox.ini b/tox.ini index ef05764eb..18f61f6b8 100644 --- a/tox.ini +++ b/tox.ini @@ -17,9 +17,9 @@ changedir = {toxinidir}/tests setenv = integration: LEDGER={envname} commands = - unit: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial unit + unit: coverage run -p --source={envsitepackagesdir}/torba -m unittest discover -t . unit integration: orchstr8 download - integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_transactions - integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_reconnect + integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest integration.test_transactions + # integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest integration.test_reconnect # Too slow on Travis # integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_blockchain_reorganization From d60b98236b710c512d320f86f2ed37ca4c3d67b5 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 15 Oct 2018 00:50:45 -0400 Subject: [PATCH 182/383] orchstr8 is needed by unittests now as well --- .travis.yml | 1 + tox.ini | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 420998b74..a7d29bebe 100644 --- a/.travis.yml +++ b/.travis.yml @@ -22,6 +22,7 @@ jobs: env: TESTTYPE=unit install: - pip install tox-travis + - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd script: tox - <<: *tests python: "3.6" diff --git a/tox.ini b/tox.ini index 18f61f6b8..0d5b572df 100644 --- a/tox.ini +++ b/tox.ini @@ -10,7 +10,7 @@ TESTTYPE = [testenv] deps = coverage - integration: ../orchstr8 + ../orchstr8 integration: ../electrumx extras = test changedir = {toxinidir}/tests From aa73cb9bbf68380d9c59d1a8a962dd6eb45fdf1b Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 15 Oct 2018 00:56:57 -0400 Subject: [PATCH 183/383] elctrumx is needed by orchstr8 even in unittests --- .travis.yml | 5 +---- tox.ini | 2 +- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/.travis.yml b/.travis.yml index a7d29bebe..ccb311a02 100644 --- a/.travis.yml +++ b/.travis.yml @@ -22,16 +22,13 @@ jobs: env: TESTTYPE=unit install: - pip install tox-travis + - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch lbryumx && popd - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd script: tox - <<: *tests python: "3.6" - <<: *tests env: TESTTYPE=integration - install: - - pip install tox-travis - - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch lbryumx && popd - - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd after_success: - pip install coverage diff --git a/tox.ini b/tox.ini index 0d5b572df..fc96bfc12 100644 --- a/tox.ini +++ b/tox.ini @@ -11,7 +11,7 @@ TESTTYPE = deps = coverage ../orchstr8 - integration: ../electrumx + ../electrumx extras = test changedir = {toxinidir}/tests setenv = From ae0e1bfaefa5ad7747ca248f96dd0134867cf4a6 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 15 Oct 2018 08:56:23 -0400 Subject: [PATCH 184/383] support python 3.6 --- torba/baseheader.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/torba/baseheader.py b/torba/baseheader.py index 5526c3fb6..dfe60f900 100644 --- a/torba/baseheader.py +++ b/torba/baseheader.py @@ -95,7 +95,9 @@ class BaseHeaders: async def connect(self, start: int, headers: bytes) -> int: added = 0 bail = False - loop = asyncio.get_running_loop() + # TODO: switch to get_running_loop() after depricating python 3.6 support + #loop = asyncio.get_running_loop() + loop = asyncio.get_event_loop() async with self._header_connect_lock: for height, chunk in self._iterate_chunks(start, headers): try: From c6b32fa946fb02e500c4cfc6a2b946443dfdb8dd Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 15 Oct 2018 13:25:18 -0400 Subject: [PATCH 185/383] basedatabase.py test coverage --- tests/unit/test_database.py | 65 +++++++++++++++++++++++++++++++------ torba/basedatabase.py | 11 ------- 2 files changed, 55 insertions(+), 21 deletions(-) diff --git a/tests/unit/test_database.py b/tests/unit/test_database.py index 860223bea..d6fcc564e 100644 --- a/tests/unit/test_database.py +++ b/tests/unit/test_database.py @@ -32,7 +32,7 @@ class TestQueryBuilder(unittest.TestCase): }) ) - def test_in_list(self): + def test_in(self): self.assertEqual( constraints_to_sql({'txo.age__in': [18, 38]}), ('txo.age IN (18, 38)', {}) @@ -41,14 +41,16 @@ class TestQueryBuilder(unittest.TestCase): constraints_to_sql({'txo.age__in': ['abc123', 'def456']}), ("txo.age IN ('abc123', 'def456')", {}) ) - - def test_in_query(self): self.assertEqual( constraints_to_sql({'txo.age__in': 'SELECT age from ages_table'}), ('txo.age IN (SELECT age from ages_table)', {}) ) - def test_not_in_query(self): + def test_not_in(self): + self.assertEqual( + constraints_to_sql({'txo.age__not_in': [18, 38]}), + ('txo.age NOT IN (18, 38)', {}) + ) self.assertEqual( constraints_to_sql({'txo.age__not_in': 'SELECT age from ages_table'}), ('txo.age NOT IN (SELECT age from ages_table)', {}) @@ -66,13 +68,13 @@ class TestQueryBuilder(unittest.TestCase): self.assertEqual( query( "select * from foo", - a='b', b__in='select * from blah where c=:$c', - d__any={'one': 1, 'two': 2}, limit=10, order_by='b', **{'$c': 3}), + a__not='b', b__in='select * from blah where c=:$c', + d__any={'one__like': 'o', 'two': 2}, limit=10, order_by='b', **{'$c': 3}), ( - "select * from foo WHERE a = :a AND " + "select * from foo WHERE a != :a__not AND " "b IN (select * from blah where c=:$c) AND " - "(one = :d__any_one OR two = :d__any_two) ORDER BY b LIMIT 10", - {'a': 'b', 'd__any_one': 1, 'd__any_two': 2, '$c': 3} + "(one LIKE :d__any_one__like OR two = :d__any_two) ORDER BY b LIMIT 10", + {'a__not': 'b', 'd__any_one__like': 'o', 'd__any_two': 2, '$c': 3} ) ) @@ -85,6 +87,8 @@ class TestQueryBuilder(unittest.TestCase): query("select * from foo", order_by=['foo', 'bar']), ("select * from foo ORDER BY foo, bar", {}) ) + with self.assertRaisesRegex(ValueError, 'order_by must be string or list'): + query("select * from foo", order_by={'foo': 'bar'}) def test_query_limit_offset(self): self.assertEqual( @@ -155,12 +159,52 @@ class TestQueries(AsyncioTestCase): def txi(self, txo): return ledger_class.transaction_class.input_class.spend(txo) - async def test_get_transactions(self): + async def test_queries(self): + self.assertEqual(0, await self.ledger.db.get_address_count()) account1 = await self.create_account() + self.assertEqual(26, await self.ledger.db.get_address_count()) account2 = await self.create_account() + self.assertEqual(52, await self.ledger.db.get_address_count()) + + self.assertEqual(0, await self.ledger.db.get_transaction_count()) + self.assertEqual(0, await self.ledger.db.get_utxo_count()) + self.assertEqual([], await self.ledger.db.get_utxos()) + self.assertEqual(0, await self.ledger.db.get_txo_count()) + self.assertEqual(0, await self.ledger.db.get_balance()) + self.assertEqual(0, await self.ledger.db.get_balance(account=account1)) + self.assertEqual(0, await self.ledger.db.get_balance(account=account2)) + tx1 = await self.create_tx_from_nothing(account1, 1) + self.assertEqual(1, await self.ledger.db.get_transaction_count(account=account1)) + self.assertEqual(0, await self.ledger.db.get_transaction_count(account=account2)) + self.assertEqual(1, await self.ledger.db.get_utxo_count(account=account1)) + self.assertEqual(1, await self.ledger.db.get_txo_count(account=account1)) + self.assertEqual(0, await self.ledger.db.get_txo_count(account=account2)) + self.assertEqual(10**8, await self.ledger.db.get_balance()) + self.assertEqual(10**8, await self.ledger.db.get_balance(account=account1)) + self.assertEqual(0, await self.ledger.db.get_balance(account=account2)) + tx2 = await self.create_tx_from_txo(tx1.outputs[0], account2, 2) + self.assertEqual(2, await self.ledger.db.get_transaction_count(account=account1)) + self.assertEqual(1, await self.ledger.db.get_transaction_count(account=account2)) + self.assertEqual(0, await self.ledger.db.get_utxo_count(account=account1)) + self.assertEqual(1, await self.ledger.db.get_txo_count(account=account1)) + self.assertEqual(1, await self.ledger.db.get_utxo_count(account=account2)) + self.assertEqual(1, await self.ledger.db.get_txo_count(account=account2)) + self.assertEqual(10**8, await self.ledger.db.get_balance()) + self.assertEqual(0, await self.ledger.db.get_balance(account=account1)) + self.assertEqual(10**8, await self.ledger.db.get_balance(account=account2)) + tx3 = await self.create_tx_to_nowhere(tx2.outputs[0], 3) + self.assertEqual(2, await self.ledger.db.get_transaction_count(account=account1)) + self.assertEqual(2, await self.ledger.db.get_transaction_count(account=account2)) + self.assertEqual(0, await self.ledger.db.get_utxo_count(account=account1)) + self.assertEqual(1, await self.ledger.db.get_txo_count(account=account1)) + self.assertEqual(0, await self.ledger.db.get_utxo_count(account=account2)) + self.assertEqual(1, await self.ledger.db.get_txo_count(account=account2)) + self.assertEqual(0, await self.ledger.db.get_balance()) + self.assertEqual(0, await self.ledger.db.get_balance(account=account1)) + self.assertEqual(0, await self.ledger.db.get_balance(account=account2)) txs = await self.ledger.db.get_transactions() self.assertEqual([tx3.id, tx2.id, tx1.id], [tx.id for tx in txs]) @@ -179,6 +223,7 @@ class TestQueries(AsyncioTestCase): self.assertEqual(txs[0].outputs[0].is_my_account, False) self.assertEqual(txs[1].inputs[0].is_my_account, False) self.assertEqual(txs[1].outputs[0].is_my_account, True) + self.assertEqual(2, await self.ledger.db.get_transaction_count(account=account2)) tx = await self.ledger.db.get_transaction(txid=tx2.id) self.assertEqual(tx.id, tx2.id) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 1493d3c32..dba994620 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -99,11 +99,6 @@ def rows_to_dict(rows, fields): return [] -def row_dict_or_default(rows, fields, default=None): - dicts = rows_to_dict(rows, fields) - return dicts[0] if dicts else default - - class SQLiteMixin: CREATE_TABLES_QUERY: str @@ -146,12 +141,6 @@ class SQLiteMixin: ) return sql, values - @staticmethod - def execute(t, sql, values): - log.debug(sql) - log.debug(values) - return t.execute(sql, values) - class BaseDatabase(SQLiteMixin): From 382ebb55b9653e744e34f9913bd5ae679a0e9c6a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 16 Oct 2018 11:56:53 -0400 Subject: [PATCH 186/383] log formatting fix --- torba/baseaccount.py | 2 +- torba/basenetwork.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 7551c39c8..86e6d3cef 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -355,7 +355,7 @@ class BaseAccount: def get_utxo_count(self, **constraints): return self.ledger.db.get_utxo_count(account=self, **constraints) - def get_transactions(self, **constraints) -> List['basetransaction.BaseTransaction']: + def get_transactions(self, **constraints): return self.ledger.db.get_transactions(account=self, **constraints) def get_transaction_count(self, **constraints): diff --git a/torba/basenetwork.py b/torba/basenetwork.py index f52d17cd9..f021dcb0d 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -50,12 +50,12 @@ class BaseNetwork: async def start(self): self.running = True for server in cycle(self.config['default_servers']): - connection_string = 'tcp:{}:{}'.format(*server) + connection_string = '{}:{}'.format(*server) self.client = ClientSession(*server, network=self) try: await self.client.create_connection() await self.ensure_server_version() - log.info("Successfully connected to SPV wallet server: %s", ) + log.info("Successfully connected to SPV wallet server: %s", connection_string) self._on_connected_controller.add(True) await self.client.on_disconnected.first except Exception: # pylint: disable=broad-except From f2f2a12ea13e61f7862b1d6d2d05d371f54e7bef Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 16 Oct 2018 21:45:59 -0400 Subject: [PATCH 187/383] added commit() after insert/update operations --- torba/basedatabase.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index dba994620..2f4579019 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -113,6 +113,7 @@ class SQLiteMixin: self.db = aiosqlite.connect(self._db_path) await self.db.__aenter__() await self.db.executescript(self.CREATE_TABLES_QUERY) + await self.db.commit() async def close(self): await self.db.close() @@ -248,7 +249,7 @@ class BaseDatabase(SQLiteMixin): await self.db.execute(*self._insert_sql("txo", self.txo_to_row(tx, address, txo))) elif txo.script.is_pay_script_hash: # TODO: implement script hash payments - print('Database.save_transaction_io: pay script hash is not implemented!') + log.warning('Database.save_transaction_io: pay script hash is not implemented!') # lookup the address associated with each TXI (via its TXO) txoid_to_address = {r[0]: r[1] for r in await self.db.execute_fetchall(*query( @@ -280,9 +281,11 @@ class BaseDatabase(SQLiteMixin): ', '.join(['?']*len(txoids)) ), [is_reserved]+txoids ) + await self.db.commit() async def release_outputs(self, txos): await self.reserve_outputs(txos, is_reserved=False) + await self.db.commit() async def rewind_blockchain(self, above_height): # pylint: disable=no-self-use # TODO: @@ -451,12 +454,14 @@ class BaseDatabase(SQLiteMixin): sqlite3.Binary(pubkey.pubkey_bytes) )) await self.db.execute(sql, values) + await self.db.commit() async def _set_address_history(self, address, history): await self.db.execute( "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", (history, history.count(':')//2, address) ) + await self.db.commit() async def set_address_history(self, address, history): await self._set_address_history(address, history) From a7838b80c335affc6f91fae6c33cf013415da69a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 16 Oct 2018 21:49:49 -0400 Subject: [PATCH 188/383] removed extraneous db.commit() --- torba/basedatabase.py | 1 - 1 file changed, 1 deletion(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 2f4579019..a96b11be3 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -285,7 +285,6 @@ class BaseDatabase(SQLiteMixin): async def release_outputs(self, txos): await self.reserve_outputs(txos, is_reserved=False) - await self.db.commit() async def rewind_blockchain(self, above_height): # pylint: disable=no-self-use # TODO: From 2b73d3d109f23364b2b6a3a45662f6388b7aa832 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 16 Oct 2018 21:53:23 -0400 Subject: [PATCH 189/383] pylint fixes --- torba/baseaccount.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/torba/baseaccount.py b/torba/baseaccount.py index 86e6d3cef..422d11c8e 100644 --- a/torba/baseaccount.py +++ b/torba/baseaccount.py @@ -1,6 +1,6 @@ import random import typing -from typing import List, Dict, Tuple, Type, Optional, Any +from typing import Dict, Tuple, Type, Optional, Any from torba.mnemonic import Mnemonic from torba.bip32 import PrivateKey, PubKey, from_extended_key_string @@ -10,7 +10,6 @@ from torba.constants import COIN if typing.TYPE_CHECKING: from torba import baseledger from torba import wallet as basewallet - from torba import basetransaction class AddressManager: From 0b8c67f2f05c425a2f71b0eb7bba1ebd5cb94d24 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 16 Oct 2018 21:56:50 -0400 Subject: [PATCH 190/383] move db.commit() --- torba/basedatabase.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index a96b11be3..63bedf7b3 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -273,6 +273,7 @@ class BaseDatabase(SQLiteMixin): })) await self._set_address_history(address, history) + await self.db.commit() async def reserve_outputs(self, txos, is_reserved=True): txoids = [txo.id for txo in txos] @@ -460,7 +461,7 @@ class BaseDatabase(SQLiteMixin): "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", (history, history.count(':')//2, address) ) - await self.db.commit() async def set_address_history(self, address, history): await self._set_address_history(address, history) + await self.db.commit() From d270e84810f921d2e2c03ce5c3da6689ad7640a6 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 17 Oct 2018 10:39:21 -0400 Subject: [PATCH 191/383] v0.1.1. --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 2b36b5a11..1389b8b7c 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.1.0' +__version__ = '0.1.1' From a8f8ff30a2290d7a3dae0b6f3f81ded1de92dd76 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 17 Oct 2018 10:57:24 -0400 Subject: [PATCH 192/383] account list --show_seed fix --- torba/basemanager.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torba/basemanager.py b/torba/basemanager.py index 706a6b296..f1dd0a7a6 100644 --- a/torba/basemanager.py +++ b/torba/basemanager.py @@ -41,10 +41,10 @@ class BaseWalletManager: self.wallets.append(wallet) return wallet - async def get_detailed_accounts(self, confirmations=6, show_seed=False): + async def get_detailed_accounts(self, **kwargs): ledgers = {} for i, account in enumerate(self.accounts): - details = await account.get_details(confirmations=confirmations, show_seed=True) + details = await account.get_details(**kwargs) details['is_default_account'] = i == 0 ledger_id = account.ledger.get_id() ledgers.setdefault(ledger_id, []) From 9fed3fce3e8265028de5580f1c0cad5ffe702cb5 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 17 Oct 2018 14:05:47 -0300 Subject: [PATCH 193/383] unlock networking limits --- torba/basenetwork.py | 1 + 1 file changed, 1 insertion(+) diff --git a/torba/basenetwork.py b/torba/basenetwork.py index f021dcb0d..5a62115a7 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -16,6 +16,7 @@ class ClientSession(BaseClientSession): super().__init__(*args, **kwargs) self._on_disconnect_controller = StreamController() self.on_disconnected = self._on_disconnect_controller.stream + self.bw_limit = self.framer.max_size = self.max_errors = 1 << 32 async def handle_request(self, request): controller = self.network.subscription_controllers[request.method] From 63563c412cdc9902ba4325fcf7da174c9e32a834 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 17 Oct 2018 14:32:33 -0300 Subject: [PATCH 194/383] cancel pending requests and close connection on server switch --- torba/basenetwork.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/torba/basenetwork.py b/torba/basenetwork.py index 5a62115a7..1fdd1a55c 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -2,6 +2,7 @@ import logging from itertools import cycle from aiorpcx import ClientSession as BaseClientSession +from asyncio import CancelledError from torba import __version__ from torba.stream import StreamController @@ -59,10 +60,13 @@ class BaseNetwork: log.info("Successfully connected to SPV wallet server: %s", connection_string) self._on_connected_controller.add(True) await self.client.on_disconnected.first - except Exception: # pylint: disable=broad-except + except (Exception, CancelledError): # pylint: disable=broad-except log.exception("Connecting to %s raised an exception:", connection_string) if not self.running: return + elif self.client: + await self.client.close() + self.client.connection.cancel_pending_requests() async def stop(self): self.running = False From c7b647b1ebd42e9787de0394fec1e841ed05b511 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 17 Oct 2018 14:32:45 -0300 Subject: [PATCH 195/383] fix test_reconnect --- tests/integration/test_reconnect.py | 8 +++++--- torba/basenetwork.py | 2 +- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/tests/integration/test_reconnect.py b/tests/integration/test_reconnect.py index 18b41e868..b7a3b9d81 100644 --- a/tests/integration/test_reconnect.py +++ b/tests/integration/test_reconnect.py @@ -1,3 +1,5 @@ +from asyncio import CancelledError + from orchstr8.testcase import IntegrationTestCase from torba.constants import COIN @@ -8,7 +10,7 @@ class ReconnectTests(IntegrationTestCase): async def test_connection_drop_still_receives_events_after_reconnected(self): address1 = await self.account.receiving.get_or_create_usable_address() - self.ledger.network.client.connectionLost() + self.ledger.network.client.connection_lost(Exception()) sendtxid = await self.blockchain.send_to_address(address1, 1.1337) await self.on_transaction_id(sendtxid) # mempool await self.blockchain.generate(1) @@ -18,8 +20,8 @@ class ReconnectTests(IntegrationTestCase): # is it real? are we rich!? let me see this tx... d = self.ledger.network.get_transaction(sendtxid) # what's that smoke on my ethernet cable? oh no! - self.ledger.network.client.connectionLost() - with self.assertRaisesRegex(TimeoutError, 'Connection dropped'): + self.ledger.network.client.connection_lost(Exception()) + with self.assertRaises(CancelledError): await d # rich but offline? no way, no water, let's retry with self.assertRaisesRegex(ConnectionError, 'connection is not available'): diff --git a/torba/basenetwork.py b/torba/basenetwork.py index 1fdd1a55c..50727ea92 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -1,8 +1,8 @@ import logging from itertools import cycle +from asyncio import CancelledError from aiorpcx import ClientSession as BaseClientSession -from asyncio import CancelledError from torba import __version__ from torba.stream import StreamController From b62c5c57afef1a1d7a3e21f2ea18683b241ce618 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 17 Oct 2018 14:32:57 -0300 Subject: [PATCH 196/383] re-enable test_reconnect on tox --- tox.ini | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tox.ini b/tox.ini index fc96bfc12..f7658651e 100644 --- a/tox.ini +++ b/tox.ini @@ -20,6 +20,6 @@ commands = unit: coverage run -p --source={envsitepackagesdir}/torba -m unittest discover -t . unit integration: orchstr8 download integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest integration.test_transactions - # integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest integration.test_reconnect + integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest integration.test_reconnect # Too slow on Travis # integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_blockchain_reorganization From 4d0ecd1fb42cf33f89d608d96c333d5e7c3eb28a Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 17 Oct 2018 19:37:33 -0300 Subject: [PATCH 197/383] fix history hash --- torba/baseledger.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index b168e1ec6..5d9dc1b0a 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -169,9 +169,8 @@ class BaseLedger(metaclass=LedgerRegistry): async def get_local_status(self, address): address_details = await self.db.get_address(address=address) - history = address_details['history'] or '' - h = sha256(history.encode()) - return hexlify(h) + history = address_details['history'] + return hexlify(sha256(history.encode())).decode() if history else None async def get_local_history(self, address): address_details = await self.db.get_address(address=address) From 28b638f0aa8a855f27891547418b28e7392d692f Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 17 Oct 2018 19:40:17 -0300 Subject: [PATCH 198/383] prefetch and remove manual update calls --- torba/baseledger.py | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index 5d9dc1b0a..481c94630 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -190,10 +190,9 @@ class BaseLedger(metaclass=LedgerRegistry): working_branch = double_sha256(combined) return hexlify(working_branch[::-1]) - async def validate_transaction_and_set_position(self, tx, height): + async def validate_transaction_and_set_position(self, tx, height, merkle): if not height <= len(self.headers): return False - merkle = await self.network.get_merkle(tx.id, height) merkle_root = self.get_root_of_merkle_tree(merkle['merkle'], merkle['pos'], tx.hash) header = self.headers[height] tx.position = merkle['pos'] @@ -314,17 +313,23 @@ class BaseLedger(metaclass=LedgerRegistry): await account.ensure_address_gap() addresses = await account.get_addresses(used_times=0) while addresses: - await asyncio.gather(*(self.update_history(a) for a in addresses)) + await asyncio.gather(*(self.subscribe_history(a) for a in addresses)) addresses = await account.ensure_address_gap() - # By this point all of the addresses should be restored and we - # can now subscribe all of them to receive updates. - all_addresses = await account.get_addresses() - await asyncio.gather(*(self.subscribe_history(a) for a in all_addresses)) + async def _prefetch_history(self, remote_history, local_history): + proofs, network_txs = {}, {} + for i, (hex_id, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): + if i < len(local_history) and local_history[i] == (hex_id, remote_height): + continue + if remote_height > 0: + proofs[hex_id] = asyncio.ensure_future(self.network.get_merkle(hex_id, remote_height)) + network_txs[hex_id] = asyncio.ensure_future(self.network.get_transaction(hex_id)) + return proofs, network_txs async def update_history(self, address): remote_history = await self.network.get_history(address) local_history = await self.get_local_history(address) + proofs, network_txs = await self._prefetch_history(remote_history, local_history) synced_history = StringIO() for i, (hex_id, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): @@ -344,14 +349,14 @@ class BaseLedger(metaclass=LedgerRegistry): tx = await self.db.get_transaction(txid=hex_id) save_tx = None if tx is None: - _raw = await self.network.get_transaction(hex_id) + _raw = await network_txs[hex_id] tx = self.transaction_class(unhexlify(_raw)) save_tx = 'insert' tx.height = remote_height if remote_height > 0 and (not tx.is_verified or tx.position == -1): - await self.validate_transaction_and_set_position(tx, remote_height) + await self.validate_transaction_and_set_position(tx, remote_height, await proofs[hex_id]) if save_tx is None: save_tx = 'update' From b830f4c3ca4dfdba16473f8f5dc026fd06bc96aa Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 17 Oct 2018 20:39:38 -0300 Subject: [PATCH 199/383] fixes from code review --- torba/basedatabase.py | 7 +------ torba/baseledger.py | 8 ++------ 2 files changed, 3 insertions(+), 12 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 63bedf7b3..05ad53197 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -110,10 +110,9 @@ class SQLiteMixin: async def open(self): log.info("connecting to database: %s", self._db_path) - self.db = aiosqlite.connect(self._db_path) + self.db = aiosqlite.connect(self._db_path, isolation_level=None) await self.db.__aenter__() await self.db.executescript(self.CREATE_TABLES_QUERY) - await self.db.commit() async def close(self): await self.db.close() @@ -273,7 +272,6 @@ class BaseDatabase(SQLiteMixin): })) await self._set_address_history(address, history) - await self.db.commit() async def reserve_outputs(self, txos, is_reserved=True): txoids = [txo.id for txo in txos] @@ -282,7 +280,6 @@ class BaseDatabase(SQLiteMixin): ', '.join(['?']*len(txoids)) ), [is_reserved]+txoids ) - await self.db.commit() async def release_outputs(self, txos): await self.reserve_outputs(txos, is_reserved=False) @@ -454,7 +451,6 @@ class BaseDatabase(SQLiteMixin): sqlite3.Binary(pubkey.pubkey_bytes) )) await self.db.execute(sql, values) - await self.db.commit() async def _set_address_history(self, address, history): await self.db.execute( @@ -464,4 +460,3 @@ class BaseDatabase(SQLiteMixin): async def set_address_history(self, address, history): await self._set_address_history(address, history) - await self.db.commit() diff --git a/torba/baseledger.py b/torba/baseledger.py index 481c94630..c22df65dc 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -306,17 +306,13 @@ class BaseLedger(metaclass=LedgerRegistry): )) async def update_account(self, account: baseaccount.BaseAccount): - # Before subscribing, download history for any addresses that don't have any, - # this avoids situation where we're getting status updates to addresses we know - # need to update anyways. Continue to get history and create more addresses until - # all missing addresses are created and history for them is fully restored. await account.ensure_address_gap() addresses = await account.get_addresses(used_times=0) while addresses: await asyncio.gather(*(self.subscribe_history(a) for a in addresses)) addresses = await account.ensure_address_gap() - async def _prefetch_history(self, remote_history, local_history): + def _prefetch_history(self, remote_history, local_history): proofs, network_txs = {}, {} for i, (hex_id, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): if i < len(local_history) and local_history[i] == (hex_id, remote_height): @@ -329,7 +325,7 @@ class BaseLedger(metaclass=LedgerRegistry): async def update_history(self, address): remote_history = await self.network.get_history(address) local_history = await self.get_local_history(address) - proofs, network_txs = await self._prefetch_history(remote_history, local_history) + proofs, network_txs = self._prefetch_history(remote_history, local_history) synced_history = StringIO() for i, (hex_id, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): From 03594dab6ad861ab94f378ccb4d32dba7b33b5b3 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 17 Oct 2018 21:20:17 -0400 Subject: [PATCH 200/383] exception message correction --- torba/basetransaction.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/basetransaction.py b/torba/basetransaction.py index 3ac582b88..ec29294eb 100644 --- a/torba/basetransaction.py +++ b/torba/basetransaction.py @@ -470,7 +470,7 @@ class BaseTransaction: await tx.sign(funding_accounts) except Exception as e: - log.exception('Failed to synchronize transaction:') + log.exception('Failed to create transaction:') await ledger.release_outputs(tx.outputs) raise e From 6fe648b9a9406643accd53c3878e034b7b6df573 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 17 Oct 2018 21:21:21 -0400 Subject: [PATCH 201/383] v0.1.2 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 1389b8b7c..3d03ab135 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.1.1' +__version__ = '0.1.2' From 3b021af1bd341015c3ddde7e39053b1cbb3f8e1a Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Thu, 18 Oct 2018 17:19:47 -0300 Subject: [PATCH 202/383] adds a simple sqlite asyncio wrapper --- setup.py | 1 - torba/basedatabase.py | 60 +++++++++++++++++++++++++++++++++++++++---- 2 files changed, 55 insertions(+), 6 deletions(-) diff --git a/setup.py b/setup.py index 5d42d03f9..4d476c0b1 100644 --- a/setup.py +++ b/setup.py @@ -27,7 +27,6 @@ setup( python_requires='>=3.6', install_requires=( 'aiorpcx', - 'aiosqlite', 'coincurve', 'pbkdf2', 'cryptography' diff --git a/torba/basedatabase.py b/torba/basedatabase.py index 05ad53197..ad758829b 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -1,8 +1,11 @@ import logging -from typing import Tuple, List, Union +import asyncio +from asyncio import wrap_future +from concurrent.futures.thread import ThreadPoolExecutor + +from typing import Tuple, List, Union, Callable, Any, Awaitable, Iterable import sqlite3 -import aiosqlite from torba.hash import TXRefImmutable from torba.basetransaction import BaseTransaction @@ -11,6 +14,54 @@ from torba.baseaccount import BaseAccount log = logging.getLogger(__name__) +class AIOSQLite: + + def __init__(self): + # has to be single threaded as there is no mapping of thread:connection + self.executor = ThreadPoolExecutor(max_workers=1) + self.connection: sqlite3.Connection = None + + @classmethod + async def connect(cls, path: Union[bytes, str], *args, **kwargs): + db = cls() + db.connection = await wrap_future(db.executor.submit(sqlite3.connect, path, *args, **kwargs)) + return db + + async def close(self): + def __close(conn): + self.executor.submit(conn.close) + self.executor.shutdown(wait=True) + conn = self.connection + self.connection = None + return asyncio._get_running_loop().call_later(0.01, __close, conn) + + def executescript(self, script: str) -> Awaitable: + return wrap_future(self.executor.submit(self.connection.executescript, script)) + + def execute_fetchall(self, sql: str, parameters: Iterable = None) -> Awaitable[Iterable[sqlite3.Row]]: + parameters = parameters if parameters is not None else [] + def __fetchall(conn: sqlite3.Connection, *args, **kwargs): + return conn.execute(*args, **kwargs).fetchall() + return wrap_future(self.executor.submit(__fetchall, self.connection, sql, parameters)) + + def execute(self, sql: str, parameters: Iterable = None) -> Awaitable[sqlite3.Cursor]: + parameters = parameters if parameters is not None else [] + return self.run(lambda conn, sql, parameters: conn.execute(sql, parameters), sql, parameters) + + def run(self, fn: Callable[[sqlite3.Connection, Any], Any], *args, **kwargs) -> Awaitable: + return wrap_future(self.executor.submit(self.__run_transaction, fn, *args, **kwargs)) + + def __run_transaction(self, fn: Callable[[sqlite3.Connection, Any], Any], *args, **kwargs): + self.connection.execute('begin') + try: + fn(self.connection, *args, **kwargs) + except (Exception, OSError): + self.connection.rollback() + raise + else: + self.connection.commit() + + def constraints_to_sql(constraints, joiner=' AND ', prepend_key=''): sql, values = [], {} for key, constraint in constraints.items(): @@ -105,13 +156,12 @@ class SQLiteMixin: def __init__(self, path): self._db_path = path - self.db: aiosqlite.Connection = None + self.db: AIOSQLite = None self.ledger = None async def open(self): log.info("connecting to database: %s", self._db_path) - self.db = aiosqlite.connect(self._db_path, isolation_level=None) - await self.db.__aenter__() + self.db = await AIOSQLite.connect(self._db_path) await self.db.executescript(self.CREATE_TABLES_QUERY) async def close(self): From c497e9884a77e1c6c5c6b5a6c10c7be88fe0cb3d Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Thu, 18 Oct 2018 17:25:24 -0300 Subject: [PATCH 203/383] pylint --- torba/basedatabase.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index ad758829b..d28b368e3 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -33,7 +33,7 @@ class AIOSQLite: self.executor.shutdown(wait=True) conn = self.connection self.connection = None - return asyncio._get_running_loop().call_later(0.01, __close, conn) + return asyncio.get_event_loop_policy().get_event_loop().call_later(0.01, __close, conn) def executescript(self, script: str) -> Awaitable: return wrap_future(self.executor.submit(self.connection.executescript, script)) @@ -48,13 +48,13 @@ class AIOSQLite: parameters = parameters if parameters is not None else [] return self.run(lambda conn, sql, parameters: conn.execute(sql, parameters), sql, parameters) - def run(self, fn: Callable[[sqlite3.Connection, Any], Any], *args, **kwargs) -> Awaitable: - return wrap_future(self.executor.submit(self.__run_transaction, fn, *args, **kwargs)) + def run(self, fun: Callable[[sqlite3.Connection, Any, Any], Any], *args, **kwargs) -> Awaitable: + return wrap_future(self.executor.submit(self.__run_transaction, fun, *args, **kwargs)) - def __run_transaction(self, fn: Callable[[sqlite3.Connection, Any], Any], *args, **kwargs): + def __run_transaction(self, fun: Callable[[sqlite3.Connection, Any, Any], Any], *args, **kwargs): self.connection.execute('begin') try: - fn(self.connection, *args, **kwargs) + fun(self.connection, *args, **kwargs) # type: ignore except (Exception, OSError): self.connection.rollback() raise From f67b872bd1755371914a40ba0eb507617cadacd1 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 18 Oct 2018 18:21:39 -0400 Subject: [PATCH 204/383] 0.1.3 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 3d03ab135..8679c6c80 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.1.2' +__version__ = '0.1.3' From 85503cf92bc0641ba8332d116d3c7f924d38d5e4 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Fri, 19 Oct 2018 11:45:05 -0300 Subject: [PATCH 205/383] retry with a delay increasing from 0 up to 10 seconds --- torba/basenetwork.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/torba/basenetwork.py b/torba/basenetwork.py index 50727ea92..ed0bd0dc6 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -1,6 +1,7 @@ import logging -from itertools import cycle +import asyncio from asyncio import CancelledError +from itertools import cycle from aiorpcx import ClientSession as BaseClientSession @@ -51,6 +52,7 @@ class BaseNetwork: async def start(self): self.running = True + delay = 0.0 for server in cycle(self.config['default_servers']): connection_string = '{}:{}'.format(*server) self.client = ClientSession(*server, network=self) @@ -59,6 +61,7 @@ class BaseNetwork: await self.ensure_server_version() log.info("Successfully connected to SPV wallet server: %s", connection_string) self._on_connected_controller.add(True) + delay = 0.0 await self.client.on_disconnected.first except (Exception, CancelledError): # pylint: disable=broad-except log.exception("Connecting to %s raised an exception:", connection_string) @@ -67,6 +70,8 @@ class BaseNetwork: elif self.client: await self.client.close() self.client.connection.cancel_pending_requests() + await asyncio.sleep(delay) + delay = min(delay + 1.0, 10.0) async def stop(self): self.running = False From d3d60071aeabb9c5fae276ed9a0a5a69545f996e Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 19 Oct 2018 11:01:35 -0400 Subject: [PATCH 206/383] v0.1.4 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 8679c6c80..63c5cf138 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.1.3' +__version__ = '0.1.4' From e650562758023a01b9c3566d1e35bb5185d1193a Mon Sep 17 00:00:00 2001 From: Nikita Titov Date: Sat, 20 Oct 2018 15:35:28 +0300 Subject: [PATCH 207/383] Use README as long description on PyPI --- setup.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/setup.py b/setup.py index 4d476c0b1..eb5c41003 100644 --- a/setup.py +++ b/setup.py @@ -1,3 +1,4 @@ +import os from setuptools import setup, find_packages import torba @@ -10,6 +11,9 @@ setup( author='LBRY Inc.', author_email='hello@lbry.io', description='Wallet library for bitcoin based currencies.', + long_description=open(os.path.join(os.path.dirname(__file__), 'README.md'), + encoding='utf-8').read(), + long_description_content_type="text/markdown", keywords='wallet,crypto,currency,money,bitcoin,lbry', classifiers=( 'Framework :: AsyncIO', From 8bbda75865a762dccc9697a7adf57bdc7d101770 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Thu, 18 Oct 2018 22:59:41 -0300 Subject: [PATCH 208/383] save_transaction_io back to a transaction --- torba/basedatabase.py | 104 +++++++++++++++++++++++------------------- 1 file changed, 57 insertions(+), 47 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index d28b368e3..ba9fbed1b 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -2,6 +2,7 @@ import logging import asyncio from asyncio import wrap_future from concurrent.futures.thread import ThreadPoolExecutor +from operator import itemgetter from typing import Tuple, List, Union, Callable, Any, Awaitable, Iterable @@ -48,7 +49,7 @@ class AIOSQLite: parameters = parameters if parameters is not None else [] return self.run(lambda conn, sql, parameters: conn.execute(sql, parameters), sql, parameters) - def run(self, fun: Callable[[sqlite3.Connection, Any, Any], Any], *args, **kwargs) -> Awaitable: + def run(self, fun, *args, **kwargs) -> Awaitable: return wrap_future(self.executor.submit(self.__run_transaction, fun, *args, **kwargs)) def __run_transaction(self, fun: Callable[[sqlite3.Connection, Any, Any], Any], *args, **kwargs): @@ -272,56 +273,65 @@ class BaseDatabase(SQLiteMixin): 'script': sqlite3.Binary(txo.script.source) } - async def save_transaction_io(self, save_tx, tx: BaseTransaction, address, txhash, history): + def save_transaction_io(self, save_tx, tx: BaseTransaction, address, txhash, history): - if save_tx == 'insert': - await self.db.execute(*self._insert_sql('tx', { - 'txid': tx.id, - 'raw': sqlite3.Binary(tx.raw), - 'height': tx.height, - 'position': tx.position, - 'is_verified': tx.is_verified - })) - elif save_tx == 'update': - await self.db.execute(*self._update_sql("tx", { - 'height': tx.height, 'position': tx.position, 'is_verified': tx.is_verified - }, 'txid = ?', (tx.id,))) - - existing_txos = [r[0] for r in await self.db.execute_fetchall(*query( - "SELECT position FROM txo", txid=tx.id - ))] - - for txo in tx.outputs: - if txo.position in existing_txos: - continue - if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == txhash: - await self.db.execute(*self._insert_sql("txo", self.txo_to_row(tx, address, txo))) - elif txo.script.is_pay_script_hash: - # TODO: implement script hash payments - log.warning('Database.save_transaction_io: pay script hash is not implemented!') - - # lookup the address associated with each TXI (via its TXO) - txoid_to_address = {r[0]: r[1] for r in await self.db.execute_fetchall(*query( - "SELECT txoid, address FROM txo", txoid__in=[txi.txo_ref.id for txi in tx.inputs] - ))} - - # list of TXIs that have already been added - existing_txis = [r[0] for r in await self.db.execute_fetchall(*query( - "SELECT txoid FROM txi", txid=tx.id - ))] - - for txi in tx.inputs: - txoid = txi.txo_ref.id - new_txi = txoid not in existing_txis - address_matches = txoid_to_address.get(txoid) == address - if new_txi and address_matches: - await self.db.execute(*self._insert_sql("txi", { + def _transaction(conn: sqlite3.Connection, save_tx, tx: BaseTransaction, address, txhash, history): + if save_tx == 'insert': + conn.execute(*self._insert_sql('tx', { 'txid': tx.id, - 'txoid': txoid, - 'address': address, + 'raw': sqlite3.Binary(tx.raw), + 'height': tx.height, + 'position': tx.position, + 'is_verified': tx.is_verified })) + elif save_tx == 'update': + conn.execute(*self._update_sql("tx", { + 'height': tx.height, 'position': tx.position, 'is_verified': tx.is_verified + }, 'txid = ?', (tx.id,))) - await self._set_address_history(address, history) + existing_txos = set(map(itemgetter(0), conn.execute(*query( + "SELECT position FROM txo", txid=tx.id + )))) + + txos_insert = [] + for txo in tx.outputs: + if txo.position in existing_txos: + continue + if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == txhash: + txos_insert.append( + (tx.id, txo.id, address, txo.position, txo.amount, sqlite3.Binary(txo.script.source)) + ) + elif txo.script.is_pay_script_hash: + # TODO: implement script hash payments + log.warning('Database.save_transaction_io: pay script hash is not implemented!') + conn.executemany( + 'INSERT INTO txo (txid, txoid, address, position, amount, script) values (?, ?, ?, ?, ?, ?)', + txos_insert + ) + + # lookup the address associated with each TXI (via its TXO) + txoid_to_address = {r[0]: r[1] for r in conn.execute(*query( + "SELECT txoid, address FROM txo", txoid__in=[txi.txo_ref.id for txi in tx.inputs] + ))} + + # list of TXIs that have already been added + existing_txis = {r[0] for r in conn.execute(*query( + "SELECT txoid FROM txi", txid=tx.id + ))} + + txis_insert = [] + for txi in tx.inputs: + txoid = txi.txo_ref.id + new_txi = txoid not in existing_txis + address_matches = txoid_to_address.get(txoid) == address + if new_txi and address_matches: + txis_insert.append((tx.id, txoid, address)) + conn.executemany('INSERT INTO txi (txid, txoid, address) VALUES (?, ?, ?)', txis_insert) + conn.execute( + "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", + (history, history.count(':')//2, address) + ) + return self.db.run(_transaction, save_tx, tx, address, txhash, history) async def reserve_outputs(self, txos, is_reserved=True): txoids = [txo.id for txo in txos] From dce5541c3a52d0e3c0cc846bb7cfb631fcb20d3a Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Thu, 18 Oct 2018 23:13:26 -0300 Subject: [PATCH 209/383] revert insert many due to lbrynet --- torba/basedatabase.py | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) diff --git a/torba/basedatabase.py b/torba/basedatabase.py index ba9fbed1b..a691f06cf 100644 --- a/torba/basedatabase.py +++ b/torba/basedatabase.py @@ -293,21 +293,14 @@ class BaseDatabase(SQLiteMixin): "SELECT position FROM txo", txid=tx.id )))) - txos_insert = [] for txo in tx.outputs: if txo.position in existing_txos: continue if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == txhash: - txos_insert.append( - (tx.id, txo.id, address, txo.position, txo.amount, sqlite3.Binary(txo.script.source)) - ) + conn.execute(*self._insert_sql("txo", self.txo_to_row(tx, address, txo))) elif txo.script.is_pay_script_hash: # TODO: implement script hash payments log.warning('Database.save_transaction_io: pay script hash is not implemented!') - conn.executemany( - 'INSERT INTO txo (txid, txoid, address, position, amount, script) values (?, ?, ?, ?, ?, ?)', - txos_insert - ) # lookup the address associated with each TXI (via its TXO) txoid_to_address = {r[0]: r[1] for r in conn.execute(*query( @@ -319,14 +312,16 @@ class BaseDatabase(SQLiteMixin): "SELECT txoid FROM txi", txid=tx.id ))} - txis_insert = [] for txi in tx.inputs: txoid = txi.txo_ref.id new_txi = txoid not in existing_txis address_matches = txoid_to_address.get(txoid) == address if new_txi and address_matches: - txis_insert.append((tx.id, txoid, address)) - conn.executemany('INSERT INTO txi (txid, txoid, address) VALUES (?, ?, ?)', txis_insert) + conn.execute(*self._insert_sql("txi", { + 'txid': tx.id, + 'txoid': txoid, + 'address': address, + })) conn.execute( "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", (history, history.count(':')//2, address) From 82c71e4255012bf13c9f4bdf6167ae9460686854 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 21 Oct 2018 11:53:13 -0400 Subject: [PATCH 210/383] v0.1.5 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 63c5cf138..f71382329 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.1.4' +__version__ = '0.1.5' From a5a0089daaec9b0bda1742f79dd494d7fb6fd690 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Thu, 25 Oct 2018 18:46:32 -0300 Subject: [PATCH 211/383] fix subscribe --- torba/baseledger.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/baseledger.py b/torba/baseledger.py index c22df65dc..03f8e2947 100644 --- a/torba/baseledger.py +++ b/torba/baseledger.py @@ -307,7 +307,7 @@ class BaseLedger(metaclass=LedgerRegistry): async def update_account(self, account: baseaccount.BaseAccount): await account.ensure_address_gap() - addresses = await account.get_addresses(used_times=0) + addresses = await account.get_addresses() while addresses: await asyncio.gather(*(self.subscribe_history(a) for a in addresses)) addresses = await account.ensure_address_gap() From b90378d73910c09373c332d528d8a63ec08f46de Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 25 Oct 2018 17:49:17 -0400 Subject: [PATCH 212/383] 0.1.6 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index f71382329..6768085ce 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.1.5' +__version__ = '0.1.6' From a6ff18c872686ac87ddfd92e4e7a8a058abf6bfe Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 26 Oct 2018 16:20:07 -0400 Subject: [PATCH 213/383] pin aiorpcx to 0.8.2 until we can upgrade to latest --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index eb5c41003..912c7a755 100644 --- a/setup.py +++ b/setup.py @@ -30,7 +30,7 @@ setup( packages=find_packages(exclude=('tests',)), python_requires='>=3.6', install_requires=( - 'aiorpcx', + 'aiorpcx==0.8.2', 'coincurve', 'pbkdf2', 'cryptography' From 41332f22c300b52c360c7900c697839a32265fb3 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Tue, 30 Oct 2018 17:26:07 -0300 Subject: [PATCH 214/383] bump aiorpcx + adapt basenetwork --- setup.py | 2 +- torba/basenetwork.py | 11 ++++++++--- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/setup.py b/setup.py index 912c7a755..2531fa89e 100644 --- a/setup.py +++ b/setup.py @@ -30,7 +30,7 @@ setup( packages=find_packages(exclude=('tests',)), python_requires='>=3.6', install_requires=( - 'aiorpcx==0.8.2', + 'aiorpcx==0.9.0', 'coincurve', 'pbkdf2', 'cryptography' diff --git a/torba/basenetwork.py b/torba/basenetwork.py index ed0bd0dc6..7ce2663fb 100644 --- a/torba/basenetwork.py +++ b/torba/basenetwork.py @@ -3,7 +3,7 @@ import asyncio from asyncio import CancelledError from itertools import cycle -from aiorpcx import ClientSession as BaseClientSession +from aiorpcx import RPCSession as BaseClientSession, Connector from torba import __version__ from torba.stream import StreamController @@ -13,13 +13,18 @@ log = logging.getLogger(__name__) class ClientSession(BaseClientSession): - def __init__(self, *args, network, **kwargs): + def __init__(self, *args, network, server, **kwargs): self.network = network + self.server = server super().__init__(*args, **kwargs) self._on_disconnect_controller = StreamController() self.on_disconnected = self._on_disconnect_controller.stream self.bw_limit = self.framer.max_size = self.max_errors = 1 << 32 + async def create_connection(self): + connector = Connector(lambda: self, *self.server) + await connector.create_connection() + async def handle_request(self, request): controller = self.network.subscription_controllers[request.method] controller.add(request.args) @@ -54,8 +59,8 @@ class BaseNetwork: self.running = True delay = 0.0 for server in cycle(self.config['default_servers']): + self.client = ClientSession(network=self, server=server) connection_string = '{}:{}'.format(*server) - self.client = ClientSession(*server, network=self) try: await self.client.create_connection() await self.ensure_server_version() From f60435c878f0b91607f8b8d71050e61109b679a7 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 3 Nov 2018 18:50:34 -0400 Subject: [PATCH 215/383] moving and refactoring electrumx into torba --- .gitignore | 1 + .travis.yml | 2 - setup.cfg | 2 +- setup.py | 25 +- tests/integration/test_reconnect.py | 4 +- tests/integration/test_transactions.py | 5 +- torba/cli.py | 89 + torba/coin/bitcoincash.py | 2 +- torba/coin/bitcoinsegwit.py | 2 +- torba/server/__init__.py | 1 + torba/server/block_processor.py | 713 ++++++++ torba/server/coins.py | 2290 ++++++++++++++++++++++++ torba/server/daemon.py | 459 +++++ torba/server/db.py | 665 +++++++ torba/server/enum.py | 54 + torba/server/env.py | 169 ++ torba/server/env_base.py | 99 + torba/server/hash.py | 159 ++ torba/server/history.py | 324 ++++ torba/server/mempool.py | 365 ++++ torba/server/merkle.py | 254 +++ torba/server/peer.py | 301 ++++ torba/server/peers.py | 510 ++++++ torba/server/script.py | 251 +++ torba/server/server.py | 129 ++ torba/server/session.py | 1436 +++++++++++++++ torba/server/storage.py | 166 ++ torba/server/text.py | 82 + torba/server/tx.py | 625 +++++++ torba/server/util.py | 359 ++++ torba/testing/__init__.py | 1 + torba/testing/node.py | 344 ++++ torba/testing/service.py | 147 ++ torba/testing/testcase.py | 176 ++ tox.ini | 11 +- 35 files changed, 10200 insertions(+), 22 deletions(-) create mode 100644 torba/cli.py create mode 100644 torba/server/__init__.py create mode 100644 torba/server/block_processor.py create mode 100644 torba/server/coins.py create mode 100644 torba/server/daemon.py create mode 100644 torba/server/db.py create mode 100644 torba/server/enum.py create mode 100644 torba/server/env.py create mode 100644 torba/server/env_base.py create mode 100644 torba/server/hash.py create mode 100644 torba/server/history.py create mode 100644 torba/server/mempool.py create mode 100644 torba/server/merkle.py create mode 100644 torba/server/peer.py create mode 100644 torba/server/peers.py create mode 100644 torba/server/script.py create mode 100644 torba/server/server.py create mode 100644 torba/server/session.py create mode 100644 torba/server/storage.py create mode 100644 torba/server/text.py create mode 100644 torba/server/tx.py create mode 100644 torba/server/util.py create mode 100644 torba/testing/__init__.py create mode 100644 torba/testing/node.py create mode 100644 torba/testing/service.py create mode 100644 torba/testing/testcase.py diff --git a/.gitignore b/.gitignore index d7a60a79b..3a20b56c5 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,7 @@ dist/ # testing .tox/ tests/unit/bitcoin_headers +torba/bin # cache and logs __pycache__/ diff --git a/.travis.yml b/.travis.yml index ccb311a02..3169a13fc 100644 --- a/.travis.yml +++ b/.travis.yml @@ -22,8 +22,6 @@ jobs: env: TESTTYPE=unit install: - pip install tox-travis - - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch lbryumx && popd - - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd script: tox - <<: *tests python: "3.6" diff --git a/setup.cfg b/setup.cfg index ab05b38df..9a037263d 100644 --- a/setup.cfg +++ b/setup.cfg @@ -10,7 +10,7 @@ source = ignore_missing_imports = True [pylint] -ignore=words +ignore=words,server max-args=10 max-line-length=110 good-names=T,t,n,i,j,k,x,y,s,f,d,h,c,e,op,db,tx,io,cachedproperty,log,id diff --git a/setup.py b/setup.py index 2531fa89e..f7e59b068 100644 --- a/setup.py +++ b/setup.py @@ -3,6 +3,10 @@ from setuptools import setup, find_packages import torba +BASE = os.path.dirname(__file__) +with open(os.path.join(BASE, 'README.md'), encoding='utf-8') as fh: + long_description = fh.read() + setup( name='torba', version=torba.__version__, @@ -10,11 +14,10 @@ setup( license='MIT', author='LBRY Inc.', author_email='hello@lbry.io', - description='Wallet library for bitcoin based currencies.', - long_description=open(os.path.join(os.path.dirname(__file__), 'README.md'), - encoding='utf-8').read(), + description='Wallet client/server framework for bitcoin based currencies.', + long_description=long_description, long_description_content_type="text/markdown", - keywords='wallet,crypto,currency,money,bitcoin,lbry', + keywords='wallet,crypto,currency,money,bitcoin,electrum,electrumx', classifiers=( 'Framework :: AsyncIO', 'Intended Audience :: Developers', @@ -23,13 +26,16 @@ setup( 'Programming Language :: Python :: 3', 'Operating System :: OS Independent', 'Topic :: Internet', + 'Topic :: Software Development :: Testing', 'Topic :: Software Development :: Libraries :: Python Modules', + 'Topic :: System :: Benchmark', 'Topic :: System :: Distributed Computing', 'Topic :: Utilities', ), packages=find_packages(exclude=('tests',)), python_requires='>=3.6', install_requires=( + 'aiohttp', 'aiorpcx==0.9.0', 'coincurve', 'pbkdf2', @@ -38,6 +44,13 @@ setup( extras_require={ 'test': ( 'mock', - ) - } + 'requests', + ), + 'server': ( + 'attrs', + 'plyvel', + 'pylru' + ), + }, + entry_points={'console_scripts': ['torba=torba.cli:main']} ) diff --git a/tests/integration/test_reconnect.py b/tests/integration/test_reconnect.py index b7a3b9d81..a2cb19d67 100644 --- a/tests/integration/test_reconnect.py +++ b/tests/integration/test_reconnect.py @@ -1,3 +1,4 @@ +import logging from asyncio import CancelledError from orchstr8.testcase import IntegrationTestCase @@ -6,7 +7,7 @@ from torba.constants import COIN class ReconnectTests(IntegrationTestCase): - VERBOSE = False + VERBOSITY = logging.DEBUG async def test_connection_drop_still_receives_events_after_reconnected(self): address1 = await self.account.receiving.get_or_create_usable_address() @@ -31,4 +32,3 @@ class ReconnectTests(IntegrationTestCase): await self.blockchain.generate(1) # omg, the burned cable still works! torba is fire proof! await self.ledger.network.get_transaction(sendtxid) - diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py index 8b5c7a263..99c5cd5fd 100644 --- a/tests/integration/test_transactions.py +++ b/tests/integration/test_transactions.py @@ -1,11 +1,12 @@ +import logging import asyncio -from orchstr8.testcase import IntegrationTestCase +from torba.testing import IntegrationTestCase from torba.constants import COIN class BasicTransactionTests(IntegrationTestCase): - VERBOSE = False + VERBOSITY = logging.WARNING async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) diff --git a/torba/cli.py b/torba/cli.py new file mode 100644 index 000000000..17d293737 --- /dev/null +++ b/torba/cli.py @@ -0,0 +1,89 @@ +import logging +import argparse +import asyncio +import aiohttp + +from torba.testing.node import Conductor, get_ledger_from_environment, get_blockchain_node_from_ledger +from torba.testing.service import TestingServiceAPI + + +def get_argument_parser(): + parser = argparse.ArgumentParser( + prog="torba" + ) + subparsers = parser.add_subparsers(dest='command', help='sub-command help') + + gui = subparsers.add_parser("gui", help="Start Qt GUI.") + + download = subparsers.add_parser("download", help="Download blockchain node binary.") + + start = subparsers.add_parser("start", help="Start orchstr8 service.") + start.add_argument("--blockchain", help="Start blockchain node.", action="store_true") + start.add_argument("--spv", help="Start SPV server.", action="store_true") + start.add_argument("--wallet", help="Start wallet daemon.", action="store_true") + + generate = subparsers.add_parser("generate", help="Call generate method on running orchstr8 instance.") + generate.add_argument("blocks", type=int, help="Number of blocks to generate") + + transfer = subparsers.add_parser("transfer", help="Call transfer method on running orchstr8 instance.") + return parser + + +async def run_remote_command(command, **kwargs): + async with aiohttp.ClientSession() as session: + async with session.post('http://localhost:7954/'+command, data=kwargs) as resp: + print(resp.status) + print(await resp.text()) + + +def main(): + parser = get_argument_parser() + args = parser.parse_args() + command = getattr(args, 'command', 'help') + + if command == 'gui': + from torba.workbench import main as start_app + return start_app() + + loop = asyncio.get_event_loop() + ledger = get_ledger_from_environment() + + if command == 'download': + logging.getLogger('blockchain').setLevel(logging.INFO) + get_blockchain_node_from_ledger(ledger).ensure() + + elif command == 'generate': + loop.run_until_complete(run_remote_command( + 'generate', blocks=args.blocks + )) + + elif command == 'start': + + conductor = Conductor() + if getattr(args, 'blockchain', False): + loop.run_until_complete(conductor.start_blockchain()) + if getattr(args, 'spv', False): + loop.run_until_complete(conductor.start_spv()) + if getattr(args, 'wallet', False): + loop.run_until_complete(conductor.start_wallet()) + + service = TestingServiceAPI(conductor, loop) + loop.run_until_complete(service.start()) + + try: + print('========== Orchstr8 API Service Started ========') + loop.run_forever() + except KeyboardInterrupt: + pass + finally: + loop.run_until_complete(service.stop()) + loop.run_until_complete(conductor.stop()) + + loop.close() + + else: + parser.print_help() + + +if __name__ == "__main__": + main() diff --git a/torba/coin/bitcoincash.py b/torba/coin/bitcoincash.py index 77e991217..29e548910 100644 --- a/torba/coin/bitcoincash.py +++ b/torba/coin/bitcoincash.py @@ -4,7 +4,7 @@ __node_bin__ = 'bitcoin-abc-0.17.2/bin' __node_url__ = ( 'https://download.bitcoinabc.org/0.17.2/linux/bitcoin-abc-0.17.2-x86_64-linux-gnu.tar.gz' ) -__electrumx__ = 'electrumx.lib.coins.BitcoinCashRegtest' +__spvserver__ = 'torba.server.coins.BitcoinCashRegtest' from binascii import unhexlify from torba.baseledger import BaseLedger diff --git a/torba/coin/bitcoinsegwit.py b/torba/coin/bitcoinsegwit.py index 167551086..13cffbd01 100644 --- a/torba/coin/bitcoinsegwit.py +++ b/torba/coin/bitcoinsegwit.py @@ -4,7 +4,7 @@ __node_bin__ = 'bitcoin-0.16.3/bin' __node_url__ = ( 'https://bitcoin.org/bin/bitcoin-core-0.16.3/bitcoin-0.16.3-x86_64-linux-gnu.tar.gz' ) -__electrumx__ = 'electrumx.lib.coins.BitcoinSegwitRegtest' +__spvserver__ = 'torba.server.coins.BitcoinSegwitRegtest' import struct from typing import Optional diff --git a/torba/server/__init__.py b/torba/server/__init__.py new file mode 100644 index 000000000..b7f2cf595 --- /dev/null +++ b/torba/server/__init__.py @@ -0,0 +1 @@ +from .server import Server diff --git a/torba/server/block_processor.py b/torba/server/block_processor.py new file mode 100644 index 000000000..a27c48737 --- /dev/null +++ b/torba/server/block_processor.py @@ -0,0 +1,713 @@ +# Copyright (c) 2016-2017, Neil Booth +# Copyright (c) 2017, the ElectrumX authors +# +# All rights reserved. +# +# See the file "LICENCE" for information about the copyright +# and warranty status of this software. + +'''Block prefetcher and chain processor.''' + + +import array +import asyncio +from struct import pack, unpack +import time +from functools import partial + +from aiorpcx import TaskGroup, run_in_thread + +import torba +from torba.server.daemon import DaemonError +from torba.server.hash import hash_to_hex_str, HASHX_LEN +from torba.server.util import chunks, class_logger +from torba.server.db import FlushData + + +class Prefetcher(object): + '''Prefetches blocks (in the forward direction only).''' + + def __init__(self, daemon, coin, blocks_event): + self.logger = class_logger(__name__, self.__class__.__name__) + self.daemon = daemon + self.coin = coin + self.blocks_event = blocks_event + self.blocks = [] + self.caught_up = False + # Access to fetched_height should be protected by the semaphore + self.fetched_height = None + self.semaphore = asyncio.Semaphore() + self.refill_event = asyncio.Event() + # The prefetched block cache size. The min cache size has + # little effect on sync time. + self.cache_size = 0 + self.min_cache_size = 10 * 1024 * 1024 + # This makes the first fetch be 10 blocks + self.ave_size = self.min_cache_size // 10 + self.polling_delay = 5 + + async def main_loop(self, bp_height): + '''Loop forever polling for more blocks.''' + await self.reset_height(bp_height) + while True: + try: + # Sleep a while if there is nothing to prefetch + await self.refill_event.wait() + if not await self._prefetch_blocks(): + await asyncio.sleep(self.polling_delay) + except DaemonError as e: + self.logger.info(f'ignoring daemon error: {e}') + + def get_prefetched_blocks(self): + '''Called by block processor when it is processing queued blocks.''' + blocks = self.blocks + self.blocks = [] + self.cache_size = 0 + self.refill_event.set() + return blocks + + async def reset_height(self, height): + '''Reset to prefetch blocks from the block processor's height. + + Used in blockchain reorganisations. This coroutine can be + called asynchronously to the _prefetch_blocks coroutine so we + must synchronize with a semaphore. + ''' + async with self.semaphore: + self.blocks.clear() + self.cache_size = 0 + self.fetched_height = height + self.refill_event.set() + + daemon_height = await self.daemon.height() + behind = daemon_height - height + if behind > 0: + self.logger.info('catching up to daemon height {:,d} ' + '({:,d} blocks behind)' + .format(daemon_height, behind)) + else: + self.logger.info('caught up to daemon height {:,d}' + .format(daemon_height)) + + async def _prefetch_blocks(self): + '''Prefetch some blocks and put them on the queue. + + Repeats until the queue is full or caught up. + ''' + daemon = self.daemon + daemon_height = await daemon.height() + async with self.semaphore: + while self.cache_size < self.min_cache_size: + # Try and catch up all blocks but limit to room in cache. + # Constrain fetch count to between 0 and 500 regardless; + # testnet can be lumpy. + cache_room = self.min_cache_size // self.ave_size + count = min(daemon_height - self.fetched_height, cache_room) + count = min(500, max(count, 0)) + if not count: + self.caught_up = True + return False + + first = self.fetched_height + 1 + hex_hashes = await daemon.block_hex_hashes(first, count) + if self.caught_up: + self.logger.info('new block height {:,d} hash {}' + .format(first + count-1, hex_hashes[-1])) + blocks = await daemon.raw_blocks(hex_hashes) + + assert count == len(blocks) + + # Special handling for genesis block + if first == 0: + blocks[0] = self.coin.genesis_block(blocks[0]) + self.logger.info('verified genesis block with hash {}' + .format(hex_hashes[0])) + + # Update our recent average block size estimate + size = sum(len(block) for block in blocks) + if count >= 10: + self.ave_size = size // count + else: + self.ave_size = (size + (10 - count) * self.ave_size) // 10 + + self.blocks.extend(blocks) + self.cache_size += size + self.fetched_height += count + self.blocks_event.set() + + self.refill_event.clear() + return True + + +class ChainError(Exception): + '''Raised on error processing blocks.''' + + +class BlockProcessor(object): + '''Process blocks and update the DB state to match. + + Employ a prefetcher to prefetch blocks in batches for processing. + Coordinate backing up in case of chain reorganisations. + ''' + + def __init__(self, env, db, daemon, notifications): + self.env = env + self.db = db + self.daemon = daemon + self.notifications = notifications + + self.coin = env.coin + self.blocks_event = asyncio.Event() + self.prefetcher = Prefetcher(daemon, env.coin, self.blocks_event) + self.logger = class_logger(__name__, self.__class__.__name__) + + # Meta + self.next_cache_check = 0 + self.touched = set() + self.reorg_count = 0 + + # Caches of unflushed items. + self.headers = [] + self.tx_hashes = [] + self.undo_infos = [] + + # UTXO cache + self.utxo_cache = {} + self.db_deletes = [] + + # If the lock is successfully acquired, in-memory chain state + # is consistent with self.height + self.state_lock = asyncio.Lock() + + async def run_in_thread_with_lock(self, func, *args): + # Run in a thread to prevent blocking. Shielded so that + # cancellations from shutdown don't lose work - when the task + # completes the data will be flushed and then we shut down. + # Take the state lock to be certain in-memory state is + # consistent and not being updated elsewhere. + async def run_in_thread_locked(): + async with self.state_lock: + return await run_in_thread(func, *args) + return await asyncio.shield(run_in_thread_locked()) + + async def check_and_advance_blocks(self, raw_blocks): + '''Process the list of raw blocks passed. Detects and handles + reorgs. + ''' + if not raw_blocks: + return + first = self.height + 1 + blocks = [self.coin.block(raw_block, first + n) + for n, raw_block in enumerate(raw_blocks)] + headers = [block.header for block in blocks] + hprevs = [self.coin.header_prevhash(h) for h in headers] + chain = [self.tip] + [self.coin.header_hash(h) for h in headers[:-1]] + + if hprevs == chain: + start = time.time() + await self.run_in_thread_with_lock(self.advance_blocks, blocks) + await self._maybe_flush() + if not self.db.first_sync: + s = '' if len(blocks) == 1 else 's' + self.logger.info('processed {:,d} block{} in {:.1f}s' + .format(len(blocks), s, + time.time() - start)) + if self._caught_up_event.is_set(): + await self.notifications.on_block(self.touched, self.height) + self.touched = set() + elif hprevs[0] != chain[0]: + await self.reorg_chain() + else: + # It is probably possible but extremely rare that what + # bitcoind returns doesn't form a chain because it + # reorg-ed the chain as it was processing the batched + # block hash requests. Should this happen it's simplest + # just to reset the prefetcher and try again. + self.logger.warning('daemon blocks do not form a chain; ' + 'resetting the prefetcher') + await self.prefetcher.reset_height(self.height) + + async def reorg_chain(self, count=None): + '''Handle a chain reorganisation. + + Count is the number of blocks to simulate a reorg, or None for + a real reorg.''' + if count is None: + self.logger.info('chain reorg detected') + else: + self.logger.info(f'faking a reorg of {count:,d} blocks') + await self.flush(True) + + async def get_raw_blocks(last_height, hex_hashes): + heights = range(last_height, last_height - len(hex_hashes), -1) + try: + blocks = [self.db.read_raw_block(height) for height in heights] + self.logger.info(f'read {len(blocks)} blocks from disk') + return blocks + except FileNotFoundError: + return await self.daemon.raw_blocks(hex_hashes) + + def flush_backup(): + # self.touched can include other addresses which is + # harmless, but remove None. + self.touched.discard(None) + self.db.flush_backup(self.flush_data(), self.touched) + + start, last, hashes = await self.reorg_hashes(count) + # Reverse and convert to hex strings. + hashes = [hash_to_hex_str(hash) for hash in reversed(hashes)] + for hex_hashes in chunks(hashes, 50): + raw_blocks = await get_raw_blocks(last, hex_hashes) + await self.run_in_thread_with_lock(self.backup_blocks, raw_blocks) + await self.run_in_thread_with_lock(flush_backup) + last -= len(raw_blocks) + await self.prefetcher.reset_height(self.height) + + async def reorg_hashes(self, count): + '''Return a pair (start, last, hashes) of blocks to back up during a + reorg. + + The hashes are returned in order of increasing height. Start + is the height of the first hash, last of the last. + ''' + start, count = await self.calc_reorg_range(count) + last = start + count - 1 + s = '' if count == 1 else 's' + self.logger.info(f'chain was reorganised replacing {count:,d} ' + f'block{s} at heights {start:,d}-{last:,d}') + + return start, last, await self.db.fs_block_hashes(start, count) + + async def calc_reorg_range(self, count): + '''Calculate the reorg range''' + + def diff_pos(hashes1, hashes2): + '''Returns the index of the first difference in the hash lists. + If both lists match returns their length.''' + for n, (hash1, hash2) in enumerate(zip(hashes1, hashes2)): + if hash1 != hash2: + return n + return len(hashes) + + if count is None: + # A real reorg + start = self.height - 1 + count = 1 + while start > 0: + hashes = await self.db.fs_block_hashes(start, count) + hex_hashes = [hash_to_hex_str(hash) for hash in hashes] + d_hex_hashes = await self.daemon.block_hex_hashes(start, count) + n = diff_pos(hex_hashes, d_hex_hashes) + if n > 0: + start += n + break + count = min(count * 2, start) + start -= count + + count = (self.height - start) + 1 + else: + start = (self.height - count) + 1 + + return start, count + + def estimate_txs_remaining(self): + # Try to estimate how many txs there are to go + daemon_height = self.daemon.cached_height() + coin = self.coin + tail_count = daemon_height - max(self.height, coin.TX_COUNT_HEIGHT) + # Damp the initial enthusiasm + realism = max(2.0 - 0.9 * self.height / coin.TX_COUNT_HEIGHT, 1.0) + return (tail_count * coin.TX_PER_BLOCK + + max(coin.TX_COUNT - self.tx_count, 0)) * realism + + # - Flushing + def flush_data(self): + '''The data for a flush. The lock must be taken.''' + assert self.state_lock.locked() + return FlushData(self.height, self.tx_count, self.headers, + self.tx_hashes, self.undo_infos, self.utxo_cache, + self.db_deletes, self.tip) + + async def flush(self, flush_utxos): + def flush(): + self.db.flush_dbs(self.flush_data(), flush_utxos, + self.estimate_txs_remaining) + await self.run_in_thread_with_lock(flush) + + async def _maybe_flush(self): + # If caught up, flush everything as client queries are + # performed on the DB. + if self._caught_up_event.is_set(): + await self.flush(True) + elif time.time() > self.next_cache_check: + flush_arg = self.check_cache_size() + if flush_arg is not None: + await self.flush(flush_arg) + self.next_cache_check = time.time() + 30 + + def check_cache_size(self): + '''Flush a cache if it gets too big.''' + # Good average estimates based on traversal of subobjects and + # requesting size from Python (see deep_getsizeof). + one_MB = 1000*1000 + utxo_cache_size = len(self.utxo_cache) * 205 + db_deletes_size = len(self.db_deletes) * 57 + hist_cache_size = self.db.history.unflushed_memsize() + # Roughly ntxs * 32 + nblocks * 42 + tx_hash_size = ((self.tx_count - self.db.fs_tx_count) * 32 + + (self.height - self.db.fs_height) * 42) + utxo_MB = (db_deletes_size + utxo_cache_size) // one_MB + hist_MB = (hist_cache_size + tx_hash_size) // one_MB + + self.logger.info('our height: {:,d} daemon: {:,d} ' + 'UTXOs {:,d}MB hist {:,d}MB' + .format(self.height, self.daemon.cached_height(), + utxo_MB, hist_MB)) + + # Flush history if it takes up over 20% of cache memory. + # Flush UTXOs once they take up 80% of cache memory. + cache_MB = self.env.cache_MB + if utxo_MB + hist_MB >= cache_MB or hist_MB >= cache_MB // 5: + return utxo_MB >= cache_MB * 4 // 5 + return None + + def advance_blocks(self, blocks): + '''Synchronously advance the blocks. + + It is already verified they correctly connect onto our tip. + ''' + min_height = self.db.min_undo_height(self.daemon.cached_height()) + height = self.height + + for block in blocks: + height += 1 + undo_info = self.advance_txs(block.transactions) + if height >= min_height: + self.undo_infos.append((undo_info, height)) + self.db.write_raw_block(block.raw, height) + + headers = [block.header for block in blocks] + self.height = height + self.headers.extend(headers) + self.tip = self.coin.header_hash(headers[-1]) + + def advance_txs(self, txs): + self.tx_hashes.append(b''.join(tx_hash for tx, tx_hash in txs)) + + # Use local vars for speed in the loops + undo_info = [] + tx_num = self.tx_count + script_hashX = self.coin.hashX_from_script + s_pack = pack + put_utxo = self.utxo_cache.__setitem__ + spend_utxo = self.spend_utxo + undo_info_append = undo_info.append + update_touched = self.touched.update + hashXs_by_tx = [] + append_hashXs = hashXs_by_tx.append + + for tx, tx_hash in txs: + hashXs = [] + append_hashX = hashXs.append + tx_numb = s_pack('= len(raw_blocks) + + coin = self.coin + for raw_block in raw_blocks: + # Check and update self.tip + block = coin.block(raw_block, self.height) + header_hash = coin.header_hash(block.header) + if header_hash != self.tip: + raise ChainError('backup block {} not tip {} at height {:,d}' + .format(hash_to_hex_str(header_hash), + hash_to_hex_str(self.tip), + self.height)) + self.tip = coin.header_prevhash(block.header) + self.backup_txs(block.transactions) + self.height -= 1 + self.db.tx_counts.pop() + + self.logger.info('backed up to height {:,d}'.format(self.height)) + + def backup_txs(self, txs): + # Prevout values, in order down the block (coinbase first if present) + # undo_info is in reverse block order + undo_info = self.db.read_undo_info(self.height) + if undo_info is None: + raise ChainError('no undo information found for height {:,d}' + .format(self.height)) + n = len(undo_info) + + # Use local vars for speed in the loops + s_pack = pack + put_utxo = self.utxo_cache.__setitem__ + spend_utxo = self.spend_utxo + script_hashX = self.coin.hashX_from_script + touched = self.touched + undo_entry_len = 12 + HASHX_LEN + + for tx, tx_hash in reversed(txs): + for idx, txout in enumerate(tx.outputs): + # Spend the TX outputs. Be careful with unspendable + # outputs - we didn't save those in the first place. + hashX = script_hashX(txout.pk_script) + if hashX: + cache_value = spend_utxo(tx_hash, idx) + touched.add(cache_value[:-12]) + + # Restore the inputs + for txin in reversed(tx.inputs): + if txin.is_generation(): + continue + n -= undo_entry_len + undo_item = undo_info[n:n + undo_entry_len] + put_utxo(txin.prev_hash + s_pack(' 1: + tx_num, = unpack('False state. + first_sync = self.db.first_sync + self.db.first_sync = False + await self.flush(True) + if first_sync: + self.logger.info(f'{torba.__version__} synced to ' + f'height {self.height:,d}') + # Reopen for serving + await self.db.open_for_serving() + + async def _first_open_dbs(self): + await self.db.open_for_sync() + self.height = self.db.db_height + self.tip = self.db.db_tip + self.tx_count = self.db.db_tx_count + + # --- External API + + async def fetch_and_process_blocks(self, caught_up_event): + '''Fetch, process and index blocks from the daemon. + + Sets caught_up_event when first caught up. Flushes to disk + and shuts down cleanly if cancelled. + + This is mainly because if, during initial sync ElectrumX is + asked to shut down when a large number of blocks have been + processed but not written to disk, it should write those to + disk before exiting, as otherwise a significant amount of work + could be lost. + ''' + self._caught_up_event = caught_up_event + await self._first_open_dbs() + try: + async with TaskGroup() as group: + await group.spawn(self.prefetcher.main_loop(self.height)) + await group.spawn(self._process_prefetched_blocks()) + finally: + # Shut down block processing + self.logger.info('flushing to DB for a clean shutdown...') + await self.flush(True) + + def force_chain_reorg(self, count): + '''Force a reorg of the given number of blocks. + + Returns True if a reorg is queued, false if not caught up. + ''' + if self._caught_up_event.is_set(): + self.reorg_count = count + self.blocks_event.set() + return True + return False + + +class DecredBlockProcessor(BlockProcessor): + async def calc_reorg_range(self, count): + start, count = await super().calc_reorg_range(count) + if start > 0: + # A reorg in Decred can invalidate the previous block + start -= 1 + count += 1 + return start, count + + +class NamecoinBlockProcessor(BlockProcessor): + def advance_txs(self, txs): + result = super().advance_txs(txs) + + tx_num = self.tx_count - len(txs) + script_name_hashX = self.coin.name_hashX_from_script + update_touched = self.touched.update + hashXs_by_tx = [] + append_hashXs = hashXs_by_tx.append + + for tx, tx_hash in txs: + hashXs = [] + append_hashX = hashXs.append + + # Add the new UTXOs and associate them with the name script + for idx, txout in enumerate(tx.outputs): + # Get the hashX of the name script. Ignore non-name scripts. + hashX = script_name_hashX(txout.pk_script) + if hashX: + append_hashX(hashX) + + append_hashXs(hashXs) + update_touched(hashXs) + tx_num += 1 + + self.db.history.add_unflushed(hashXs_by_tx, self.tx_count - len(txs)) + + return result diff --git a/torba/server/coins.py b/torba/server/coins.py new file mode 100644 index 000000000..af1829842 --- /dev/null +++ b/torba/server/coins.py @@ -0,0 +1,2290 @@ +# Copyright (c) 2016-2017, Neil Booth +# Copyright (c) 2017, the ElectrumX authors +# +# All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +'''Module providing coin abstraction. + +Anything coin-specific should go in this file and be subclassed where +necessary for appropriate handling. +''' + +from collections import namedtuple +import re +import struct +from decimal import Decimal +from hashlib import sha256 +from functools import partial +import base64 +from typing import Type, List + +import torba.server.util as util +from torba.server.hash import Base58, hash160, double_sha256, hash_to_hex_str +from torba.server.hash import HASHX_LEN, hex_str_to_hash +from torba.server.script import ScriptPubKey, OpCodes +import torba.server.tx as lib_tx +import torba.server.block_processor as block_proc +import torba.server.daemon as daemon +from torba.server.session import ElectrumX, DashElectrumX + + +Block = namedtuple("Block", "raw header transactions") +OP_RETURN = OpCodes.OP_RETURN + + +class CoinError(Exception): + '''Exception raised for coin-related errors.''' + + +class Coin(object): + '''Base class of coin hierarchy.''' + + REORG_LIMIT = 200 + # Not sure if these are coin-specific + RPC_URL_REGEX = re.compile('.+@(\\[[0-9a-fA-F:]+\\]|[^:]+)(:[0-9]+)?') + VALUE_PER_COIN = 100000000 + CHUNK_SIZE = 2016 + BASIC_HEADER_SIZE = 80 + STATIC_BLOCK_HEADERS = True + SESSIONCLS = ElectrumX + DESERIALIZER = lib_tx.Deserializer + DAEMON = daemon.Daemon + BLOCK_PROCESSOR = block_proc.BlockProcessor + HEADER_VALUES = [ + 'version', 'prev_block_hash', 'merkle_root', 'timestamp', 'bits', 'nonce' + ] + HEADER_UNPACK = struct.Struct('< I 32s 32s I I I').unpack_from + MEMPOOL_HISTOGRAM_REFRESH_SECS = 500 + XPUB_VERBYTES = bytes('????', 'utf-8') + XPRV_VERBYTES = bytes('????', 'utf-8') + ENCODE_CHECK = Base58.encode_check + DECODE_CHECK = Base58.decode_check + # Peer discovery + PEER_DEFAULT_PORTS = {'t': '50001', 's': '50002'} + PEERS: List[str] = [] + + @classmethod + def lookup_coin_class(cls, name, net): + '''Return a coin class given name and network. + + Raise an exception if unrecognised.''' + req_attrs = ['TX_COUNT', 'TX_COUNT_HEIGHT', 'TX_PER_BLOCK'] + for coin in util.subclasses(Coin): + if (coin.NAME.lower() == name.lower() and + coin.NET.lower() == net.lower()): + coin_req_attrs = req_attrs.copy() + missing = [attr for attr in coin_req_attrs + if not hasattr(coin, attr)] + if missing: + raise CoinError('coin {} missing {} attributes' + .format(name, missing)) + return coin + raise CoinError('unknown coin {} and network {} combination' + .format(name, net)) + + @classmethod + def sanitize_url(cls, url): + # Remove surrounding ws and trailing /s + url = url.strip().rstrip('/') + match = cls.RPC_URL_REGEX.match(url) + if not match: + raise CoinError('invalid daemon URL: "{}"'.format(url)) + if match.groups()[1] is None: + url += ':{:d}'.format(cls.RPC_PORT) + if not url.startswith('http://') and not url.startswith('https://'): + url = 'http://' + url + return url + '/' + + @classmethod + def genesis_block(cls, block): + '''Check the Genesis block is the right one for this coin. + + Return the block less its unspendable coinbase. + ''' + header = cls.block_header(block, 0) + header_hex_hash = hash_to_hex_str(cls.header_hash(header)) + if header_hex_hash != cls.GENESIS_HASH: + raise CoinError('genesis block has hash {} expected {}' + .format(header_hex_hash, cls.GENESIS_HASH)) + + return header + bytes(1) + + @classmethod + def hashX_from_script(cls, script): + '''Returns a hashX from a script, or None if the script is provably + unspendable so the output can be dropped. + ''' + if script and script[0] == OP_RETURN: + return None + return sha256(script).digest()[:HASHX_LEN] + + @staticmethod + def lookup_xverbytes(verbytes): + '''Return a (is_xpub, coin_class) pair given xpub/xprv verbytes.''' + # Order means BTC testnet will override NMC testnet + for coin in util.subclasses(Coin): + if verbytes == coin.XPUB_VERBYTES: + return True, coin + if verbytes == coin.XPRV_VERBYTES: + return False, coin + raise CoinError('version bytes unrecognised') + + @classmethod + def address_to_hashX(cls, address): + '''Return a hashX given a coin address.''' + return cls.hashX_from_script(cls.pay_to_address_script(address)) + + @classmethod + def P2PKH_address_from_hash160(cls, hash160): + '''Return a P2PKH address given a public key.''' + assert len(hash160) == 20 + return cls.ENCODE_CHECK(cls.P2PKH_VERBYTE + hash160) + + @classmethod + def P2PKH_address_from_pubkey(cls, pubkey): + '''Return a coin address given a public key.''' + return cls.P2PKH_address_from_hash160(hash160(pubkey)) + + @classmethod + def P2SH_address_from_hash160(cls, hash160): + '''Return a coin address given a hash160.''' + assert len(hash160) == 20 + return cls.ENCODE_CHECK(cls.P2SH_VERBYTES[0] + hash160) + + @classmethod + def hash160_to_P2PKH_script(cls, hash160): + return ScriptPubKey.P2PKH_script(hash160) + + @classmethod + def hash160_to_P2PKH_hashX(cls, hash160): + return cls.hashX_from_script(cls.hash160_to_P2PKH_script(hash160)) + + @classmethod + def pay_to_address_script(cls, address): + '''Return a pubkey script that pays to a pubkey hash. + + Pass the address (either P2PKH or P2SH) in base58 form. + ''' + raw = cls.DECODE_CHECK(address) + + # Require version byte(s) plus hash160. + verbyte = -1 + verlen = len(raw) - 20 + if verlen > 0: + verbyte, hash160 = raw[:verlen], raw[verlen:] + + if verbyte == cls.P2PKH_VERBYTE: + return cls.hash160_to_P2PKH_script(hash160) + if verbyte in cls.P2SH_VERBYTES: + return ScriptPubKey.P2SH_script(hash160) + + raise CoinError('invalid address: {}'.format(address)) + + @classmethod + def privkey_WIF(cls, privkey_bytes, compressed): + '''Return the private key encoded in Wallet Import Format.''' + payload = bytearray(cls.WIF_BYTE) + privkey_bytes + if compressed: + payload.append(0x01) + return cls.ENCODE_CHECK(payload) + + @classmethod + def header_hash(cls, header): + '''Given a header return hash''' + return double_sha256(header) + + @classmethod + def header_prevhash(cls, header): + '''Given a header return previous hash''' + return header[4:36] + + @classmethod + def static_header_offset(cls, height): + '''Given a header height return its offset in the headers file. + + If header sizes change at some point, this is the only code + that needs updating.''' + assert cls.STATIC_BLOCK_HEADERS + return height * cls.BASIC_HEADER_SIZE + + @classmethod + def static_header_len(cls, height): + '''Given a header height return its length.''' + return (cls.static_header_offset(height + 1) + - cls.static_header_offset(height)) + + @classmethod + def block_header(cls, block, height): + '''Returns the block header given a block and its height.''' + return block[:cls.static_header_len(height)] + + @classmethod + def block(cls, raw_block, height): + '''Return a Block namedtuple given a raw block and its height.''' + header = cls.block_header(raw_block, height) + txs = cls.DESERIALIZER(raw_block, start=len(header)).read_tx_block() + return Block(raw_block, header, txs) + + @classmethod + def decimal_value(cls, value): + '''Return the number of standard coin units as a Decimal given a + quantity of smallest units. + + For example 1 BTC is returned for 100 million satoshis. + ''' + return Decimal(value) / cls.VALUE_PER_COIN + + @classmethod + def electrum_header(cls, header, height): + h = dict(zip(cls.HEADER_VALUES, cls.HEADER_UNPACK(header))) + # Add the height that is not present in the header itself + h['block_height'] = height + # Convert bytes to str + h['prev_block_hash'] = hash_to_hex_str(h['prev_block_hash']) + h['merkle_root'] = hash_to_hex_str(h['merkle_root']) + return h + + +class AuxPowMixin(object): + STATIC_BLOCK_HEADERS = False + DESERIALIZER = lib_tx.DeserializerAuxPow + + @classmethod + def header_hash(cls, header): + '''Given a header return hash''' + return double_sha256(header[:cls.BASIC_HEADER_SIZE]) + + @classmethod + def block_header(cls, block, height): + '''Return the AuxPow block header bytes''' + deserializer = cls.DESERIALIZER(block) + return deserializer.read_header(height, cls.BASIC_HEADER_SIZE) + + +class EquihashMixin(object): + STATIC_BLOCK_HEADERS = False + BASIC_HEADER_SIZE = 140 # Excluding Equihash solution + DESERIALIZER = lib_tx.DeserializerEquihash + HEADER_VALUES = ['version', 'prev_block_hash', 'merkle_root', 'reserved', + 'timestamp', 'bits', 'nonce'] + HEADER_UNPACK = struct.Struct('< I 32s 32s 32s I I 32s').unpack_from + + @classmethod + def electrum_header(cls, header, height): + h = dict(zip(cls.HEADER_VALUES, cls.HEADER_UNPACK(header))) + # Add the height that is not present in the header itself + h['block_height'] = height + # Convert bytes to str + h['prev_block_hash'] = hash_to_hex_str(h['prev_block_hash']) + h['merkle_root'] = hash_to_hex_str(h['merkle_root']) + h['reserved'] = hash_to_hex_str(h['reserved']) + h['nonce'] = hash_to_hex_str(h['nonce']) + return h + + @classmethod + def block_header(cls, block, height): + '''Return the block header bytes''' + deserializer = cls.DESERIALIZER(block) + return deserializer.read_header(height, cls.BASIC_HEADER_SIZE) + + +class ScryptMixin(object): + + DESERIALIZER = lib_tx.DeserializerTxTime + HEADER_HASH = None + + @classmethod + def header_hash(cls, header): + '''Given a header return the hash.''' + if cls.HEADER_HASH is None: + import scrypt + cls.HEADER_HASH = lambda x: scrypt.hash(x, x, 1024, 1, 1, 32) + + version, = util.unpack_le_uint32_from(header) + if version > 6: + return super().header_hash(header) + else: + return cls.HEADER_HASH(header) + + +class KomodoMixin(object): + P2PKH_VERBYTE = bytes.fromhex("3C") + P2SH_VERBYTES = [bytes.fromhex("55")] + WIF_BYTE = bytes.fromhex("BC") + GENESIS_HASH = ('027e3758c3a65b12aa1046462b486d0a' + '63bfa1beae327897f56c5cfb7daaae71') + DESERIALIZER = lib_tx.DeserializerZcash + + +class BitcoinMixin(object): + SHORTNAME = "BTC" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + P2PKH_VERBYTE = bytes.fromhex("00") + P2SH_VERBYTES = [bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('000000000019d6689c085ae165831e93' + '4ff763ae46a2a6c172b3f1b60a8ce26f') + RPC_PORT = 8332 + + +class HOdlcoin(Coin): + NAME = "HOdlcoin" + SHORTNAME = "HODLC" + NET = "mainnet" + BASIC_HEADER_SIZE = 88 + P2PKH_VERBYTE = bytes.fromhex("28") + P2SH_VERBYTES = [bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("a8") + GENESIS_HASH = ('008872e5582924544e5c707ee4b839bb' + '82c28a9e94e917c94b40538d5658c04b') + DESERIALIZER = lib_tx.DeserializerSegWit + TX_COUNT = 258858 + TX_COUNT_HEIGHT = 382138 + TX_PER_BLOCK = 5 + + +class BitcoinCash(BitcoinMixin, Coin): + NAME = "BitcoinCash" + SHORTNAME = "BCH" + TX_COUNT = 246362688 + TX_COUNT_HEIGHT = 511484 + TX_PER_BLOCK = 400 + PEERS = [ + 'electroncash.cascharia.com s50002', + 'bch.electrumx.cash s t', + 'bccarihace4jdcnt.onion t52001 s52002', + 'abc1.hsmiths.com t60001 s60002', + 'electroncash.checksum0.com s t', + 'electrumx-cash.1209k.com s t', + 'electrum.leblancnet.us t50011 s50012', + 'electroncash.dk s t', + 'electrum.imaginary.cash s t', + ] + + +class BitcoinSegwit(BitcoinMixin, Coin): + NAME = "BitcoinSegwit" + DESERIALIZER = lib_tx.DeserializerSegWit + MEMPOOL_HISTOGRAM_REFRESH_SECS = 120 + TX_COUNT = 318337769 + TX_COUNT_HEIGHT = 524213 + TX_PER_BLOCK = 1400 + PEERS = [ + 'btc.smsys.me s995', + 'E-X.not.fyi s t', + 'elec.luggs.co s443', + 'electrum.vom-stausee.de s t', + 'electrum3.hachre.de s t', + 'electrum.hsmiths.com s t', + 'helicarrier.bauerj.eu s t', + 'hsmiths4fyqlw5xw.onion s t', + 'luggscoqbymhvnkp.onion t80', + 'ozahtqwp25chjdjd.onion s t', + 'node.arihanc.com s t', + 'arihancckjge66iv.onion s t', + ] + + +class BitcoinGold(EquihashMixin, BitcoinMixin, Coin): + CHUNK_SIZE = 252 + NAME = "BitcoinGold" + SHORTNAME = "BTG" + FORK_HEIGHT = 491407 + P2PKH_VERBYTE = bytes.fromhex("26") + P2SH_VERBYTES = [bytes.fromhex("17")] + DESERIALIZER = lib_tx.DeserializerEquihashSegWit + TX_COUNT = 265026255 + TX_COUNT_HEIGHT = 499923 + TX_PER_BLOCK = 50 + REORG_LIMIT = 1000 + RPC_PORT = 8338 + PEERS = [ + 'electrumx-eu.bitcoingold.org s50002 t50001', + 'electrumx-us.bitcoingold.org s50002 t50001', + 'electrumx-eu.btcgpu.org s50002 t50001', + 'electrumx-us.btcgpu.org s50002 t50001' + ] + + @classmethod + def header_hash(cls, header): + '''Given a header return hash''' + height, = util.unpack_le_uint32_from(header, 68) + if height >= cls.FORK_HEIGHT: + return double_sha256(header) + else: + return double_sha256(header[:68] + header[100:112]) + + @classmethod + def electrum_header(cls, header, height): + h = super().electrum_header(header, height) + h['reserved'] = hash_to_hex_str(header[72:100]) + h['solution'] = hash_to_hex_str(header[140:]) + return h + + +class BitcoinGoldTestnet(BitcoinGold): + FORK_HEIGHT = 1 + SHORTNAME = "TBTG" + XPUB_VERBYTES = bytes.fromhex("043587CF") + XPRV_VERBYTES = bytes.fromhex("04358394") + P2PKH_VERBYTE = bytes.fromhex("6F") + P2SH_VERBYTES = [bytes.fromhex("C4")] + WIF_BYTE = bytes.fromhex("EF") + TX_COUNT = 0 + TX_COUNT_HEIGHT = 1 + NET = 'testnet' + RPC_PORT = 18338 + GENESIS_HASH = ('00000000e0781ebe24b91eedc293adfe' + 'a2f557b53ec379e78959de3853e6f9f6') + PEERS = [ + 'test-node1.bitcoingold.org s50002', + 'test-node2.bitcoingold.org s50002', + 'test-node3.bitcoingold.org s50002', + 'test-node1.btcgpu.org s50002', + 'test-node2.btcgpu.org s50002', + 'test-node3.btcgpu.org s50002' + ] + + +class BitcoinGoldRegtest(BitcoinGold): + FORK_HEIGHT = 2000 + SHORTNAME = "TBTG" + XPUB_VERBYTES = bytes.fromhex("043587CF") + XPRV_VERBYTES = bytes.fromhex("04358394") + P2PKH_VERBYTE = bytes.fromhex("6F") + P2SH_VERBYTES = [bytes.fromhex("C4")] + WIF_BYTE = bytes.fromhex("EF") + TX_COUNT = 0 + TX_COUNT_HEIGHT = 1 + NET = 'regtest' + RPC_PORT = 18444 + GENESIS_HASH = ('0f9188f13cb7b2c71f2a335e3a4fc328' + 'bf5beb436012afca590b1a11466e2206') + PEERS: List[str] = [] + + +class Emercoin(Coin): + NAME = "Emercoin" + SHORTNAME = "EMC" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + P2PKH_VERBYTE = bytes.fromhex("21") + P2SH_VERBYTES = [bytes.fromhex("5c")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('00000000bcccd459d036a588d1008fce' + '8da3754b205736f32ddfd35350e84c2d') + TX_COUNT = 217380620 + TX_COUNT_HEIGHT = 464000 + TX_PER_BLOCK = 1700 + VALUE_PER_COIN = 1000000 + RPC_PORT = 6662 + + DESERIALIZER = lib_tx.DeserializerTxTimeAuxPow + + PEERS: List[str] = [] + + @classmethod + def block_header(cls, block, height): + '''Returns the block header given a block and its height.''' + deserializer = cls.DESERIALIZER(block) + + if deserializer.is_merged_block(): + return deserializer.read_header(height, cls.BASIC_HEADER_SIZE) + return block[:cls.static_header_len(height)] + + @classmethod + def header_hash(cls, header): + '''Given a header return hash''' + return double_sha256(header[:cls.BASIC_HEADER_SIZE]) + + +class BitcoinTestnetMixin(object): + SHORTNAME = "XTN" + NET = "testnet" + XPUB_VERBYTES = bytes.fromhex("043587cf") + XPRV_VERBYTES = bytes.fromhex("04358394") + P2PKH_VERBYTE = bytes.fromhex("6f") + P2SH_VERBYTES = [bytes.fromhex("c4")] + WIF_BYTE = bytes.fromhex("ef") + GENESIS_HASH = ('000000000933ea01ad0ee984209779ba' + 'aec3ced90fa3f408719526f8d77f4943') + REORG_LIMIT = 8000 + TX_COUNT = 12242438 + TX_COUNT_HEIGHT = 1035428 + TX_PER_BLOCK = 21 + RPC_PORT = 18332 + PEER_DEFAULT_PORTS = {'t': '51001', 's': '51002'} + + +class BitcoinCashTestnet(BitcoinTestnetMixin, Coin): + '''Bitcoin Testnet for Bitcoin Cash daemons.''' + NAME = "BitcoinCash" + PEERS = [ + 'electrum-testnet-abc.criptolayer.net s50112', + 'bchtestnet.arihanc.com t53001 s53002', + 'ciiattqkgzebpp6jofjbrkhvhwmgnsfoayljdcrve2p3qmkbv3duaoyd.onion ' + 't53001 s53002', + ] + + +class BitcoinCashRegtest(BitcoinCashTestnet): + NET = "regtest" + GENESIS_HASH = ('0f9188f13cb7b2c71f2a335e3a4fc328' + 'bf5beb436012afca590b1a11466e2206') + PEERS: List[str] = [] + TX_COUNT = 1 + TX_COUNT_HEIGHT = 1 + + +class BitcoinSegwitTestnet(BitcoinTestnetMixin, Coin): + '''Bitcoin Testnet for Core bitcoind >= 0.13.1.''' + NAME = "BitcoinSegwit" + DESERIALIZER = lib_tx.DeserializerSegWit + PEERS = [ + 'electrum.akinbo.org s t', + 'he36kyperp3kbuxu.onion s t', + 'testnet.hsmiths.com t53011 s53012', + 'hsmithsxurybd7uh.onion t53011 s53012', + 'testnetnode.arihanc.com s t', + 'w3e2orjpiiv2qwem3dw66d7c4krink4nhttngkylglpqe5r22n6n5wid.onion s t', + 'testnet.qtornado.com s t', + ] + + +class BitcoinSegwitRegtest(BitcoinSegwitTestnet): + NAME = "BitcoinSegwit" + NET = "regtest" + GENESIS_HASH = ('0f9188f13cb7b2c71f2a335e3a4fc328' + 'bf5beb436012afca590b1a11466e2206') + PEERS: List[str] = [] + TX_COUNT = 1 + TX_COUNT_HEIGHT = 1 + + +class BitcoinNolnet(BitcoinCash): + '''Bitcoin Unlimited nolimit testnet.''' + NET = "nolnet" + GENESIS_HASH = ('0000000057e31bd2066c939a63b7b862' + '3bd0f10d8c001304bdfc1a7902ae6d35') + PEERS: List[str] = [] + REORG_LIMIT = 8000 + TX_COUNT = 583589 + TX_COUNT_HEIGHT = 8617 + TX_PER_BLOCK = 50 + RPC_PORT = 28332 + PEER_DEFAULT_PORTS = {'t': '52001', 's': '52002'} + + +class Litecoin(Coin): + NAME = "Litecoin" + SHORTNAME = "LTC" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + P2PKH_VERBYTE = bytes.fromhex("30") + P2SH_VERBYTES = [bytes.fromhex("32"), bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("b0") + GENESIS_HASH = ('12a765e31ffd4059bada1e25190f6e98' + 'c99d9714d334efa41a195a7e7e04bfe2') + DESERIALIZER = lib_tx.DeserializerSegWit + TX_COUNT = 8908766 + TX_COUNT_HEIGHT = 1105256 + TX_PER_BLOCK = 10 + RPC_PORT = 9332 + REORG_LIMIT = 800 + PEERS = [ + 'elec.luggs.co s444', + 'electrum-ltc.bysh.me s t', + 'electrum-ltc.ddns.net s t', + 'electrum-ltc.wilv.in s t', + 'electrum.cryptomachine.com p1000 s t', + 'electrum.ltc.xurious.com s t', + 'eywr5eubdbbe2laq.onion s50008 t50007', + ] + + +class LitecoinTestnet(Litecoin): + SHORTNAME = "XLT" + NET = "testnet" + XPUB_VERBYTES = bytes.fromhex("043587cf") + XPRV_VERBYTES = bytes.fromhex("04358394") + P2PKH_VERBYTE = bytes.fromhex("6f") + P2SH_VERBYTES = [bytes.fromhex("3a"), bytes.fromhex("c4")] + WIF_BYTE = bytes.fromhex("ef") + GENESIS_HASH = ('4966625a4b2851d9fdee139e56211a0d' + '88575f59ed816ff5e6a63deb4e3e29a0') + TX_COUNT = 21772 + TX_COUNT_HEIGHT = 20800 + TX_PER_BLOCK = 2 + RPC_PORT = 19332 + REORG_LIMIT = 4000 + PEER_DEFAULT_PORTS = {'t': '51001', 's': '51002'} + PEERS = [ + 'electrum-ltc.bysh.me s t', + 'electrum.ltc.xurious.com s t', + ] + + +class Viacoin(AuxPowMixin, Coin): + NAME = "Viacoin" + SHORTNAME = "VIA" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("47") + P2SH_VERBYTES = [bytes.fromhex("21")] + WIF_BYTE = bytes.fromhex("c7") + GENESIS_HASH = ('4e9b54001f9976049830128ec0331515' + 'eaabe35a70970d79971da1539a400ba1') + TX_COUNT = 113638 + TX_COUNT_HEIGHT = 3473674 + TX_PER_BLOCK = 30 + RPC_PORT = 5222 + REORG_LIMIT = 5000 + DESERIALIZER: Type = lib_tx.DeserializerAuxPowSegWit + PEERS = [ + 'vialectrum.bitops.me s t', + 'server.vialectrum.org s t', + 'vialectrum.viacoin.net s t', + 'viax1.bitops.me s t', + ] + + +class ViacoinTestnet(Viacoin): + SHORTNAME = "TVI" + NET = "testnet" + P2PKH_VERBYTE = bytes.fromhex("7f") + P2SH_VERBYTES = [bytes.fromhex("c4")] + WIF_BYTE = bytes.fromhex("ff") + GENESIS_HASH = ('00000007199508e34a9ff81e6ec0c477' + 'a4cccff2a4767a8eee39c11db367b008') + RPC_PORT = 25222 + REORG_LIMIT = 2500 + PEER_DEFAULT_PORTS = {'t': '51001', 's': '51002'} + PEERS = [ + 'vialectrum.bysh.me s t', + ] + + +class ViacoinTestnetSegWit(ViacoinTestnet): + NET = "testnet-segwit" + DESERIALIZER = lib_tx.DeserializerSegWit + + +# Source: namecoin.org +class Namecoin(AuxPowMixin, Coin): + NAME = "Namecoin" + SHORTNAME = "NMC" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("d7dd6370") + XPRV_VERBYTES = bytes.fromhex("d7dc6e31") + P2PKH_VERBYTE = bytes.fromhex("34") + P2SH_VERBYTES = [bytes.fromhex("0d")] + WIF_BYTE = bytes.fromhex("e4") + GENESIS_HASH = ('000000000062b72c5e2ceb45fbc8587e' + '807c155b0da735e6483dfba2f0a9c770') + TX_COUNT = 4415768 + TX_COUNT_HEIGHT = 329065 + TX_PER_BLOCK = 10 + PEERS = [ + 'elec.luggs.co s446', + ] + BLOCK_PROCESSOR = block_proc.NamecoinBlockProcessor + + @classmethod + def split_name_script(cls, script): + from torba.server.script import _match_ops, Script, ScriptError + + try: + ops = Script.get_ops(script) + except ScriptError: + return None, script + + match = _match_ops + + # Name opcodes + OP_NAME_NEW = OpCodes.OP_1 + OP_NAME_FIRSTUPDATE = OpCodes.OP_2 + OP_NAME_UPDATE = OpCodes.OP_3 + + # Opcode sequences for name operations + NAME_NEW_OPS = [OP_NAME_NEW, -1, OpCodes.OP_2DROP] + NAME_FIRSTUPDATE_OPS = [OP_NAME_FIRSTUPDATE, -1, -1, -1, + OpCodes.OP_2DROP, OpCodes.OP_2DROP] + NAME_UPDATE_OPS = [OP_NAME_UPDATE, -1, -1, OpCodes.OP_2DROP, + OpCodes.OP_DROP] + + name_script_op_count = None + name_pushdata = None + + # Detect name operations; determine count of opcodes. + # Also extract the name field -- we might use that for something in a + # future version. + if match(ops[:len(NAME_NEW_OPS)], NAME_NEW_OPS): + name_script_op_count = len(NAME_NEW_OPS) + elif match(ops[:len(NAME_FIRSTUPDATE_OPS)], NAME_FIRSTUPDATE_OPS): + name_script_op_count = len(NAME_FIRSTUPDATE_OPS) + name_pushdata = ops[1] + elif match(ops[:len(NAME_UPDATE_OPS)], NAME_UPDATE_OPS): + name_script_op_count = len(NAME_UPDATE_OPS) + name_pushdata = ops[1] + + if name_script_op_count is None: + return None, script + + # Find the end position of the name data + n = 0 + for i in range(name_script_op_count): + # Content of this loop is copied from Script.get_ops's loop + op = script[n] + n += 1 + + if op <= OpCodes.OP_PUSHDATA4: + # Raw bytes follow + if op < OpCodes.OP_PUSHDATA1: + dlen = op + elif op == OpCodes.OP_PUSHDATA1: + dlen = script[n] + n += 1 + elif op == OpCodes.OP_PUSHDATA2: + dlen, = struct.unpack(' len(script): + raise IndexError + op = (op, script[n:n + dlen]) + n += dlen + # Strip the name data to yield the address script + address_script = script[n:] + + if name_pushdata is None: + return None, address_script + + normalized_name_op_script = bytearray() + normalized_name_op_script.append(OP_NAME_UPDATE) + normalized_name_op_script.extend(Script.push_data(name_pushdata[1])) + normalized_name_op_script.extend(Script.push_data(bytes([]))) + normalized_name_op_script.append(OpCodes.OP_2DROP) + normalized_name_op_script.append(OpCodes.OP_DROP) + normalized_name_op_script.append(OpCodes.OP_RETURN) + + return bytes(normalized_name_op_script), address_script + + @classmethod + def hashX_from_script(cls, script): + name_op_script, address_script = cls.split_name_script(script) + + return super().hashX_from_script(address_script) + + @classmethod + def address_from_script(cls, script): + name_op_script, address_script = cls.split_name_script(script) + + return super().address_from_script(address_script) + + @classmethod + def name_hashX_from_script(cls, script): + name_op_script, address_script = cls.split_name_script(script) + + if name_op_script is None: + return None + + return super().hashX_from_script(name_op_script) + + +class NamecoinTestnet(Namecoin): + NAME = "Namecoin" + SHORTNAME = "XNM" + NET = "testnet" + P2PKH_VERBYTE = bytes.fromhex("6f") + P2SH_VERBYTES = [bytes.fromhex("c4")] + WIF_BYTE = bytes.fromhex("ef") + GENESIS_HASH = ('00000007199508e34a9ff81e6ec0c477' + 'a4cccff2a4767a8eee39c11db367b008') + + +class Dogecoin(AuxPowMixin, Coin): + NAME = "Dogecoin" + SHORTNAME = "DOGE" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("02facafd") + XPRV_VERBYTES = bytes.fromhex("02fac398") + P2PKH_VERBYTE = bytes.fromhex("1e") + P2SH_VERBYTES = [bytes.fromhex("16")] + WIF_BYTE = bytes.fromhex("9e") + GENESIS_HASH = ('1a91e3dace36e2be3bf030a65679fe82' + '1aa1d6ef92e7c9902eb318182c355691') + TX_COUNT = 27583427 + TX_COUNT_HEIGHT = 1604979 + TX_PER_BLOCK = 20 + REORG_LIMIT = 2000 + + +class DogecoinTestnet(Dogecoin): + NAME = "Dogecoin" + SHORTNAME = "XDT" + NET = "testnet" + P2PKH_VERBYTE = bytes.fromhex("71") + P2SH_VERBYTES = [bytes.fromhex("c4")] + WIF_BYTE = bytes.fromhex("f1") + GENESIS_HASH = ('bb0a78264637406b6360aad926284d54' + '4d7049f45189db5664f3c4d07350559e') + + +# Source: https://github.com/motioncrypto/motion +class Motion(Coin): + NAME = "Motion" + SHORTNAME = "XMN" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488B21E") + XPRV_VERBYTES = bytes.fromhex("0488ADE4") + GENESIS_HASH = ('000001e9dc60dd2618e91f7b90141349' + '22c374496b61c1a272519b1c39979d78') + P2PKH_VERBYTE = bytes.fromhex("32") + P2SH_VERBYTES = [bytes.fromhex("12")] + WIF_BYTE = bytes.fromhex("80") + TX_COUNT_HEIGHT = 54353 + TX_COUNT = 92701 + TX_PER_BLOCK = 4 + RPC_PORT = 3385 + SESSIONCLS = DashElectrumX + DAEMON = daemon.DashDaemon + + @classmethod + def header_hash(cls, header): + '''Given a header return the hash.''' + import x16r_hash + return x16r_hash.getPoWHash(header) + + +# Source: https://github.com/dashpay/dash +class Dash(Coin): + NAME = "Dash" + SHORTNAME = "DASH" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("02fe52cc") + XPRV_VERBYTES = bytes.fromhex("02fe52f8") + GENESIS_HASH = ('00000ffd590b1485b3caadc19b22e637' + '9c733355108f107a430458cdf3407ab6') + P2PKH_VERBYTE = bytes.fromhex("4c") + P2SH_VERBYTES = [bytes.fromhex("10")] + WIF_BYTE = bytes.fromhex("cc") + TX_COUNT_HEIGHT = 569399 + TX_COUNT = 2157510 + TX_PER_BLOCK = 4 + RPC_PORT = 9998 + PEERS = [ + 'electrum.dash.org s t', + 'electrum.masternode.io s t', + 'electrum-drk.club s t', + 'dashcrypto.space s t', + 'electrum.dash.siampm.com s t', + 'wl4sfwq2hwxnodof.onion s t', + ] + SESSIONCLS = DashElectrumX + DAEMON = daemon.DashDaemon + + @classmethod + def header_hash(cls, header): + '''Given a header return the hash.''' + import x11_hash + return x11_hash.getPoWHash(header) + + +class DashTestnet(Dash): + SHORTNAME = "tDASH" + NET = "testnet" + XPUB_VERBYTES = bytes.fromhex("3a805837") + XPRV_VERBYTES = bytes.fromhex("3a8061a0") + GENESIS_HASH = ('00000bafbc94add76cb75e2ec9289483' + '7288a481e5c005f6563d91623bf8bc2c') + P2PKH_VERBYTE = bytes.fromhex("8c") + P2SH_VERBYTES = [bytes.fromhex("13")] + WIF_BYTE = bytes.fromhex("ef") + TX_COUNT_HEIGHT = 101619 + TX_COUNT = 132681 + TX_PER_BLOCK = 1 + RPC_PORT = 19998 + PEER_DEFAULT_PORTS = {'t': '51001', 's': '51002'} + PEERS = [ + 'electrum.dash.siampm.com s t', + 'dasht.random.re s54002 t54001', + ] + + +class Argentum(AuxPowMixin, Coin): + NAME = "Argentum" + SHORTNAME = "ARG" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("17") + P2SH_VERBYTES = [bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("97") + GENESIS_HASH = ('88c667bc63167685e4e4da058fffdfe8' + 'e007e5abffd6855de52ad59df7bb0bb2') + TX_COUNT = 2263089 + TX_COUNT_HEIGHT = 2050260 + TX_PER_BLOCK = 2000 + RPC_PORT = 13581 + + +class ArgentumTestnet(Argentum): + SHORTNAME = "XRG" + NET = "testnet" + P2PKH_VERBYTE = bytes.fromhex("6f") + P2SH_VERBYTES = [bytes.fromhex("c4")] + WIF_BYTE = bytes.fromhex("ef") + REORG_LIMIT = 2000 + + +class DigiByte(Coin): + NAME = "DigiByte" + SHORTNAME = "DGB" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("1E") + P2SH_VERBYTES = [bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('7497ea1b465eb39f1c8f507bc877078f' + 'e016d6fcb6dfad3a64c98dcc6e1e8496') + DESERIALIZER = lib_tx.DeserializerSegWit + TX_COUNT = 1046018 + TX_COUNT_HEIGHT = 1435000 + TX_PER_BLOCK = 1000 + RPC_PORT = 12022 + + +class DigiByteTestnet(DigiByte): + NET = "testnet" + P2PKH_VERBYTE = bytes.fromhex("6f") + P2SH_VERBYTES = [bytes.fromhex("c4")] + WIF_BYTE = bytes.fromhex("ef") + GENESIS_HASH = ('b5dca8039e300198e5fe7cd23bdd1728' + 'e2a444af34c447dbd0916fa3430a68c2') + RPC_PORT = 15022 + REORG_LIMIT = 2000 + + +class FairCoin(Coin): + NAME = "FairCoin" + SHORTNAME = "FAIR" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("5f") + P2SH_VERBYTES = [bytes.fromhex("24")] + WIF_BYTE = bytes.fromhex("df") + GENESIS_HASH = ('beed44fa5e96150d95d56ebd5d262578' + '1825a9407a5215dd7eda723373a0a1d7') + BASIC_HEADER_SIZE = 108 + HEADER_VALUES = ['version', 'prev_block_hash', 'merkle_root', + 'payload_hash', 'timestamp', 'creatorId'] + HEADER_UNPACK = struct.Struct('< I 32s 32s 32s I I').unpack_from + TX_COUNT = 505 + TX_COUNT_HEIGHT = 470 + TX_PER_BLOCK = 1 + RPC_PORT = 40405 + PEER_DEFAULT_PORTS = {'t': '51811', 's': '51812'} + PEERS = [ + 'electrum.faircoin.world s', + 'electrumfair.punto0.org s', + ] + + @classmethod + def block(cls, raw_block, height): + '''Return a Block namedtuple given a raw block and its height.''' + if height > 0: + return super().block(raw_block, height) + else: + return Block(raw_block, cls.block_header(raw_block, height), []) + + @classmethod + def electrum_header(cls, header, height): + h = super().electrum_header(header, height) + h['payload_hash'] = hash_to_hex_str(h['payload_hash']) + return h + + +class Zcash(EquihashMixin, Coin): + NAME = "Zcash" + SHORTNAME = "ZEC" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("1CB8") + P2SH_VERBYTES = [bytes.fromhex("1CBD")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('00040fe8ec8471911baa1db1266ea15d' + 'd06b4a8a5c453883c000b031973dce08') + DESERIALIZER = lib_tx.DeserializerZcash + TX_COUNT = 329196 + TX_COUNT_HEIGHT = 68379 + TX_PER_BLOCK = 5 + RPC_PORT = 8232 + REORG_LIMIT = 800 + + +class ZcashTestnet(Zcash): + SHORTNAME = "TAZ" + NET = "testnet" + P2PKH_VERBYTE = bytes.fromhex("1D25") + P2SH_VERBYTES = [bytes.fromhex("1CBA")] + WIF_BYTE = bytes.fromhex("EF") + GENESIS_HASH = ('05a60a92d99d85997cce3b87616c089f' + '6124d7342af37106edc76126334a2c38') + TX_COUNT = 242312 + TX_COUNT_HEIGHT = 321685 + TX_PER_BLOCK = 2 + RPC_PORT = 18232 + + +class SnowGem(EquihashMixin, Coin): + NAME = "SnowGem" + SHORTNAME = "SNG" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("1C28") + P2SH_VERBYTES = [bytes.fromhex("1C2D")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('00068b35729d9d2b0c294ff1fe9af009' + '4740524311a131de40e7f705e4c29a5b') + DESERIALIZER = lib_tx.DeserializerZcash + TX_COUNT = 140698 + TX_COUNT_HEIGHT = 102802 + TX_PER_BLOCK = 2 + RPC_PORT = 16112 + REORG_LIMIT = 800 + CHUNK_SIZE = 200 + + @classmethod + def electrum_header(cls, header, height): + h = super().electrum_header(header, height) + h['n_solution'] = base64.b64encode(lib_tx.Deserializer( + header, start=140)._read_varbytes()).decode('utf8') + return h + + +class BitcoinZ(EquihashMixin, Coin): + NAME = "BitcoinZ" + SHORTNAME = "BTCZ" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("1CB8") + P2SH_VERBYTES = [bytes.fromhex("1CBD")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('f499ee3d498b4298ac6a64205b8addb7' + 'c43197e2a660229be65db8a4534d75c1') + DESERIALIZER = lib_tx.DeserializerZcash + TX_COUNT = 171976 + TX_COUNT_HEIGHT = 81323 + TX_PER_BLOCK = 3 + RPC_PORT = 1979 + REORG_LIMIT = 800 + + +class Hush(EquihashMixin, Coin): + NAME = "Hush" + SHORTNAME = "HUSH" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("1CB8") + P2SH_VERBYTES = [bytes.fromhex("1CBD")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('0003a67bc26fe564b75daf11186d3606' + '52eb435a35ba3d9d3e7e5d5f8e62dc17') + DESERIALIZER = lib_tx.DeserializerZcash + TX_COUNT = 329196 + TX_COUNT_HEIGHT = 68379 + TX_PER_BLOCK = 5 + RPC_PORT = 8822 + REORG_LIMIT = 800 + + +class Zclassic(EquihashMixin, Coin): + NAME = "Zclassic" + SHORTNAME = "ZCL" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("1CB8") + P2SH_VERBYTES = [bytes.fromhex("1CBD")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('0007104ccda289427919efc39dc9e4d4' + '99804b7bebc22df55f8b834301260602') + DESERIALIZER = lib_tx.DeserializerZcash + TX_COUNT = 329196 + TX_COUNT_HEIGHT = 68379 + TX_PER_BLOCK = 5 + RPC_PORT = 8023 + REORG_LIMIT = 800 + + +class Koto(Coin): + NAME = "Koto" + SHORTNAME = "KOTO" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("1836") + P2SH_VERBYTES = [bytes.fromhex("183B")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('6d424c350729ae633275d51dc3496e16' + 'cd1b1d195c164da00f39c499a2e9959e') + DESERIALIZER = lib_tx.DeserializerZcash + TX_COUNT = 158914 + TX_COUNT_HEIGHT = 67574 + TX_PER_BLOCK = 3 + RPC_PORT = 8432 + REORG_LIMIT = 800 + PEERS = [ + 'fr.kotocoin.info s t', + 'electrum.kotocoin.info s t', + ] + + +class KotoTestnet(Koto): + SHORTNAME = "TOKO" + NET = "testnet" + P2PKH_VERBYTE = bytes.fromhex("18A4") + P2SH_VERBYTES = [bytes.fromhex("1839")] + WIF_BYTE = bytes.fromhex("EF") + GENESIS_HASH = ('bf84afbde20c2d213b68b231ddb585ab' + '616ef7567226820f00d9b397d774d2f0') + TX_COUNT = 91144 + TX_COUNT_HEIGHT = 89662 + TX_PER_BLOCK = 1 + RPC_PORT = 18432 + PEER_DEFAULT_PORTS = {'t': '51001', 's': '51002'} + PEERS = [ + 'testnet.kotocoin.info s t', + ] + + +class Komodo(KomodoMixin, EquihashMixin, Coin): + NAME = "Komodo" + SHORTNAME = "KMD" + NET = "mainnet" + TX_COUNT = 693629 + TX_COUNT_HEIGHT = 491777 + TX_PER_BLOCK = 2 + RPC_PORT = 7771 + REORG_LIMIT = 800 + PEERS: List[str] = [] + + +class Monaize(KomodoMixin, EquihashMixin, Coin): + NAME = "Monaize" + SHORTNAME = "MNZ" + NET = "mainnet" + TX_COUNT = 256 + TX_COUNT_HEIGHT = 128 + TX_PER_BLOCK = 2 + RPC_PORT = 14337 + REORG_LIMIT = 800 + PEERS: List[str] = [] + + +class Einsteinium(Coin): + NAME = "Einsteinium" + SHORTNAME = "EMC2" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("21") + P2SH_VERBYTES = [bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("b0") + GENESIS_HASH = ('4e56204bb7b8ac06f860ff1c845f03f9' + '84303b5b97eb7b42868f714611aed94b') + DESERIALIZER = lib_tx.DeserializerSegWit + TX_COUNT = 2087559 + TX_COUNT_HEIGHT = 1358517 + TX_PER_BLOCK = 2 + RPC_PORT = 41879 + REORG_LIMIT = 2000 + + +class Blackcoin(ScryptMixin, Coin): + NAME = "Blackcoin" + SHORTNAME = "BLK" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("19") + P2SH_VERBYTES = [bytes.fromhex("55")] + WIF_BYTE = bytes.fromhex("99") + GENESIS_HASH = ('000001faef25dec4fbcf906e6242621d' + 'f2c183bf232f263d0ba5b101911e4563') + DAEMON = daemon.LegacyRPCDaemon + TX_COUNT = 4594999 + TX_COUNT_HEIGHT = 1667070 + TX_PER_BLOCK = 3 + RPC_PORT = 15715 + REORG_LIMIT = 5000 + + +class Bitbay(ScryptMixin, Coin): + NAME = "Bitbay" + SHORTNAME = "BAY" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("19") + P2SH_VERBYTES = [bytes.fromhex("55")] + WIF_BYTE = bytes.fromhex("99") + GENESIS_HASH = ('0000075685d3be1f253ce777174b1594' + '354e79954d2a32a6f77fe9cba00e6467') + TX_COUNT = 4594999 + TX_COUNT_HEIGHT = 1667070 + TX_PER_BLOCK = 3 + RPC_PORT = 19914 + REORG_LIMIT = 5000 + + +class Peercoin(Coin): + NAME = "Peercoin" + SHORTNAME = "PPC" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("37") + P2SH_VERBYTES = [bytes.fromhex("75")] + WIF_BYTE = bytes.fromhex("b7") + GENESIS_HASH = ('0000000032fe677166d54963b62a4677' + 'd8957e87c508eaa4fd7eb1c880cd27e3') + DESERIALIZER = lib_tx.DeserializerTxTime + DAEMON = daemon.LegacyRPCDaemon + TX_COUNT = 1207356 + TX_COUNT_HEIGHT = 306425 + TX_PER_BLOCK = 4 + RPC_PORT = 9902 + REORG_LIMIT = 5000 + + +class Reddcoin(Coin): + NAME = "Reddcoin" + SHORTNAME = "RDD" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("3d") + P2SH_VERBYTES = [bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("bd") + GENESIS_HASH = ('b868e0d95a3c3c0e0dadc67ee587aaf9' + 'dc8acbf99e3b4b3110fad4eb74c1decc') + DESERIALIZER = lib_tx.DeserializerReddcoin + TX_COUNT = 5413508 + TX_COUNT_HEIGHT = 1717382 + TX_PER_BLOCK = 3 + RPC_PORT = 45443 + + +class TokenPay(ScryptMixin, Coin): + NAME = "TokenPay" + SHORTNAME = "TPAY" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("41") + P2SH_VERBYTES = [bytes.fromhex("7e")] + WIF_BYTE = bytes.fromhex("b3") + GENESIS_HASH = ('000008b71ab32e585a23f0de642dc113' + '740144e94c0ece047751e9781f953ae9') + DESERIALIZER = lib_tx.DeserializerTokenPay + DAEMON = daemon.LegacyRPCDaemon + TX_COUNT = 147934 + TX_COUNT_HEIGHT = 73967 + TX_PER_BLOCK = 100 + RPC_PORT = 8800 + REORG_LIMIT = 500 + XPUB_VERBYTES = bytes.fromhex("0488B21E") + XPRV_VERBYTES = bytes.fromhex("0488ADE4") + + PEERS = [ + "electrum-us.tpay.ai s", + "electrum-eu.tpay.ai s", + ] + + +class Vertcoin(Coin): + NAME = "Vertcoin" + SHORTNAME = "VTC" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488B21E") + XPRV_VERBYTES = bytes.fromhex("0488ADE4") + P2PKH_VERBYTE = bytes.fromhex("47") + P2SH_VERBYTES = [bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('4d96a915f49d40b1e5c2844d1ee2dccb' + '90013a990ccea12c492d22110489f0c4') + DESERIALIZER = lib_tx.DeserializerSegWit + TX_COUNT = 2383423 + TX_COUNT_HEIGHT = 759076 + TX_PER_BLOCK = 3 + RPC_PORT = 5888 + REORG_LIMIT = 1000 + + +class Monacoin(Coin): + NAME = "Monacoin" + SHORTNAME = "MONA" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488B21E") + XPRV_VERBYTES = bytes.fromhex("0488ADE4") + P2PKH_VERBYTE = bytes.fromhex("32") + P2SH_VERBYTES = [bytes.fromhex("37"), bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("B0") + GENESIS_HASH = ('ff9f1c0116d19de7c9963845e129f9ed' + '1bfc0b376eb54fd7afa42e0d418c8bb6') + DESERIALIZER = lib_tx.DeserializerSegWit + TX_COUNT = 2568580 + TX_COUNT_HEIGHT = 1029766 + TX_PER_BLOCK = 2 + RPC_PORT = 9402 + REORG_LIMIT = 1000 + PEERS = [ + 'electrumx.tamami-foundation.org s t', + 'electrumx2.tamami-foundation.org s t', + 'electrumx3.tamami-foundation.org s t', + 'electrumx1.monacoin.nl s t', + 'electrumx2.monacoin.nl s t', + 'electrumx1.monacoin.ninja s t', + 'electrumx2.monacoin.ninja s t', + 'electrumx2.movsign.info s t', + 'electrum-mona.bitbank.cc s t', + 'ri7rzlmdaf4eqbza.onion s t', + ] + + +class MonacoinTestnet(Monacoin): + SHORTNAME = "XMN" + NET = "testnet" + XPUB_VERBYTES = bytes.fromhex("043587CF") + XPRV_VERBYTES = bytes.fromhex("04358394") + P2PKH_VERBYTE = bytes.fromhex("6F") + P2SH_VERBYTES = [bytes.fromhex("75"), bytes.fromhex("C4")] + WIF_BYTE = bytes.fromhex("EF") + GENESIS_HASH = ('a2b106ceba3be0c6d097b2a6a6aacf9d' + '638ba8258ae478158f449c321061e0b2') + TX_COUNT = 83602 + TX_COUNT_HEIGHT = 83252 + TX_PER_BLOCK = 1 + RPC_PORT = 19402 + REORG_LIMIT = 1000 + PEER_DEFAULT_PORTS = {'t': '51001', 's': '51002'} + PEERS = [ + 'electrumx1.testnet.monacoin.ninja s t', + 'electrumx1.testnet.monacoin.nl s t', + ] + + +class Crown(AuxPowMixin, Coin): + NAME = "Crown" + SHORTNAME = "CRW" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + P2PKH_VERBYTE = bytes.fromhex("00") + P2SH_VERBYTES = [bytes.fromhex("1c")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('0000000085370d5e122f64f4ab19c686' + '14ff3df78c8d13cb814fd7e69a1dc6da') + TX_COUNT = 13336629 + TX_COUNT_HEIGHT = 1268206 + TX_PER_BLOCK = 10 + RPC_PORT = 9341 + REORG_LIMIT = 1000 + PEERS = [ + 'sgp-crwseed.crowndns.info s t', + 'blr-crwseed.crowndns.info s t', + 'sfo-crwseed.crowndns.info s t', + 'nyc-crwseed.crowndns.info s t', + 'ams-crwseed.crowndns.info s t', + 'tor-crwseed.crowndns.info s t', + 'lon-crwseed.crowndns.info s t', + 'fra-crwseed.crowndns.info s t', + ] + + +class Fujicoin(Coin): + NAME = "Fujicoin" + SHORTNAME = "FJC" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + P2PKH_VERBYTE = bytes.fromhex("24") + P2SH_VERBYTES = [bytes.fromhex("10")] + WIF_BYTE = bytes.fromhex("a4") + GENESIS_HASH = ('adb6d9cfd74075e7f91608add4bd2a2e' + 'a636f70856183086842667a1597714a0') + DESERIALIZER = lib_tx.DeserializerSegWit + TX_COUNT = 170478 + TX_COUNT_HEIGHT = 1521676 + TX_PER_BLOCK = 1 + RPC_PORT = 3776 + REORG_LIMIT = 1000 + + +class Neblio(ScryptMixin, Coin): + NAME = "Neblio" + SHORTNAME = "NEBL" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + P2PKH_VERBYTE = bytes.fromhex("35") + P2SH_VERBYTES = [bytes.fromhex("70")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('7286972be4dbc1463d256049b7471c25' + '2e6557e222cab9be73181d359cd28bcc') + TX_COUNT = 23675 + TX_COUNT_HEIGHT = 22785 + TX_PER_BLOCK = 1 + RPC_PORT = 6326 + REORG_LIMIT = 1000 + + +class Bitzeny(Coin): + NAME = "Bitzeny" + SHORTNAME = "ZNY" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + P2PKH_VERBYTE = bytes.fromhex("51") + P2SH_VERBYTES = [bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('000009f7e55e9e3b4781e22bd87a7cfa' + '4acada9e4340d43ca738bf4e9fb8f5ce') + ESTIMATE_FEE = 0.001 + RELAY_FEE = 0.001 + DAEMON = daemon.FakeEstimateFeeDaemon + TX_COUNT = 1408733 + TX_COUNT_HEIGHT = 1015115 + TX_PER_BLOCK = 1 + RPC_PORT = 9252 + REORG_LIMIT = 1000 + + @classmethod + def header_hash(cls, header): + '''Given a header return the hash.''' + import zny_yescrypt + return zny_yescrypt.getPoWHash(header) + + +class CanadaeCoin(AuxPowMixin, Coin): + NAME = "CanadaeCoin" + SHORTNAME = "CDN" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + P2PKH_VERBYTE = bytes.fromhex("1C") + P2SH_VERBYTES = [bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("9c") + GENESIS_HASH = ('863626dadaef221e2e2f30ff3dacae44' + 'cabdae9e0028058072181b3fb675d94a') + ESTIMATE_FEE = 0.0001 + RELAY_FEE = 0.0001 + DAEMON = daemon.FakeEstimateFeeDaemon + TX_COUNT = 3455905 + TX_COUNT_HEIGHT = 3645419 + TX_PER_BLOCK = 1 + RPC_PORT = 34330 + REORG_LIMIT = 1000 + + +class Denarius(Coin): + NAME = "Denarius" + SHORTNAME = "DNR" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + P2PKH_VERBYTE = bytes.fromhex("1E") # Address starts with a D + P2SH_VERBYTES = [bytes.fromhex("5A")] + WIF_BYTE = bytes.fromhex("9E") # WIF starts with a 6 + GENESIS_HASH = ('00000d5dbbda01621cfc16bbc1f9bf32' + '64d641a5dbf0de89fd0182c2c4828fcd') + DESERIALIZER = lib_tx.DeserializerTxTime + TX_COUNT = 4230 + RPC_PORT = 32339 + ESTIMATE_FEE = 0.00001 + RELAY_FEE = 0.00001 + DAEMON = daemon.FakeEstimateFeeDaemon + TX_COUNT_HEIGHT = 306187 + TX_PER_BLOCK = 4000 + + @classmethod + def header_hash(cls, header): + '''Given a header return the hash.''' + import tribus_hash + return tribus_hash.getPoWHash(header) + + +class DenariusTestnet(Denarius): + NET = "testnet" + XPUB_VERBYTES = bytes.fromhex("043587cf") + XPRV_VERBYTES = bytes.fromhex("04358394") + P2PKH_VERBYTE = bytes.fromhex("12") + P2SH_VERBYTES = [bytes.fromhex("74")] + WIF_BYTE = bytes.fromhex("ef") + GENESIS_HASH = ('000086bfe8264d241f7f8e5393f74778' + '4b8ca2aa98bdd066278d590462a4fdb4') + RPC_PORT = 32338 + REORG_LIMIT = 2000 + + +class Sibcoin(Dash): + NAME = "Sibcoin" + SHORTNAME = "SIB" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + P2PKH_VERBYTE = bytes.fromhex("3F") + P2SH_VERBYTES = [bytes.fromhex("28")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('00000c492bf73490420868bc577680bf' + 'c4c60116e7e85343bc624787c21efa4c') + DAEMON = daemon.DashDaemon + TX_COUNT = 1000 + TX_COUNT_HEIGHT = 10000 + TX_PER_BLOCK = 1 + RPC_PORT = 1944 + REORG_LIMIT = 1000 + PEERS: List[str] = [] + + @classmethod + def header_hash(cls, header): + ''' + Given a header return the hash for sibcoin. + Need to download `x11_gost_hash` module + Source code: https://github.com/ivansib/x11_gost_hash + ''' + import x11_gost_hash + return x11_gost_hash.getPoWHash(header) + + +class Chips(Coin): + NAME = "Chips" + SHORTNAME = "CHIPS" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("3c") + P2SH_VERBYTES = [bytes.fromhex("55")] + WIF_BYTE = bytes.fromhex("bc") + GENESIS_HASH = ('0000006e75f6aa0efdbf7db03132aa4e' + '4d0c84951537a6f5a7c39a0a9d30e1e7') + DESERIALIZER = lib_tx.DeserializerSegWit + TX_COUNT = 145290 + TX_COUNT_HEIGHT = 318637 + TX_PER_BLOCK = 2 + RPC_PORT = 57776 + REORG_LIMIT = 800 + + +class Feathercoin(Coin): + NAME = "Feathercoin" + SHORTNAME = "FTC" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488BC26") + XPRV_VERBYTES = bytes.fromhex("0488DAEE") + P2PKH_VERBYTE = bytes.fromhex("0E") + P2SH_VERBYTES = [bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("8E") + GENESIS_HASH = ('12a765e31ffd4059bada1e25190f6e98' + 'c99d9714d334efa41a195a7e7e04bfe2') + DESERIALIZER = lib_tx.DeserializerSegWit + TX_COUNT = 3170843 + TX_COUNT_HEIGHT = 1981777 + TX_PER_BLOCK = 2 + RPC_PORT = 9337 + REORG_LIMIT = 2000 + PEERS = [ + 'electrumx-ch-1.feathercoin.ch s t', + ] + + +class UFO(Coin): + NAME = "UniformFiscalObject" + SHORTNAME = "UFO" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488B21E") + XPRV_VERBYTES = bytes.fromhex("0488ADE4") + P2PKH_VERBYTE = bytes.fromhex("1B") + P2SH_VERBYTES = [bytes.fromhex("44")] + WIF_BYTE = bytes.fromhex("9B") + GENESIS_HASH = ('ba1d39b4928ab03d813d952daf65fb77' + '97fcf538a9c1b8274f4edc8557722d13') + DESERIALIZER = lib_tx.DeserializerSegWit + TX_COUNT = 1608926 + TX_COUNT_HEIGHT = 1300154 + TX_PER_BLOCK = 2 + RPC_PORT = 9888 + REORG_LIMIT = 2000 + PEERS = [ + 'electrumx1.ufobject.com s t', + ] + + +class Newyorkcoin(AuxPowMixin, Coin): + NAME = "Newyorkcoin" + SHORTNAME = "NYC" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("3c") + P2SH_VERBYTES = [bytes.fromhex("16")] + WIF_BYTE = bytes.fromhex("bc") + GENESIS_HASH = ('5597f25c062a3038c7fd815fe46c67de' + 'dfcb3c839fbc8e01ed4044540d08fe48') + TX_COUNT = 5161944 + TX_COUNT_HEIGHT = 3948743 + TX_PER_BLOCK = 2 + REORG_LIMIT = 2000 + + +class NewyorkcoinTestnet(Newyorkcoin): + SHORTNAME = "tNYC" + NET = "testnet" + P2PKH_VERBYTE = bytes.fromhex("71") + P2SH_VERBYTES = [bytes.fromhex("c4")] + WIF_BYTE = bytes.fromhex("f1") + GENESIS_HASH = ('24463e4d3c625b0a9059f309044c2cf0' + 'd7e196cf2a6ecce901f24f681be33c8f') + TX_COUNT = 5161944 + TX_COUNT_HEIGHT = 3948743 + TX_PER_BLOCK = 2 + REORG_LIMIT = 2000 + + +class Bitcore(BitcoinMixin, Coin): + NAME = "Bitcore" + SHORTNAME = "BTX" + P2PKH_VERBYTE = bytes.fromhex("03") + P2SH_VERBYTES = [bytes.fromhex("7D")] + WIF_BYTE = bytes.fromhex("80") + DESERIALIZER = lib_tx.DeserializerSegWit + GENESIS_HASH = ('604148281e5c4b7f2487e5d03cd60d8e' + '6f69411d613f6448034508cea52e9574') + TX_COUNT = 126979 + TX_COUNT_HEIGHT = 126946 + TX_PER_BLOCK = 2 + RPC_PORT = 8556 + + +class GameCredits(Coin): + NAME = "GameCredits" + SHORTNAME = "GAME" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("26") + P2SH_VERBYTES = [bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("a6") + GENESIS_HASH = ('91ec5f25ee9a0ffa1af7d4da4db9a552' + '228dd2dc77cdb15b738be4e1f55f30ee') + DESERIALIZER = lib_tx.DeserializerSegWit + TX_COUNT = 316796 + TX_COUNT_HEIGHT = 2040250 + TX_PER_BLOCK = 2 + RPC_PORT = 40001 + REORG_LIMIT = 1000 + + +class Machinecoin(Coin): + NAME = "Machinecoin" + SHORTNAME = "MAC" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + P2PKH_VERBYTE = bytes.fromhex("32") + P2SH_VERBYTES = [bytes.fromhex("26"), bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("b2") + GENESIS_HASH = ('6a1f879bcea5471cbfdee1fd0cb2ddcc' + '4fed569a500e352d41de967703e83172') + DESERIALIZER = lib_tx.DeserializerSegWit + TX_COUNT = 137641 + TX_COUNT_HEIGHT = 513020 + TX_PER_BLOCK = 2 + RPC_PORT = 40332 + REORG_LIMIT = 800 + + +class BitcoinAtom(Coin): + NAME = "BitcoinAtom" + SHORTNAME = "BCA" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("17") + P2SH_VERBYTES = [bytes.fromhex("0a")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('000000000019d6689c085ae165831e93' + '4ff763ae46a2a6c172b3f1b60a8ce26f') + STATIC_BLOCK_HEADERS = False + DESERIALIZER = lib_tx.DeserializerBitcoinAtom + HEADER_SIZE_POST_FORK = 84 + BLOCK_PROOF_OF_STAKE = 0x01 + BLOCK_PROOF_OF_STAKE_FLAGS = b'\x01\x00\x00\x00' + TX_COUNT = 295158744 + TX_COUNT_HEIGHT = 589197 + TX_PER_BLOCK = 10 + RPC_PORT = 9136 + REORG_LIMIT = 5000 + + @classmethod + def header_hash(cls, header): + '''Given a header return hash''' + header_to_be_hashed = header[:cls.BASIC_HEADER_SIZE] + # New block header format has some extra flags in the end + if len(header) == cls.HEADER_SIZE_POST_FORK: + flags, = util.unpack_le_uint32_from(header, len(header) - 4) + # Proof of work blocks have special serialization + if flags & cls.BLOCK_PROOF_OF_STAKE != 0: + header_to_be_hashed += cls.BLOCK_PROOF_OF_STAKE_FLAGS + + return double_sha256(header_to_be_hashed) + + @classmethod + def block_header(cls, block, height): + '''Return the block header bytes''' + deserializer = cls.DESERIALIZER(block) + return deserializer.read_header(height, cls.BASIC_HEADER_SIZE) + + +class Decred(Coin): + NAME = "Decred" + SHORTNAME = "DCR" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("02fda926") + XPRV_VERBYTES = bytes.fromhex("02fda4e8") + P2PKH_VERBYTE = bytes.fromhex("073f") + P2SH_VERBYTES = [bytes.fromhex("071a")] + WIF_BYTE = bytes.fromhex("22de") + GENESIS_HASH = ('298e5cc3d985bfe7f81dc135f360abe0' + '89edd4396b86d2de66b0cef42b21d980') + BASIC_HEADER_SIZE = 180 + HEADER_HASH = lib_tx.DeserializerDecred.blake256 + DESERIALIZER = lib_tx.DeserializerDecred + DAEMON = daemon.DecredDaemon + BLOCK_PROCESSOR = block_proc.DecredBlockProcessor + ENCODE_CHECK = partial(Base58.encode_check, + hash_fn=lib_tx.DeserializerDecred.blake256d) + DECODE_CHECK = partial(Base58.decode_check, + hash_fn=lib_tx.DeserializerDecred.blake256d) + HEADER_VALUES = ['version', 'prev_block_hash', 'merkle_root', 'stake_root', + 'vote_bits', 'final_state', 'voters', 'fresh_stake', + 'revocations', 'pool_size', 'bits', 'sbits', + 'block_height', 'size', 'timestamp', 'nonce', + 'extra_data', 'stake_version'] + HEADER_UNPACK = struct.Struct( + '< i 32s 32s 32s H 6s H B B I I Q I I I I 32s I').unpack_from + TX_COUNT = 4629388 + TX_COUNT_HEIGHT = 260628 + TX_PER_BLOCK = 17 + REORG_LIMIT = 1000 + RPC_PORT = 9109 + + @classmethod + def header_hash(cls, header): + '''Given a header return the hash.''' + return cls.HEADER_HASH(header) + + @classmethod + def block(cls, raw_block, height): + '''Return a Block namedtuple given a raw block and its height.''' + if height > 0: + return super().block(raw_block, height) + else: + return Block(raw_block, cls.block_header(raw_block, height), []) + + @classmethod + def electrum_header(cls, header, height): + h = super().electrum_header(header, height) + h['stake_root'] = hash_to_hex_str(h['stake_root']) + h['final_state'] = hash_to_hex_str(h['final_state']) + h['extra_data'] = hash_to_hex_str(h['extra_data']) + return h + + +class DecredTestnet(Decred): + SHORTNAME = "tDCR" + NET = "testnet" + XPUB_VERBYTES = bytes.fromhex("043587d1") + XPRV_VERBYTES = bytes.fromhex("04358397") + P2PKH_VERBYTE = bytes.fromhex("0f21") + P2SH_VERBYTES = [bytes.fromhex("0efc")] + WIF_BYTE = bytes.fromhex("230e") + GENESIS_HASH = ( + 'a649dce53918caf422e9c711c858837e08d626ecfcd198969b24f7b634a49bac') + BASIC_HEADER_SIZE = 180 + ALLOW_ADVANCING_ERRORS = True + TX_COUNT = 217380620 + TX_COUNT_HEIGHT = 464000 + TX_PER_BLOCK = 1800 + REORG_LIMIT = 1000 + RPC_PORT = 19109 + + +class Axe(Dash): + NAME = "Axe" + SHORTNAME = "AXE" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("02fe52cc") + XPRV_VERBYTES = bytes.fromhex("02fe52f8") + P2PKH_VERBYTE = bytes.fromhex("37") + P2SH_VERBYTES = [bytes.fromhex("10")] + WIF_BYTE = bytes.fromhex("cc") + GENESIS_HASH = ('00000c33631ca6f2f61368991ce2dc03' + '306b5bb50bf7cede5cfbba6db38e52e6') + DAEMON = daemon.DashDaemon + TX_COUNT = 18405 + TX_COUNT_HEIGHT = 30237 + TX_PER_BLOCK = 1 + RPC_PORT = 9337 + REORG_LIMIT = 1000 + PEERS: List[str] = [] + + @classmethod + def header_hash(cls, header): + ''' + Given a header return the hash for AXE. + Need to download `axe_hash` module + Source code: https://github.com/AXErunners/axe_hash + ''' + import x11_hash + return x11_hash.getPoWHash(header) + + +class Xuez(Coin): + NAME = "Xuez" + SHORTNAME = "XUEZ" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("022d2533") + XPRV_VERBYTES = bytes.fromhex("0221312b") + P2PKH_VERBYTE = bytes.fromhex("48") + P2SH_VERBYTES = [bytes.fromhex("12")] + WIF_BYTE = bytes.fromhex("d4") + GENESIS_HASH = ('000000e1febc39965b055e8e0117179a' + '4d18e24e7aaa0c69864c4054b4f29445') + TX_COUNT = 30000 + TX_COUNT_HEIGHT = 15000 + TX_PER_BLOCK = 1 + RPC_PORT = 41799 + REORG_LIMIT = 1000 + BASIC_HEADER_SIZE = 112 + PEERS: List[str] = [] + + @classmethod + def header_hash(cls, header): + ''' + Given a header return the hash for Xuez. + Need to download `xevan_hash` module + Source code: https://github.com/xuez/xuez + ''' + version, = util.unpack_le_uint32_from(header) + + import xevan_hash + + if version == 1: + return xevan_hash.getPoWHash(header[:80]) + else: + return xevan_hash.getPoWHash(header) + + @classmethod + def electrum_header(cls, header, height): + h = super().electrum_header(header, height) + if h['version'] > 1: + h['nAccumulatorCheckpoint'] = hash_to_hex_str(header[80:]) + return h + + +class Pac(Coin): + NAME = "PAC" + SHORTNAME = "PAC" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488B21E") + XPRV_VERBYTES = bytes.fromhex("0488ADE4") + GENESIS_HASH = ('00000354655ff039a51273fe61d3b493' + 'bd2897fe6c16f732dbc4ae19f04b789e') + P2PKH_VERBYTE = bytes.fromhex("37") + P2SH_VERBYTES = [bytes.fromhex("0A")] + WIF_BYTE = bytes.fromhex("CC") + TX_COUNT_HEIGHT = 14939 + TX_COUNT = 23708 + TX_PER_BLOCK = 2 + RPC_PORT = 7111 + PEERS = [ + 'electrum.paccoin.io s t', + 'electro-pac.paccoin.io s t' + ] + SESSIONCLS = DashElectrumX + DAEMON = daemon.DashDaemon + ESTIMATE_FEE = 0.00001 + RELAY_FEE = 0.00001 + + @classmethod + def header_hash(cls, header): + '''Given a header return the hash.''' + import x11_hash + return x11_hash.getPoWHash(header) + + +class PacTestnet(Pac): + SHORTNAME = "tPAC" + NET = "testnet" + XPUB_VERBYTES = bytes.fromhex("043587CF") + XPRV_VERBYTES = bytes.fromhex("04358394") + GENESIS_HASH = ('00000da63bd9478b655ef6bf1bf76cd9' + 'af05202ab68643f9091e049b2b5280ed') + P2PKH_VERBYTE = bytes.fromhex("78") + P2SH_VERBYTES = [bytes.fromhex("0E")] + WIF_BYTE = bytes.fromhex("EF") + TX_COUNT_HEIGHT = 16275 + TX_COUNT = 16275 + TX_PER_BLOCK = 1 + RPC_PORT = 17111 + + +class Polis(Coin): + NAME = "Polis" + SHORTNAME = "POLIS" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("03E25D7E") + XPRV_VERBYTES = bytes.fromhex("03E25945") + GENESIS_HASH = ('000009701eb781a8113b1af1d814e2f0' + '60f6408a2c990db291bc5108a1345c1e') + P2PKH_VERBYTE = bytes.fromhex("37") + P2SH_VERBYTES = [bytes.fromhex("38")] + WIF_BYTE = bytes.fromhex("3c") + TX_COUNT_HEIGHT = 111111 + TX_COUNT = 256128 + TX_PER_BLOCK = 4 + RPC_PORT = 24127 + PEERS = [ + 'electrum1-polis.polispay.org', + 'electrum2-polis.polispay.org' + ] + SESSIONCLS = DashElectrumX + DAEMON = daemon.DashDaemon + + @classmethod + def header_hash(cls, header): + '''Given a header return the hash.''' + import x11_hash + return x11_hash.getPoWHash(header) + + +class ColossusXT(Coin): + NAME = "ColossusXT" + SHORTNAME = "COLX" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("022D2533") + XPRV_VERBYTES = bytes.fromhex("0221312B") + GENESIS_HASH = ('a0ce8206c908357008c1b9a8ba2813af' + 'f0989ca7f72d62b14e652c55f02b4f5c') + P2PKH_VERBYTE = bytes.fromhex("1E") + P2SH_VERBYTES = [bytes.fromhex("0D")] + WIF_BYTE = bytes.fromhex("D4") + TX_COUNT_HEIGHT = 356500 + TX_COUNT = 761041 + TX_PER_BLOCK = 4 + RPC_PORT = 51473 + PEERS = [ + 'electrum1-colx.polispay.org', + 'electrum2-colx.polispay.org' + ] + SESSIONCLS = DashElectrumX + DAEMON = daemon.DashDaemon + + @classmethod + def header_hash(cls, header): + '''Given a header return the hash.''' + import quark_hash + return quark_hash.getPoWHash(header) + + +class GoByte(Coin): + NAME = "GoByte" + SHORTNAME = "GBX" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488B21E") + XPRV_VERBYTES = bytes.fromhex("0488ADE4") + GENESIS_HASH = ('0000033b01055cf8df90b01a14734cae' + '92f7039b9b0e48887b4e33a469d7bc07') + P2PKH_VERBYTE = bytes.fromhex("26") + P2SH_VERBYTES = [bytes.fromhex("0A")] + WIF_BYTE = bytes.fromhex("C6") + TX_COUNT_HEIGHT = 115890 + TX_COUNT = 245030 + TX_PER_BLOCK = 4 + RPC_PORT = 12454 + PEERS = [ + 'electrum1-gbx.polispay.org', + 'electrum2-gbx.polispay.org' + ] + SESSIONCLS = DashElectrumX + DAEMON = daemon.DashDaemon + + @classmethod + def header_hash(cls, header): + '''Given a header return the hash.''' + import neoscrypt + return neoscrypt.getPoWHash(header) + + +class Monoeci(Coin): + NAME = "Monoeci" + SHORTNAME = "XMCC" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488B21E") + XPRV_VERBYTES = bytes.fromhex("0488ADE4") + GENESIS_HASH = ('0000005be1eb05b05fb45ae38ee9c144' + '1514a65343cd146100a574de4278f1a3') + P2PKH_VERBYTE = bytes.fromhex("32") + P2SH_VERBYTES = [bytes.fromhex("49")] + WIF_BYTE = bytes.fromhex("4D") + TX_COUNT_HEIGHT = 140000 + TX_COUNT = 140000 + TX_PER_BLOCK = 4 + RPC_PORT = 24156 + PEERS = [ + 'electrum1-gbx.polispay.org', + 'electrum2-gbx.polispay.org' + ] + SESSIONCLS = DashElectrumX + DAEMON = daemon.DashDaemon + + @classmethod + def header_hash(cls, header): + '''Given a header return the hash.''' + import x11_hash + return x11_hash.getPoWHash(header) + + +class Minexcoin(EquihashMixin, Coin): + NAME = "Minexcoin" + SHORTNAME = "MNX" + NET = "mainnet" + P2PKH_VERBYTE = bytes.fromhex("4b") + P2SH_VERBYTES = [bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('490a36d9451a55ed197e34aca7414b35' + 'd775baa4a8e896f1c577f65ce2d214cb') + STATIC_BLOCK_HEADERS = True + BASIC_HEADER_SIZE = 209 + HEADER_SIZE_NO_SOLUTION = 140 + TX_COUNT = 327963 + TX_COUNT_HEIGHT = 74495 + TX_PER_BLOCK = 5 + RPC_PORT = 8022 + CHUNK_SIZE = 960 + PEERS = [ + 'elex01-ams.turinex.eu s t', + 'eu.minexpool.nl s t' + ] + + @classmethod + def electrum_header(cls, header, height): + h = super().electrum_header(header, height) + h['solution'] = hash_to_hex_str(header[cls.HEADER_SIZE_NO_SOLUTION:]) + return h + + @classmethod + def block_header(cls, block, height): + '''Return the block header bytes''' + deserializer = cls.DESERIALIZER(block) + return deserializer.read_header(height, cls.HEADER_SIZE_NO_SOLUTION) + + +class Groestlcoin(Coin): + NAME = "Groestlcoin" + SHORTNAME = "GRS" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + P2PKH_VERBYTE = bytes.fromhex("24") + P2SH_VERBYTES = [bytes.fromhex("05")] + WIF_BYTE = bytes.fromhex("80") + GENESIS_HASH = ('00000ac5927c594d49cc0bdb81759d0d' + 'a8297eb614683d3acb62f0703b639023') + DESERIALIZER = lib_tx.DeserializerGroestlcoin + TX_COUNT = 115900 + TX_COUNT_HEIGHT = 1601528 + TX_PER_BLOCK = 5 + RPC_PORT = 1441 + PEERS = [ + 'electrum1.groestlcoin.org s t', + 'electrum2.groestlcoin.org s t', + '6brsrbiinpc32tfc.onion t', + 'xkj42efxrcy6vbfw.onion t', + ] + + def grshash(data): + import groestlcoin_hash + return groestlcoin_hash.getHash(data, len(data)) + + @classmethod + def header_hash(cls, header): + '''Given a header return the hash.''' + return cls.grshash(header) + + ENCODE_CHECK = partial(Base58.encode_check, hash_fn=grshash) + DECODE_CHECK = partial(Base58.decode_check, hash_fn=grshash) + + +class GroestlcoinTestnet(Groestlcoin): + SHORTNAME = "TGRS" + NET = "testnet" + XPUB_VERBYTES = bytes.fromhex("043587cf") + XPRV_VERBYTES = bytes.fromhex("04358394") + P2PKH_VERBYTE = bytes.fromhex("6f") + P2SH_VERBYTES = [bytes.fromhex("c4")] + WIF_BYTE = bytes.fromhex("ef") + GENESIS_HASH = ('000000ffbb50fc9898cdd36ec163e6ba' + '23230164c0052a28876255b7dcf2cd36') + RPC_PORT = 17766 + PEERS = [ + 'electrum-test1.groestlcoin.org s t', + 'electrum-test2.groestlcoin.org s t', + '7frvhgofuf522b5i.onion t', + 'aocojvqcybdoxekv.onion t', + ] + + +class Pivx(Coin): + NAME = "Pivx" + SHORTNAME = "PIVX" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("022D2533") + XPRV_VERBYTES = bytes.fromhex("0221312B") + P2PKH_VERBYTE = bytes.fromhex("1e") + P2SH_VERBYTES = [bytes.fromhex("0d")] + WIF_BYTE = bytes.fromhex("d4") + GENESIS_HASH = ('0000041e482b9b9691d98eefb4847340' + '5c0b8ec31b76df3797c74a78680ef818') + BASIC_HEADER_SIZE = 80 + HDR_V4_SIZE = 112 + HDR_V4_HEIGHT = 863787 + HDR_V4_START_OFFSET = HDR_V4_HEIGHT * BASIC_HEADER_SIZE + TX_COUNT = 2930206 + TX_COUNT_HEIGHT = 1299212 + TX_PER_BLOCK = 2 + RPC_PORT = 51473 + + @classmethod + def static_header_offset(cls, height): + assert cls.STATIC_BLOCK_HEADERS + if height >= cls.HDR_V4_HEIGHT: + relative_v4_offset = (height - cls.HDR_V4_HEIGHT) * cls.HDR_V4_SIZE + return cls.HDR_V4_START_OFFSET + relative_v4_offset + else: + return height * cls.BASIC_HEADER_SIZE + + @classmethod + def header_hash(cls, header): + version, = util.unpack_le_uint32_from(header) + if version >= 4: + return super().header_hash(header) + else: + import quark_hash + return quark_hash.getPoWHash(header) + + +class PivxTestnet(Pivx): + SHORTNAME = "tPIVX" + NET = "testnet" + XPUB_VERBYTES = bytes.fromhex("3a8061a0") + XPRV_VERBYTES = bytes.fromhex("3a805837") + P2PKH_VERBYTE = bytes.fromhex("8B") + P2SH_VERBYTES = [bytes.fromhex("13")] + WIF_BYTE = bytes.fromhex("EF") + GENESIS_HASH = ( + '0000041e482b9b9691d98eefb48473405c0b8ec31b76df3797c74a78680ef818') + BASIC_HEADER_SIZE = 80 + HDR_V4_SIZE = 112 + HDR_V4_HEIGHT = 863787 + HDR_V4_START_OFFSET = HDR_V4_HEIGHT * BASIC_HEADER_SIZE + TX_COUNT = 2157510 + TX_COUNT_HEIGHT = 569399 + TX_PER_BLOCK = 2 + RPC_PORT = 51472 + + +class Bitg(Coin): + + NAME = "BitcoinGreen" + SHORTNAME = "BITG" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + P2PKH_VERBYTE = bytes.fromhex("26") + P2SH_VERBYTES = [bytes.fromhex("06")] + WIF_BYTE = bytes.fromhex("2e") + GENESIS_HASH = ( + '000008467c3a9c587533dea06ad9380cded3ed32f9742a6c0c1aebc21bf2bc9b') + DAEMON = daemon.DashDaemon + TX_COUNT = 1000 + TX_COUNT_HEIGHT = 10000 + TX_PER_BLOCK = 1 + RPC_PORT = 9332 + REORG_LIMIT = 1000 + SESSIONCLS = DashElectrumX + DAEMON = daemon.DashDaemon + + @classmethod + def header_hash(cls, header): + '''Given a header return the hash.''' + import quark_hash + return quark_hash.getPoWHash(header) + + +class tBitg(Bitg): + SHORTNAME = "tBITG" + NET = "testnet" + XPUB_VERBYTES = bytes.fromhex("043587cf") + XPRV_VERBYTES = bytes.fromhex("04358394") + P2PKH_VERBYTE = bytes.fromhex("62") + P2SH_VERBYTES = [bytes.fromhex("0c")] + WIF_BYTE = bytes.fromhex("6c") + GENESIS_HASH = ( + '000008467c3a9c587533dea06ad9380cded3ed32f9742a6c0c1aebc21bf2bc9b') + RPC_PORT = 19332 + + +class CivX(Coin): + NAME = "CivX" + SHORTNAME = "CIVX" + NET = "mainnet" + XPUB_VERBYTES = bytes.fromhex("0488b21e") + XPRV_VERBYTES = bytes.fromhex("0488ade4") + GENESIS_HASH = ('00000036090a68c523471da7a4f0f958' + 'c1b4403fef74a003be7f71877699cab7') + P2PKH_VERBYTE = bytes.fromhex("1C") + P2SH_VERBYTE = [bytes.fromhex("57")] + WIF_BYTE = bytes.fromhex("9C") + RPC_PORT = 4561 + TX_COUNT = 1000 + TX_COUNT_HEIGHT = 10000 + TX_PER_BLOCK = 4 + DAEMON = daemon.PreLegacyRPCDaemon + DESERIALIZER = lib_tx.DeserializerTxTime + + @classmethod + def header_hash(cls, header): + version, = util.unpack_le_uint32_from(header) + + if version > 2: + return double_sha256(header) + else: + return hex_str_to_hash(CivX.GENESIS_HASH) + + +class CivXTestnet(CivX): + SHORTNAME = "tCIVX" + NET = "testnet" + XPUB_VERBYTES = bytes.fromhex("043587cf") + XPRV_VERBYTES = bytes.fromhex("04358394") + GENESIS_HASH = ('0000059bb2c2048493efcb0f1a034972' + 'b3ce4089d54c93b69aaab212fb369887') + P2PKH_VERBYTE = bytes.fromhex("4B") + P2SH_VERBYTE = [bytes.fromhex("CE")] + WIF_BYTE = bytes.fromhex("CB") + RPC_PORT = 14561 + + @classmethod + def header_hash(cls, header): + version, = util.unpack_le_uint32_from(header) + + if version > 2: + return double_sha256(header) + else: + return hex_str_to_hash(CivXTestnet.GENESIS_HASH) diff --git a/torba/server/daemon.py b/torba/server/daemon.py new file mode 100644 index 000000000..979d00154 --- /dev/null +++ b/torba/server/daemon.py @@ -0,0 +1,459 @@ +# Copyright (c) 2016-2017, Neil Booth +# +# All rights reserved. +# +# See the file "LICENCE" for information about the copyright +# and warranty status of this software. + +'''Class for handling asynchronous connections to a blockchain +daemon.''' + +import asyncio +import itertools +import json +import time +from calendar import timegm +from struct import pack +from time import strptime + +import aiohttp + +from torba.server.util import hex_to_bytes, class_logger,\ + unpack_le_uint16_from, pack_varint +from torba.server.hash import hex_str_to_hash, hash_to_hex_str +from torba.server.tx import DeserializerDecred +from aiorpcx import JSONRPC + + +class DaemonError(Exception): + '''Raised when the daemon returns an error in its results.''' + + +class WarmingUpError(Exception): + '''Internal - when the daemon is warming up.''' + + +class WorkQueueFullError(Exception): + '''Internal - when the daemon's work queue is full.''' + + +class Daemon(object): + '''Handles connections to a daemon at the given URL.''' + + WARMING_UP = -28 + id_counter = itertools.count() + + def __init__(self, coin, url, max_workqueue=10, init_retry=0.25, + max_retry=4.0): + self.coin = coin + self.logger = class_logger(__name__, self.__class__.__name__) + self.set_url(url) + # Limit concurrent RPC calls to this number. + # See DEFAULT_HTTP_WORKQUEUE in bitcoind, which is typically 16 + self.workqueue_semaphore = asyncio.Semaphore(value=max_workqueue) + self.init_retry = init_retry + self.max_retry = max_retry + self._height = None + self.available_rpcs = {} + + def set_url(self, url): + '''Set the URLS to the given list, and switch to the first one.''' + urls = url.split(',') + urls = [self.coin.sanitize_url(url) for url in urls] + for n, url in enumerate(urls): + status = '' if n else ' (current)' + logged_url = self.logged_url(url) + self.logger.info(f'daemon #{n + 1} at {logged_url}{status}') + self.url_index = 0 + self.urls = urls + + def current_url(self): + '''Returns the current daemon URL.''' + return self.urls[self.url_index] + + def logged_url(self, url=None): + '''The host and port part, for logging.''' + url = url or self.current_url() + return url[url.rindex('@') + 1:] + + def failover(self): + '''Call to fail-over to the next daemon URL. + + Returns False if there is only one, otherwise True. + ''' + if len(self.urls) > 1: + self.url_index = (self.url_index + 1) % len(self.urls) + self.logger.info(f'failing over to {self.logged_url()}') + return True + return False + + def client_session(self): + '''An aiohttp client session.''' + return aiohttp.ClientSession() + + async def _send_data(self, data): + async with self.workqueue_semaphore: + async with self.client_session() as session: + async with session.post(self.current_url(), data=data) as resp: + kind = resp.headers.get('Content-Type', None) + if kind == 'application/json': + return await resp.json() + # bitcoind's HTTP protocol "handling" is a bad joke + text = await resp.text() + if 'Work queue depth exceeded' in text: + raise WorkQueueFullError + text = text.strip() or resp.reason + self.logger.error(text) + raise DaemonError(text) + + async def _send(self, payload, processor): + '''Send a payload to be converted to JSON. + + Handles temporary connection issues. Daemon reponse errors + are raise through DaemonError. + ''' + def log_error(error): + nonlocal last_error_log, retry + now = time.time() + if now - last_error_log > 60: + last_error_log = now + self.logger.error(f'{error} Retrying occasionally...') + if retry == self.max_retry and self.failover(): + retry = 0 + + on_good_message = None + last_error_log = 0 + data = json.dumps(payload) + retry = self.init_retry + while True: + try: + result = await self._send_data(data) + result = processor(result) + if on_good_message: + self.logger.info(on_good_message) + return result + except asyncio.TimeoutError: + log_error('timeout error.') + except aiohttp.ServerDisconnectedError: + log_error('disconnected.') + on_good_message = 'connection restored' + except aiohttp.ClientConnectionError: + log_error('connection problem - is your daemon running?') + on_good_message = 'connection restored' + except aiohttp.ClientError as e: + log_error(f'daemon error: {e}') + on_good_message = 'running normally' + except WarmingUpError: + log_error('starting up checking blocks.') + on_good_message = 'running normally' + except WorkQueueFullError: + log_error('work queue full.') + on_good_message = 'running normally' + + await asyncio.sleep(retry) + retry = max(min(self.max_retry, retry * 2), self.init_retry) + + async def _send_single(self, method, params=None): + '''Send a single request to the daemon.''' + def processor(result): + err = result['error'] + if not err: + return result['result'] + if err.get('code') == self.WARMING_UP: + raise WarmingUpError + raise DaemonError(err) + + payload = {'method': method, 'id': next(self.id_counter)} + if params: + payload['params'] = params + return await self._send(payload, processor) + + async def _send_vector(self, method, params_iterable, replace_errs=False): + '''Send several requests of the same method. + + The result will be an array of the same length as params_iterable. + If replace_errs is true, any item with an error is returned as None, + otherwise an exception is raised.''' + def processor(result): + errs = [item['error'] for item in result if item['error']] + if any(err.get('code') == self.WARMING_UP for err in errs): + raise WarmingUpError + if not errs or replace_errs: + return [item['result'] for item in result] + raise DaemonError(errs) + + payload = [{'method': method, 'params': p, 'id': next(self.id_counter)} + for p in params_iterable] + if payload: + return await self._send(payload, processor) + return [] + + async def _is_rpc_available(self, method): + '''Return whether given RPC method is available in the daemon. + + Results are cached and the daemon will generally not be queried with + the same method more than once.''' + available = self.available_rpcs.get(method) + if available is None: + available = True + try: + await self._send_single(method) + except DaemonError as e: + err = e.args[0] + error_code = err.get("code") + available = error_code != JSONRPC.METHOD_NOT_FOUND + self.available_rpcs[method] = available + return available + + async def block_hex_hashes(self, first, count): + '''Return the hex hashes of count block starting at height first.''' + params_iterable = ((h, ) for h in range(first, first + count)) + return await self._send_vector('getblockhash', params_iterable) + + async def deserialised_block(self, hex_hash): + '''Return the deserialised block with the given hex hash.''' + return await self._send_single('getblock', (hex_hash, True)) + + async def raw_blocks(self, hex_hashes): + '''Return the raw binary blocks with the given hex hashes.''' + params_iterable = ((h, False) for h in hex_hashes) + blocks = await self._send_vector('getblock', params_iterable) + # Convert hex string to bytes + return [hex_to_bytes(block) for block in blocks] + + async def mempool_hashes(self): + '''Update our record of the daemon's mempool hashes.''' + return await self._send_single('getrawmempool') + + async def estimatefee(self, block_count): + '''Return the fee estimate for the block count. Units are whole + currency units per KB, e.g. 0.00000995, or -1 if no estimate + is available. + ''' + args = (block_count, ) + if await self._is_rpc_available('estimatesmartfee'): + estimate = await self._send_single('estimatesmartfee', args) + return estimate.get('feerate', -1) + return await self._send_single('estimatefee', args) + + async def getnetworkinfo(self): + '''Return the result of the 'getnetworkinfo' RPC call.''' + return await self._send_single('getnetworkinfo') + + async def relayfee(self): + '''The minimum fee a low-priority tx must pay in order to be accepted + to the daemon's memory pool.''' + network_info = await self.getnetworkinfo() + return network_info['relayfee'] + + async def getrawtransaction(self, hex_hash, verbose=False): + '''Return the serialized raw transaction with the given hash.''' + # Cast to int because some coin daemons are old and require it + return await self._send_single('getrawtransaction', + (hex_hash, int(verbose))) + + async def getrawtransactions(self, hex_hashes, replace_errs=True): + '''Return the serialized raw transactions with the given hashes. + + Replaces errors with None by default.''' + params_iterable = ((hex_hash, 0) for hex_hash in hex_hashes) + txs = await self._send_vector('getrawtransaction', params_iterable, + replace_errs=replace_errs) + # Convert hex strings to bytes + return [hex_to_bytes(tx) if tx else None for tx in txs] + + async def broadcast_transaction(self, raw_tx): + '''Broadcast a transaction to the network.''' + return await self._send_single('sendrawtransaction', (raw_tx, )) + + async def height(self): + '''Query the daemon for its current height.''' + self._height = await self._send_single('getblockcount') + return self._height + + def cached_height(self): + '''Return the cached daemon height. + + If the daemon has not been queried yet this returns None.''' + return self._height + + +class DashDaemon(Daemon): + + async def masternode_broadcast(self, params): + '''Broadcast a transaction to the network.''' + return await self._send_single('masternodebroadcast', params) + + async def masternode_list(self, params): + '''Return the masternode status.''' + return await self._send_single('masternodelist', params) + + +class FakeEstimateFeeDaemon(Daemon): + '''Daemon that simulates estimatefee and relayfee RPC calls. Coin that + wants to use this daemon must define ESTIMATE_FEE & RELAY_FEE''' + + async def estimatefee(self, block_count): + '''Return the fee estimate for the given parameters.''' + return self.coin.ESTIMATE_FEE + + async def relayfee(self): + '''The minimum fee a low-priority tx must pay in order to be accepted + to the daemon's memory pool.''' + return self.coin.RELAY_FEE + + +class LegacyRPCDaemon(Daemon): + '''Handles connections to a daemon at the given URL. + + This class is useful for daemons that don't have the new 'getblock' + RPC call that returns the block in hex, the workaround is to manually + recreate the block bytes. The recreated block bytes may not be the exact + as in the underlying blockchain but it is good enough for our indexing + purposes.''' + + async def raw_blocks(self, hex_hashes): + '''Return the raw binary blocks with the given hex hashes.''' + params_iterable = ((h, ) for h in hex_hashes) + block_info = await self._send_vector('getblock', params_iterable) + + blocks = [] + for i in block_info: + raw_block = await self.make_raw_block(i) + blocks.append(raw_block) + + # Convert hex string to bytes + return blocks + + async def make_raw_header(self, b): + pbh = b.get('previousblockhash') + if pbh is None: + pbh = '0' * 64 + return b''.join([ + pack(' 0: + transactions = await self.getrawtransactions(b.get('tx'), False) + + raw_block = header + num_txs = len(transactions) + if num_txs > 0: + raw_block += pack_varint(num_txs) + raw_block += b''.join(transactions) + else: + raw_block += b'\x00' + + return raw_block + + def timestamp_safe(self, t): + if isinstance(t, int): + return t + return timegm(strptime(t, "%Y-%m-%d %H:%M:%S %Z")) + + +class DecredDaemon(Daemon): + async def raw_blocks(self, hex_hashes): + '''Return the raw binary blocks with the given hex hashes.''' + + params_iterable = ((h, False) for h in hex_hashes) + blocks = await self._send_vector('getblock', params_iterable) + + raw_blocks = [] + valid_tx_tree = {} + for block in blocks: + # Convert to bytes from hex + raw_block = hex_to_bytes(block) + raw_blocks.append(raw_block) + # Check if previous block is valid + prev = self.prev_hex_hash(raw_block) + votebits = unpack_le_uint16_from(raw_block[100:102])[0] + valid_tx_tree[prev] = self.is_valid_tx_tree(votebits) + + processed_raw_blocks = [] + for hash, raw_block in zip(hex_hashes, raw_blocks): + if hash in valid_tx_tree: + is_valid = valid_tx_tree[hash] + else: + # Do something complicated to figure out if this block is valid + header = await self._send_single('getblockheader', (hash, )) + if 'nextblockhash' not in header: + raise DaemonError(f'Could not find next block for {hash}') + next_hash = header['nextblockhash'] + next_header = await self._send_single('getblockheader', + (next_hash, )) + is_valid = self.is_valid_tx_tree(next_header['votebits']) + + if is_valid: + processed_raw_blocks.append(raw_block) + else: + # If this block is invalid remove the normal transactions + self.logger.info(f'block {hash} is invalidated') + processed_raw_blocks.append(self.strip_tx_tree(raw_block)) + + return processed_raw_blocks + + @staticmethod + def prev_hex_hash(raw_block): + return hash_to_hex_str(raw_block[4:36]) + + @staticmethod + def is_valid_tx_tree(votebits): + # Check if previous block was invalidated. + return bool(votebits & (1 << 0) != 0) + + def strip_tx_tree(self, raw_block): + c = self.coin + assert issubclass(c.DESERIALIZER, DeserializerDecred) + d = c.DESERIALIZER(raw_block, start=c.BASIC_HEADER_SIZE) + d.read_tx_tree() # Skip normal transactions + # Create a fake block without any normal transactions + return raw_block[:c.BASIC_HEADER_SIZE] + b'\x00' + raw_block[d.cursor:] + + async def height(self): + height = await super().height() + if height > 0: + # Lie about the daemon height as the current tip can be invalidated + height -= 1 + self._height = height + return height + + async def mempool_hashes(self): + mempool = await super().mempool_hashes() + # Add current tip transactions to the 'fake' mempool. + real_height = await self._send_single('getblockcount') + tip_hash = await self._send_single('getblockhash', (real_height,)) + tip = await self.deserialised_block(tip_hash) + # Add normal transactions except coinbase + mempool += tip['tx'][1:] + # Add stake transactions if applicable + mempool += tip.get('stx', []) + return mempool + + def client_session(self): + # FIXME allow self signed certificates + connector = aiohttp.TCPConnector(verify_ssl=False) + return aiohttp.ClientSession(connector=connector) + + +class PreLegacyRPCDaemon(LegacyRPCDaemon): + '''Handles connections to a daemon at the given URL. + + This class is useful for daemons that don't have the new 'getblock' + RPC call that returns the block in hex, and need the False parameter + for the getblock''' + + async def deserialised_block(self, hex_hash): + '''Return the deserialised block with the given hex hash.''' + return await self._send_single('getblock', (hex_hash, False)) diff --git a/torba/server/db.py b/torba/server/db.py new file mode 100644 index 000000000..d594cbff0 --- /dev/null +++ b/torba/server/db.py @@ -0,0 +1,665 @@ +# Copyright (c) 2016, Neil Booth +# Copyright (c) 2017, the ElectrumX authors +# +# All rights reserved. +# +# See the file "LICENCE" for information about the copyright +# and warranty status of this software. + +'''Interface to the blockchain database.''' + + +import array +import ast +import os +import time +from bisect import bisect_right +from collections import namedtuple +from glob import glob +from struct import pack, unpack + +import attr +from aiorpcx import run_in_thread, sleep + +import torba.server.util as util +from torba.server.hash import hash_to_hex_str, HASHX_LEN +from torba.server.merkle import Merkle, MerkleCache +from torba.server.util import formatted_time +from torba.server.storage import db_class +from torba.server.history import History + + +UTXO = namedtuple("UTXO", "tx_num tx_pos tx_hash height value") + + +@attr.s(slots=True) +class FlushData(object): + height = attr.ib() + tx_count = attr.ib() + headers = attr.ib() + block_tx_hashes = attr.ib() + # The following are flushed to the UTXO DB if undo_infos is not None + undo_infos = attr.ib() + adds = attr.ib() + deletes = attr.ib() + tip = attr.ib() + + +class DB(object): + '''Simple wrapper of the backend database for querying. + + Performs no DB update, though the DB will be cleaned on opening if + it was shutdown uncleanly. + ''' + + DB_VERSIONS = [6] + + class DBError(Exception): + '''Raised on general DB errors generally indicating corruption.''' + + def __init__(self, env): + self.logger = util.class_logger(__name__, self.__class__.__name__) + self.env = env + self.coin = env.coin + + # Setup block header size handlers + if self.coin.STATIC_BLOCK_HEADERS: + self.header_offset = self.coin.static_header_offset + self.header_len = self.coin.static_header_len + else: + self.header_offset = self.dynamic_header_offset + self.header_len = self.dynamic_header_len + + self.logger.info(f'switching current directory to {env.db_dir}') + os.chdir(env.db_dir) + + self.db_class = db_class(self.env.db_engine) + self.history = History() + self.utxo_db = None + self.tx_counts = None + self.last_flush = time.time() + + self.logger.info(f'using {self.env.db_engine} for DB backend') + + # Header merkle cache + self.merkle = Merkle() + self.header_mc = MerkleCache(self.merkle, self.fs_block_hashes) + + self.headers_file = util.LogicalFile('meta/headers', 2, 16000000) + self.tx_counts_file = util.LogicalFile('meta/txcounts', 2, 2000000) + self.hashes_file = util.LogicalFile('meta/hashes', 4, 16000000) + if not self.coin.STATIC_BLOCK_HEADERS: + self.headers_offsets_file = util.LogicalFile( + 'meta/headers_offsets', 2, 16000000) + + async def _read_tx_counts(self): + if self.tx_counts is not None: + return + # tx_counts[N] has the cumulative number of txs at the end of + # height N. So tx_counts[0] is 1 - the genesis coinbase + size = (self.db_height + 1) * 4 + tx_counts = self.tx_counts_file.read(0, size) + assert len(tx_counts) == size + self.tx_counts = array.array('I', tx_counts) + if self.tx_counts: + assert self.db_tx_count == self.tx_counts[-1] + else: + assert self.db_tx_count == 0 + + async def _open_dbs(self, for_sync, compacting): + assert self.utxo_db is None + + # First UTXO DB + self.utxo_db = self.db_class('utxo', for_sync) + if self.utxo_db.is_new: + self.logger.info('created new database') + self.logger.info('creating metadata directory') + os.mkdir('meta') + with util.open_file('COIN', create=True) as f: + f.write(f'ElectrumX databases and metadata for ' + f'{self.coin.NAME} {self.coin.NET}'.encode()) + if not self.coin.STATIC_BLOCK_HEADERS: + self.headers_offsets_file.write(0, bytes(8)) + else: + self.logger.info(f'opened UTXO DB (for sync: {for_sync})') + self.read_utxo_state() + + # Then history DB + self.utxo_flush_count = self.history.open_db(self.db_class, for_sync, + self.utxo_flush_count, + compacting) + self.clear_excess_undo_info() + + # Read TX counts (requires meta directory) + await self._read_tx_counts() + + async def open_for_compacting(self): + await self._open_dbs(True, True) + + async def open_for_sync(self): + '''Open the databases to sync to the daemon. + + When syncing we want to reserve a lot of open files for the + synchronization. When serving clients we want the open files for + serving network connections. + ''' + await self._open_dbs(True, False) + + async def open_for_serving(self): + '''Open the databases for serving. If they are already open they are + closed first. + ''' + if self.utxo_db: + self.logger.info('closing DBs to re-open for serving') + self.utxo_db.close() + self.history.close_db() + self.utxo_db = None + await self._open_dbs(False, False) + + # Header merkle cache + + async def populate_header_merkle_cache(self): + self.logger.info('populating header merkle cache...') + length = max(1, self.db_height - self.env.reorg_limit) + start = time.time() + await self.header_mc.initialize(length) + elapsed = time.time() - start + self.logger.info(f'header merkle cache populated in {elapsed:.1f}s') + + async def header_branch_and_root(self, length, height): + return await self.header_mc.branch_and_root(length, height) + + # Flushing + def assert_flushed(self, flush_data): + '''Asserts state is fully flushed.''' + assert flush_data.tx_count == self.fs_tx_count == self.db_tx_count + assert flush_data.height == self.fs_height == self.db_height + assert flush_data.tip == self.db_tip + assert not flush_data.headers + assert not flush_data.block_tx_hashes + assert not flush_data.adds + assert not flush_data.deletes + assert not flush_data.undo_infos + self.history.assert_flushed() + + def flush_dbs(self, flush_data, flush_utxos, estimate_txs_remaining): + '''Flush out cached state. History is always flushed; UTXOs are + flushed if flush_utxos.''' + if flush_data.height == self.db_height: + self.assert_flushed(flush_data) + return + + start_time = time.time() + prior_flush = self.last_flush + tx_delta = flush_data.tx_count - self.last_flush_tx_count + + # Flush to file system + self.flush_fs(flush_data) + + # Then history + self.flush_history() + + # Flush state last as it reads the wall time. + with self.utxo_db.write_batch() as batch: + if flush_utxos: + self.flush_utxo_db(batch, flush_data) + self.flush_state(batch) + + # Update and put the wall time again - otherwise we drop the + # time it took to commit the batch + self.flush_state(self.utxo_db) + + elapsed = self.last_flush - start_time + self.logger.info(f'flush #{self.history.flush_count:,d} took ' + f'{elapsed:.1f}s. Height {flush_data.height:,d} ' + f'txs: {flush_data.tx_count:,d} ({tx_delta:+,d})') + + # Catch-up stats + if self.utxo_db.for_sync: + flush_interval = self.last_flush - prior_flush + tx_per_sec_gen = int(flush_data.tx_count / self.wall_time) + tx_per_sec_last = 1 + int(tx_delta / flush_interval) + eta = estimate_txs_remaining() / tx_per_sec_last + self.logger.info(f'tx/sec since genesis: {tx_per_sec_gen:,d}, ' + f'since last flush: {tx_per_sec_last:,d}') + self.logger.info(f'sync time: {formatted_time(self.wall_time)} ' + f'ETA: {formatted_time(eta)}') + + def flush_fs(self, flush_data): + '''Write headers, tx counts and block tx hashes to the filesystem. + + The first height to write is self.fs_height + 1. The FS + metadata is all append-only, so in a crash we just pick up + again from the height stored in the DB. + ''' + prior_tx_count = (self.tx_counts[self.fs_height] + if self.fs_height >= 0 else 0) + assert len(flush_data.block_tx_hashes) == len(flush_data.headers) + assert flush_data.height == self.fs_height + len(flush_data.headers) + assert flush_data.tx_count == (self.tx_counts[-1] if self.tx_counts + else 0) + assert len(self.tx_counts) == flush_data.height + 1 + hashes = b''.join(flush_data.block_tx_hashes) + flush_data.block_tx_hashes.clear() + assert len(hashes) % 32 == 0 + assert len(hashes) // 32 == flush_data.tx_count - prior_tx_count + + # Write the headers, tx counts, and tx hashes + start_time = time.time() + height_start = self.fs_height + 1 + offset = self.header_offset(height_start) + self.headers_file.write(offset, b''.join(flush_data.headers)) + self.fs_update_header_offsets(offset, height_start, flush_data.headers) + flush_data.headers.clear() + + offset = height_start * self.tx_counts.itemsize + self.tx_counts_file.write(offset, + self.tx_counts[height_start:].tobytes()) + offset = prior_tx_count * 32 + self.hashes_file.write(offset, hashes) + + self.fs_height = flush_data.height + self.fs_tx_count = flush_data.tx_count + + if self.utxo_db.for_sync: + elapsed = time.time() - start_time + self.logger.info(f'flushed filesystem data in {elapsed:.2f}s') + + def flush_history(self): + self.history.flush() + + def flush_utxo_db(self, batch, flush_data): + '''Flush the cached DB writes and UTXO set to the batch.''' + # Care is needed because the writes generated by flushing the + # UTXO state may have keys in common with our write cache or + # may be in the DB already. + start_time = time.time() + add_count = len(flush_data.adds) + spend_count = len(flush_data.deletes) // 2 + + # Spends + batch_delete = batch.delete + for key in sorted(flush_data.deletes): + batch_delete(key) + flush_data.deletes.clear() + + # New UTXOs + batch_put = batch.put + for key, value in flush_data.adds.items(): + # suffix = tx_idx + tx_num + hashX = value[:-12] + suffix = key[-2:] + value[-12:-8] + batch_put(b'h' + key[:4] + suffix, hashX) + batch_put(b'u' + hashX + suffix, value[-8:]) + flush_data.adds.clear() + + # New undo information + self.flush_undo_infos(batch_put, flush_data.undo_infos) + flush_data.undo_infos.clear() + + if self.utxo_db.for_sync: + block_count = flush_data.height - self.db_height + tx_count = flush_data.tx_count - self.db_tx_count + elapsed = time.time() - start_time + self.logger.info(f'flushed {block_count:,d} blocks with ' + f'{tx_count:,d} txs, {add_count:,d} UTXO adds, ' + f'{spend_count:,d} spends in ' + f'{elapsed:.1f}s, committing...') + + self.utxo_flush_count = self.history.flush_count + self.db_height = flush_data.height + self.db_tx_count = flush_data.tx_count + self.db_tip = flush_data.tip + + def flush_state(self, batch): + '''Flush chain state to the batch.''' + now = time.time() + self.wall_time += now - self.last_flush + self.last_flush = now + self.last_flush_tx_count = self.fs_tx_count + self.write_utxo_state(batch) + + def flush_backup(self, flush_data, touched): + '''Like flush_dbs() but when backing up. All UTXOs are flushed.''' + assert not flush_data.headers + assert not flush_data.block_tx_hashes + assert flush_data.height < self.db_height + self.history.assert_flushed() + + start_time = time.time() + tx_delta = flush_data.tx_count - self.last_flush_tx_count + + self.backup_fs(flush_data.height, flush_data.tx_count) + self.history.backup(touched, flush_data.tx_count) + with self.utxo_db.write_batch() as batch: + self.flush_utxo_db(batch, flush_data) + # Flush state last as it reads the wall time. + self.flush_state(batch) + + elapsed = self.last_flush - start_time + self.logger.info(f'backup flush #{self.history.flush_count:,d} took ' + f'{elapsed:.1f}s. Height {flush_data.height:,d} ' + f'txs: {flush_data.tx_count:,d} ({tx_delta:+,d})') + + def fs_update_header_offsets(self, offset_start, height_start, headers): + if self.coin.STATIC_BLOCK_HEADERS: + return + offset = offset_start + offsets = [] + for h in headers: + offset += len(h) + offsets.append(pack("= 0, count >= 0. Reads as many headers as + are available starting at start_height up to count. This + would be zero if start_height is beyond self.db_height, for + example. + + Returns a (binary, n) pair where binary is the concatenated + binary headers, and n is the count of headers returned. + ''' + if start_height < 0 or count < 0: + raise self.DBError(f'{count:,d} headers starting at ' + f'{start_height:,d} not on disk') + + def read_headers(): + # Read some from disk + disk_count = max(0, min(count, self.db_height + 1 - start_height)) + if disk_count: + offset = self.header_offset(start_height) + size = self.header_offset(start_height + disk_count) - offset + return self.headers_file.read(offset, size), disk_count + return b'', 0 + + return await run_in_thread(read_headers) + + def fs_tx_hash(self, tx_num): + '''Return a par (tx_hash, tx_height) for the given tx number. + + If the tx_height is not on disk, returns (None, tx_height).''' + tx_height = bisect_right(self.tx_counts, tx_num) + if tx_height > self.db_height: + tx_hash = None + else: + tx_hash = self.hashes_file.read(tx_num * 32, 32) + return tx_hash, tx_height + + async def fs_block_hashes(self, height, count): + headers_concat, headers_count = await self.read_headers(height, count) + if headers_count != count: + raise self.DBError('only got {:,d} headers starting at {:,d}, not ' + '{:,d}'.format(headers_count, height, count)) + offset = 0 + headers = [] + for n in range(count): + hlen = self.header_len(height + n) + headers.append(headers_concat[offset:offset + hlen]) + offset += hlen + + return [self.coin.header_hash(header) for header in headers] + + async def limited_history(self, hashX, *, limit=1000): + '''Return an unpruned, sorted list of (tx_hash, height) tuples of + confirmed transactions that touched the address, earliest in + the blockchain first. Includes both spending and receiving + transactions. By default returns at most 1000 entries. Set + limit to None to get them all. + ''' + def read_history(): + tx_nums = list(self.history.get_txnums(hashX, limit)) + fs_tx_hash = self.fs_tx_hash + return [fs_tx_hash(tx_num) for tx_num in tx_nums] + + while True: + history = await run_in_thread(read_history) + if all(hash is not None for hash, height in history): + return history + self.logger.warning(f'limited_history: tx hash ' + f'not found (reorg?), retrying...') + await sleep(0.25) + + # -- Undo information + + def min_undo_height(self, max_height): + '''Returns a height from which we should store undo info.''' + return max_height - self.env.reorg_limit + 1 + + def undo_key(self, height): + '''DB key for undo information at the given height.''' + return b'U' + pack('>I', height) + + def read_undo_info(self, height): + '''Read undo information from a file for the current height.''' + return self.utxo_db.get(self.undo_key(height)) + + def flush_undo_infos(self, batch_put, undo_infos): + '''undo_infos is a list of (undo_info, height) pairs.''' + for undo_info, height in undo_infos: + batch_put(self.undo_key(height), b''.join(undo_info)) + + def raw_block_prefix(self): + return 'meta/block' + + def raw_block_path(self, height): + return f'{self.raw_block_prefix()}{height:d}' + + def read_raw_block(self, height): + '''Returns a raw block read from disk. Raises FileNotFoundError + if the block isn't on-disk.''' + with util.open_file(self.raw_block_path(height)) as f: + return f.read(-1) + + def write_raw_block(self, block, height): + '''Write a raw block to disk.''' + with util.open_truncate(self.raw_block_path(height)) as f: + f.write(block) + # Delete old blocks to prevent them accumulating + try: + del_height = self.min_undo_height(height) - 1 + os.remove(self.raw_block_path(del_height)) + except FileNotFoundError: + pass + + def clear_excess_undo_info(self): + '''Clear excess undo info. Only most recent N are kept.''' + prefix = b'U' + min_height = self.min_undo_height(self.db_height) + keys = [] + for key, hist in self.utxo_db.iterator(prefix=prefix): + height, = unpack('>I', key[-4:]) + if height >= min_height: + break + keys.append(key) + + if keys: + with self.utxo_db.write_batch() as batch: + for key in keys: + batch.delete(key) + self.logger.info(f'deleted {len(keys):,d} stale undo entries') + + # delete old block files + prefix = self.raw_block_prefix() + paths = [path for path in glob(f'{prefix}[0-9]*') + if len(path) > len(prefix) + and int(path[len(prefix):]) < min_height] + if paths: + for path in paths: + try: + os.remove(path) + except FileNotFoundError: + pass + self.logger.info(f'deleted {len(paths):,d} stale block files') + + # -- UTXO database + + def read_utxo_state(self): + state = self.utxo_db.get(b'state') + if not state: + self.db_height = -1 + self.db_tx_count = 0 + self.db_tip = b'\0' * 32 + self.db_version = max(self.DB_VERSIONS) + self.utxo_flush_count = 0 + self.wall_time = 0 + self.first_sync = True + else: + state = ast.literal_eval(state.decode()) + if not isinstance(state, dict): + raise self.DBError('failed reading state from DB') + self.db_version = state['db_version'] + if self.db_version not in self.DB_VERSIONS: + raise self.DBError('your UTXO DB version is {} but this ' + 'software only handles versions {}' + .format(self.db_version, self.DB_VERSIONS)) + # backwards compat + genesis_hash = state['genesis'] + if isinstance(genesis_hash, bytes): + genesis_hash = genesis_hash.decode() + if genesis_hash != self.coin.GENESIS_HASH: + raise self.DBError('DB genesis hash {} does not match coin {}' + .format(genesis_hash, + self.coin.GENESIS_HASH)) + self.db_height = state['height'] + self.db_tx_count = state['tx_count'] + self.db_tip = state['tip'] + self.utxo_flush_count = state['utxo_flush_count'] + self.wall_time = state['wall_time'] + self.first_sync = state['first_sync'] + + # These are our state as we move ahead of DB state + self.fs_height = self.db_height + self.fs_tx_count = self.db_tx_count + self.last_flush_tx_count = self.fs_tx_count + + # Log some stats + self.logger.info('DB version: {:d}'.format(self.db_version)) + self.logger.info('coin: {}'.format(self.coin.NAME)) + self.logger.info('network: {}'.format(self.coin.NET)) + self.logger.info('height: {:,d}'.format(self.db_height)) + self.logger.info('tip: {}'.format(hash_to_hex_str(self.db_tip))) + self.logger.info('tx count: {:,d}'.format(self.db_tx_count)) + if self.utxo_db.for_sync: + self.logger.info(f'flushing DB cache at {self.env.cache_MB:,d} MB') + if self.first_sync: + self.logger.info('sync time so far: {}' + .format(util.formatted_time(self.wall_time))) + + def write_utxo_state(self, batch): + '''Write (UTXO) state to the batch.''' + state = { + 'genesis': self.coin.GENESIS_HASH, + 'height': self.db_height, + 'tx_count': self.db_tx_count, + 'tip': self.db_tip, + 'utxo_flush_count': self.utxo_flush_count, + 'wall_time': self.wall_time, + 'first_sync': self.first_sync, + 'db_version': self.db_version, + } + batch.put(b'state', repr(state).encode()) + + def set_flush_count(self, count): + self.utxo_flush_count = count + with self.utxo_db.write_batch() as batch: + self.write_utxo_state(batch) + + async def all_utxos(self, hashX): + '''Return all UTXOs for an address sorted in no particular order.''' + def read_utxos(): + utxos = [] + utxos_append = utxos.append + s_unpack = unpack + # Key: b'u' + address_hashX + tx_idx + tx_num + # Value: the UTXO value as a 64-bit unsigned integer + prefix = b'u' + hashX + for db_key, db_value in self.utxo_db.iterator(prefix=prefix): + tx_pos, tx_num = s_unpack(' utxo_flush_count: + keys.append(key) + + self.logger.info(f'deleting {len(keys):,d} history entries') + + self.flush_count = utxo_flush_count + with self.db.write_batch() as batch: + for key in keys: + batch.delete(key) + self.write_state(batch) + + self.logger.info('deleted excess history entries') + + def write_state(self, batch): + '''Write state to the history DB.''' + state = { + 'flush_count': self.flush_count, + 'comp_flush_count': self.comp_flush_count, + 'comp_cursor': self.comp_cursor, + 'db_version': self.db_version, + } + # History entries are not prefixed; the suffix \0\0 ensures we + # look similar to other entries and aren't interfered with + batch.put(b'state\0\0', repr(state).encode()) + + def add_unflushed(self, hashXs_by_tx, first_tx_num): + unflushed = self.unflushed + count = 0 + for tx_num, hashXs in enumerate(hashXs_by_tx, start=first_tx_num): + hashXs = set(hashXs) + for hashX in hashXs: + unflushed[hashX].append(tx_num) + count += len(hashXs) + self.unflushed_count += count + + def unflushed_memsize(self): + return len(self.unflushed) * 180 + self.unflushed_count * 4 + + def assert_flushed(self): + assert not self.unflushed + + def flush(self): + start_time = time.time() + self.flush_count += 1 + flush_id = pack_be_uint16(self.flush_count) + unflushed = self.unflushed + + with self.db.write_batch() as batch: + for hashX in sorted(unflushed): + key = hashX + flush_id + batch.put(key, unflushed[hashX].tobytes()) + self.write_state(batch) + + count = len(unflushed) + unflushed.clear() + self.unflushed_count = 0 + + if self.db.for_sync: + elapsed = time.time() - start_time + self.logger.info(f'flushed history in {elapsed:.1f}s ' + f'for {count:,d} addrs') + + def backup(self, hashXs, tx_count): + # Not certain this is needed, but it doesn't hurt + self.flush_count += 1 + nremoves = 0 + bisect_left = bisect.bisect_left + + with self.db.write_batch() as batch: + for hashX in sorted(hashXs): + deletes = [] + puts = {} + for key, hist in self.db.iterator(prefix=hashX, reverse=True): + a = array.array('I') + a.frombytes(hist) + # Remove all history entries >= tx_count + idx = bisect_left(a, tx_count) + nremoves += len(a) - idx + if idx > 0: + puts[key] = a[:idx].tobytes() + break + deletes.append(key) + + for key in deletes: + batch.delete(key) + for key, value in puts.items(): + batch.put(key, value) + self.write_state(batch) + + self.logger.info(f'backing up removed {nremoves:,d} history entries') + + def get_txnums(self, hashX, limit=1000): + '''Generator that returns an unpruned, sorted list of tx_nums in the + history of a hashX. Includes both spending and receiving + transactions. By default yields at most 1000 entries. Set + limit to None to get them all. ''' + limit = util.resolve_limit(limit) + for key, hist in self.db.iterator(prefix=hashX): + a = array.array('I') + a.frombytes(hist) + for tx_num in a: + if limit == 0: + return + yield tx_num + limit -= 1 + + # + # History compaction + # + + # comp_cursor is a cursor into compaction progress. + # -1: no compaction in progress + # 0-65535: Compaction in progress; all prefixes < comp_cursor have + # been compacted, and later ones have not. + # 65536: compaction complete in-memory but not flushed + # + # comp_flush_count applies during compaction, and is a flush count + # for history with prefix < comp_cursor. flush_count applies + # to still uncompacted history. It is -1 when no compaction is + # taking place. Key suffixes up to and including comp_flush_count + # are used, so a parallel history flush must first increment this + # + # When compaction is complete and the final flush takes place, + # flush_count is reset to comp_flush_count, and comp_flush_count to -1 + + def _flush_compaction(self, cursor, write_items, keys_to_delete): + '''Flush a single compaction pass as a batch.''' + # Update compaction state + if cursor == 65536: + self.flush_count = self.comp_flush_count + self.comp_cursor = -1 + self.comp_flush_count = -1 + else: + self.comp_cursor = cursor + + # History DB. Flush compacted history and updated state + with self.db.write_batch() as batch: + # Important: delete first! The keyspace may overlap. + for key in keys_to_delete: + batch.delete(key) + for key, value in write_items: + batch.put(key, value) + self.write_state(batch) + + def _compact_hashX(self, hashX, hist_map, hist_list, + write_items, keys_to_delete): + '''Compres history for a hashX. hist_list is an ordered list of + the histories to be compressed.''' + # History entries (tx numbers) are 4 bytes each. Distribute + # over rows of up to 50KB in size. A fixed row size means + # future compactions will not need to update the first N - 1 + # rows. + max_row_size = self.max_hist_row_entries * 4 + full_hist = b''.join(hist_list) + nrows = (len(full_hist) + max_row_size - 1) // max_row_size + if nrows > 4: + self.logger.info('hashX {} is large: {:,d} entries across ' + '{:,d} rows' + .format(hash_to_hex_str(hashX), + len(full_hist) // 4, nrows)) + + # Find what history needs to be written, and what keys need to + # be deleted. Start by assuming all keys are to be deleted, + # and then remove those that are the same on-disk as when + # compacted. + write_size = 0 + keys_to_delete.update(hist_map) + for n, chunk in enumerate(util.chunks(full_hist, max_row_size)): + key = hashX + pack_be_uint16(n) + if hist_map.get(key) == chunk: + keys_to_delete.remove(key) + else: + write_items.append((key, chunk)) + write_size += len(chunk) + + assert n + 1 == nrows + self.comp_flush_count = max(self.comp_flush_count, n) + + return write_size + + def _compact_prefix(self, prefix, write_items, keys_to_delete): + '''Compact all history entries for hashXs beginning with the + given prefix. Update keys_to_delete and write.''' + prior_hashX = None + hist_map = {} + hist_list = [] + + key_len = HASHX_LEN + 2 + write_size = 0 + for key, hist in self.db.iterator(prefix=prefix): + # Ignore non-history entries + if len(key) != key_len: + continue + hashX = key[:-2] + if hashX != prior_hashX and prior_hashX: + write_size += self._compact_hashX(prior_hashX, hist_map, + hist_list, write_items, + keys_to_delete) + hist_map.clear() + hist_list.clear() + prior_hashX = hashX + hist_map[key] = hist + hist_list.append(hist) + + if prior_hashX: + write_size += self._compact_hashX(prior_hashX, hist_map, hist_list, + write_items, keys_to_delete) + return write_size + + def _compact_history(self, limit): + '''Inner loop of history compaction. Loops until limit bytes have + been processed. + ''' + keys_to_delete = set() + write_items = [] # A list of (key, value) pairs + write_size = 0 + + # Loop over 2-byte prefixes + cursor = self.comp_cursor + while write_size < limit and cursor < 65536: + prefix = pack_be_uint16(cursor) + write_size += self._compact_prefix(prefix, write_items, + keys_to_delete) + cursor += 1 + + max_rows = self.comp_flush_count + 1 + self._flush_compaction(cursor, write_items, keys_to_delete) + + self.logger.info('history compaction: wrote {:,d} rows ({:.1f} MB), ' + 'removed {:,d} rows, largest: {:,d}, {:.1f}% complete' + .format(len(write_items), write_size / 1000000, + len(keys_to_delete), max_rows, + 100 * cursor / 65536)) + return write_size + + def _cancel_compaction(self): + if self.comp_cursor != -1: + self.logger.warning('cancelling in-progress history compaction') + self.comp_flush_count = -1 + self.comp_cursor = -1 diff --git a/torba/server/mempool.py b/torba/server/mempool.py new file mode 100644 index 000000000..765e66a4f --- /dev/null +++ b/torba/server/mempool.py @@ -0,0 +1,365 @@ +# Copyright (c) 2016-2018, Neil Booth +# +# All rights reserved. +# +# See the file "LICENCE" for information about the copyright +# and warranty status of this software. + +'''Mempool handling.''' + +import itertools +import time +from abc import ABC, abstractmethod +from asyncio import Lock +from collections import defaultdict + +import attr +from aiorpcx import TaskGroup, run_in_thread, sleep + +from torba.server.hash import hash_to_hex_str, hex_str_to_hash +from torba.server.util import class_logger, chunks +from torba.server.db import UTXO + + +@attr.s(slots=True) +class MemPoolTx(object): + prevouts = attr.ib() + # A pair is a (hashX, value) tuple + in_pairs = attr.ib() + out_pairs = attr.ib() + fee = attr.ib() + size = attr.ib() + + +@attr.s(slots=True) +class MemPoolTxSummary(object): + hash = attr.ib() + fee = attr.ib() + has_unconfirmed_inputs = attr.ib() + + +class MemPoolAPI(ABC): + '''A concrete instance of this class is passed to the MemPool object + and used by it to query DB and blockchain state.''' + + @abstractmethod + async def height(self): + '''Query bitcoind for its height.''' + + @abstractmethod + def cached_height(self): + '''Return the height of bitcoind the last time it was queried, + for any reason, without actually querying it. + ''' + + @abstractmethod + async def mempool_hashes(self): + '''Query bitcoind for the hashes of all transactions in its + mempool, returned as a list.''' + + @abstractmethod + async def raw_transactions(self, hex_hashes): + '''Query bitcoind for the serialized raw transactions with the given + hashes. Missing transactions are returned as None. + + hex_hashes is an iterable of hexadecimal hash strings.''' + + @abstractmethod + async def lookup_utxos(self, prevouts): + '''Return a list of (hashX, value) pairs each prevout if unspent, + otherwise return None if spent or not found. + + prevouts - an iterable of (hash, index) pairs + ''' + + @abstractmethod + async def on_mempool(self, touched, height): + '''Called each time the mempool is synchronized. touched is a set of + hashXs touched since the previous call. height is the + daemon's height at the time the mempool was obtained.''' + + +class MemPool(object): + '''Representation of the daemon's mempool. + + coin - a coin class from coins.py + api - an object implementing MemPoolAPI + + Updated regularly in caught-up state. Goal is to enable efficient + response to the calls in the external interface. To that end we + maintain the following maps: + + tx: tx_hash -> MemPoolTx + hashXs: hashX -> set of all hashes of txs touching the hashX + ''' + + def __init__(self, coin, api, refresh_secs=5.0, log_status_secs=120.0): + assert isinstance(api, MemPoolAPI) + self.coin = coin + self.api = api + self.logger = class_logger(__name__, self.__class__.__name__) + self.txs = {} + self.hashXs = defaultdict(set) # None can be a key + self.cached_compact_histogram = [] + self.refresh_secs = refresh_secs + self.log_status_secs = log_status_secs + # Prevents mempool refreshes during fee histogram calculation + self.lock = Lock() + + async def _logging(self, synchronized_event): + '''Print regular logs of mempool stats.''' + self.logger.info('beginning processing of daemon mempool. ' + 'This can take some time...') + start = time.time() + await synchronized_event.wait() + elapsed = time.time() - start + self.logger.info(f'synced in {elapsed:.2f}s') + while True: + self.logger.info(f'{len(self.txs):,d} txs ' + f'touching {len(self.hashXs):,d} addresses') + await sleep(self.log_status_secs) + await synchronized_event.wait() + + async def _refresh_histogram(self, synchronized_event): + while True: + await synchronized_event.wait() + async with self.lock: + # Threaded as can be expensive + await run_in_thread(self._update_histogram, 100_000) + await sleep(self.coin.MEMPOOL_HISTOGRAM_REFRESH_SECS) + + def _update_histogram(self, bin_size): + # Build a histogram by fee rate + histogram = defaultdict(int) + for tx in self.txs.values(): + histogram[tx.fee // tx.size] += tx.size + + # Now compact it. For efficiency, get_fees returns a + # compact histogram with variable bin size. The compact + # histogram is an array of (fee_rate, vsize) values. + # vsize_n is the cumulative virtual size of mempool + # transactions with a fee rate in the interval + # [rate_(n-1), rate_n)], and rate_(n-1) > rate_n. + # Intervals are chosen to create tranches containing at + # least 100kb of transactions + compact = [] + cum_size = 0 + r = 0 # ? + for fee_rate, size in sorted(histogram.items(), reverse=True): + cum_size += size + if cum_size + r > bin_size: + compact.append((fee_rate, cum_size)) + r += cum_size - bin_size + cum_size = 0 + bin_size *= 1.1 + self.logger.info(f'compact fee histogram: {compact}') + self.cached_compact_histogram = compact + + def _accept_transactions(self, tx_map, utxo_map, touched): + '''Accept transactions in tx_map to the mempool if all their inputs + can be found in the existing mempool or a utxo_map from the + DB. + + Returns an (unprocessed tx_map, unspent utxo_map) pair. + ''' + hashXs = self.hashXs + txs = self.txs + + deferred = {} + unspent = set(utxo_map) + # Try to find all prevouts so we can accept the TX + for hash, tx in tx_map.items(): + in_pairs = [] + try: + for prevout in tx.prevouts: + utxo = utxo_map.get(prevout) + if not utxo: + prev_hash, prev_index = prevout + # Raises KeyError if prev_hash is not in txs + utxo = txs[prev_hash].out_pairs[prev_index] + in_pairs.append(utxo) + except KeyError: + deferred[hash] = tx + continue + + # Spend the prevouts + unspent.difference_update(tx.prevouts) + + # Save the in_pairs, compute the fee and accept the TX + tx.in_pairs = tuple(in_pairs) + # Avoid negative fees if dealing with generation-like transactions + # because some in_parts would be missing + tx.fee = max(0, (sum(v for _, v in tx.in_pairs) - + sum(v for _, v in tx.out_pairs))) + txs[hash] = tx + + for hashX, value in itertools.chain(tx.in_pairs, tx.out_pairs): + touched.add(hashX) + hashXs[hashX].add(hash) + + return deferred, {prevout: utxo_map[prevout] for prevout in unspent} + + async def _refresh_hashes(self, synchronized_event): + '''Refresh our view of the daemon's mempool.''' + while True: + height = self.api.cached_height() + hex_hashes = await self.api.mempool_hashes() + if height != await self.api.height(): + continue + hashes = set(hex_str_to_hash(hh) for hh in hex_hashes) + async with self.lock: + touched = await self._process_mempool(hashes) + synchronized_event.set() + synchronized_event.clear() + await self.api.on_mempool(touched, height) + await sleep(self.refresh_secs) + + async def _process_mempool(self, all_hashes): + # Re-sync with the new set of hashes + txs = self.txs + hashXs = self.hashXs + touched = set() + + # First handle txs that have disappeared + for tx_hash in set(txs).difference(all_hashes): + tx = txs.pop(tx_hash) + tx_hashXs = set(hashX for hashX, value in tx.in_pairs) + tx_hashXs.update(hashX for hashX, value in tx.out_pairs) + for hashX in tx_hashXs: + hashXs[hashX].remove(tx_hash) + if not hashXs[hashX]: + del hashXs[hashX] + touched.update(tx_hashXs) + + # Process new transactions + new_hashes = list(all_hashes.difference(txs)) + if new_hashes: + group = TaskGroup() + for hashes in chunks(new_hashes, 200): + coro = self._fetch_and_accept(hashes, all_hashes, touched) + await group.spawn(coro) + tx_map = {} + utxo_map = {} + async for task in group: + deferred, unspent = task.result() + tx_map.update(deferred) + utxo_map.update(unspent) + + prior_count = 0 + # FIXME: this is not particularly efficient + while tx_map and len(tx_map) != prior_count: + prior_count = len(tx_map) + tx_map, utxo_map = self._accept_transactions(tx_map, utxo_map, + touched) + if tx_map: + self.logger.info(f'{len(tx_map)} txs dropped') + + return touched + + async def _fetch_and_accept(self, hashes, all_hashes, touched): + '''Fetch a list of mempool transactions.''' + hex_hashes_iter = (hash_to_hex_str(hash) for hash in hashes) + raw_txs = await self.api.raw_transactions(hex_hashes_iter) + + def deserialize_txs(): # This function is pure + to_hashX = self.coin.hashX_from_script + deserializer = self.coin.DESERIALIZER + + txs = {} + for hash, raw_tx in zip(hashes, raw_txs): + # The daemon may have evicted the tx from its + # mempool or it may have gotten in a block + if not raw_tx: + continue + tx, tx_size = deserializer(raw_tx).read_tx_and_vsize() + # Convert the inputs and outputs into (hashX, value) pairs + # Drop generation-like inputs from MemPoolTx.prevouts + txin_pairs = tuple((txin.prev_hash, txin.prev_idx) + for txin in tx.inputs + if not txin.is_generation()) + txout_pairs = tuple((to_hashX(txout.pk_script), txout.value) + for txout in tx.outputs) + txs[hash] = MemPoolTx(txin_pairs, None, txout_pairs, + 0, tx_size) + return txs + + # Thread this potentially slow operation so as not to block + tx_map = await run_in_thread(deserialize_txs) + + # Determine all prevouts not in the mempool, and fetch the + # UTXO information from the database. Failed prevout lookups + # return None - concurrent database updates happen - which is + # relied upon by _accept_transactions. Ignore prevouts that are + # generation-like. + prevouts = tuple(prevout for tx in tx_map.values() + for prevout in tx.prevouts + if prevout[0] not in all_hashes) + utxos = await self.api.lookup_utxos(prevouts) + utxo_map = {prevout: utxo for prevout, utxo in zip(prevouts, utxos)} + + return self._accept_transactions(tx_map, utxo_map, touched) + + # + # External interface + # + + async def keep_synchronized(self, synchronized_event): + '''Keep the mempool synchronized with the daemon.''' + async with TaskGroup() as group: + await group.spawn(self._refresh_hashes(synchronized_event)) + await group.spawn(self._refresh_histogram(synchronized_event)) + await group.spawn(self._logging(synchronized_event)) + + async def balance_delta(self, hashX): + '''Return the unconfirmed amount in the mempool for hashX. + + Can be positive or negative. + ''' + value = 0 + if hashX in self.hashXs: + for hash in self.hashXs[hashX]: + tx = self.txs[hash] + value -= sum(v for h168, v in tx.in_pairs if h168 == hashX) + value += sum(v for h168, v in tx.out_pairs if h168 == hashX) + return value + + async def compact_fee_histogram(self): + '''Return a compact fee histogram of the current mempool.''' + return self.cached_compact_histogram + + async def potential_spends(self, hashX): + '''Return a set of (prev_hash, prev_idx) pairs from mempool + transactions that touch hashX. + + None, some or all of these may be spends of the hashX, but all + actual spends of it (in the DB or mempool) will be included. + ''' + result = set() + for tx_hash in self.hashXs.get(hashX, ()): + tx = self.txs[tx_hash] + result.update(tx.prevouts) + return result + + async def transaction_summaries(self, hashX): + '''Return a list of MemPoolTxSummary objects for the hashX.''' + result = [] + for tx_hash in self.hashXs.get(hashX, ()): + tx = self.txs[tx_hash] + has_ui = any(hash in self.txs for hash, idx in tx.prevouts) + result.append(MemPoolTxSummary(tx_hash, tx.fee, has_ui)) + return result + + async def unordered_UTXOs(self, hashX): + '''Return an unordered list of UTXO named tuples from mempool + transactions that pay to hashX. + + This does not consider if any other mempool transactions spend + the outputs. + ''' + utxos = [] + for tx_hash in self.hashXs.get(hashX, ()): + tx = self.txs.get(tx_hash) + for pos, (hX, value) in enumerate(tx.out_pairs): + if hX == hashX: + utxos.append(UTXO(-1, pos, tx_hash, 0, value)) + return utxos diff --git a/torba/server/merkle.py b/torba/server/merkle.py new file mode 100644 index 000000000..bdb0a90a9 --- /dev/null +++ b/torba/server/merkle.py @@ -0,0 +1,254 @@ +# Copyright (c) 2018, Neil Booth +# +# All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# and warranty status of this software. + +'''Merkle trees, branches, proofs and roots.''' + +from math import ceil, log + +from aiorpcx import Event + +from torba.server.hash import double_sha256 + + +class Merkle(object): + '''Perform merkle tree calculations on binary hashes using a given hash + function. + + If the hash count is not even, the final hash is repeated when + calculating the next merkle layer up the tree. + ''' + + def __init__(self, hash_func=double_sha256): + self.hash_func = hash_func + + def tree_depth(self, hash_count): + return self.branch_length(hash_count) + 1 + + def branch_length(self, hash_count): + '''Return the length of a merkle branch given the number of hashes.''' + if not isinstance(hash_count, int): + raise TypeError('hash_count must be an integer') + if hash_count < 1: + raise ValueError('hash_count must be at least 1') + return ceil(log(hash_count, 2)) + + def branch_and_root(self, hashes, index, length=None): + '''Return a (merkle branch, merkle_root) pair given hashes, and the + index of one of those hashes. + ''' + hashes = list(hashes) + if not isinstance(index, int): + raise TypeError('index must be an integer') + # This also asserts hashes is not empty + if not 0 <= index < len(hashes): + raise ValueError('index out of range') + natural_length = self.branch_length(len(hashes)) + if length is None: + length = natural_length + else: + if not isinstance(length, int): + raise TypeError('length must be an integer') + if length < natural_length: + raise ValueError('length out of range') + + hash_func = self.hash_func + branch = [] + for _ in range(length): + if len(hashes) & 1: + hashes.append(hashes[-1]) + branch.append(hashes[index ^ 1]) + index >>= 1 + hashes = [hash_func(hashes[n] + hashes[n + 1]) + for n in range(0, len(hashes), 2)] + + return branch, hashes[0] + + def root(self, hashes, length=None): + '''Return the merkle root of a non-empty iterable of binary hashes.''' + branch, root = self.branch_and_root(hashes, 0, length) + return root + + def root_from_proof(self, hash, branch, index): + '''Return the merkle root given a hash, a merkle branch to it, and + its index in the hashes array. + + branch is an iterable sorted deepest to shallowest. If the + returned root is the expected value then the merkle proof is + verified. + + The caller should have confirmed the length of the branch with + branch_length(). Unfortunately this is not easily done for + bitcoin transactions as the number of transactions in a block + is unknown to an SPV client. + ''' + hash_func = self.hash_func + for elt in branch: + if index & 1: + hash = hash_func(elt + hash) + else: + hash = hash_func(hash + elt) + index >>= 1 + if index: + raise ValueError('index out of range for branch') + return hash + + def level(self, hashes, depth_higher): + '''Return a level of the merkle tree of hashes the given depth + higher than the bottom row of the original tree.''' + size = 1 << depth_higher + root = self.root + return [root(hashes[n: n + size], depth_higher) + for n in range(0, len(hashes), size)] + + def branch_and_root_from_level(self, level, leaf_hashes, index, + depth_higher): + '''Return a (merkle branch, merkle_root) pair when a merkle-tree has a + level cached. + + To maximally reduce the amount of data hashed in computing a + markle branch, cache a tree of depth N at level N // 2. + + level is a list of hashes in the middle of the tree (returned + by level()) + + leaf_hashes are the leaves needed to calculate a partial branch + up to level. + + depth_higher is how much higher level is than the leaves of the tree + + index is the index in the full list of hashes of the hash whose + merkle branch we want. + ''' + if not isinstance(level, list): + raise TypeError("level must be a list") + if not isinstance(leaf_hashes, list): + raise TypeError("leaf_hashes must be a list") + leaf_index = (index >> depth_higher) << depth_higher + leaf_branch, leaf_root = self.branch_and_root( + leaf_hashes, index - leaf_index, depth_higher) + index >>= depth_higher + level_branch, root = self.branch_and_root(level, index) + # Check last so that we know index is in-range + if leaf_root != level[index]: + raise ValueError('leaf hashes inconsistent with level') + return leaf_branch + level_branch, root + + +class MerkleCache(object): + '''A cache to calculate merkle branches efficiently.''' + + def __init__(self, merkle, source_func): + '''Initialise a cache hashes taken from source_func: + + async def source_func(index, count): + ... + ''' + self.merkle = merkle + self.source_func = source_func + self.length = 0 + self.depth_higher = 0 + self.initialized = Event() + + def _segment_length(self): + return 1 << self.depth_higher + + def _leaf_start(self, index): + '''Given a level's depth higher and a hash index, return the leaf + index and leaf hash count needed to calculate a merkle branch. + ''' + depth_higher = self.depth_higher + return (index >> depth_higher) << depth_higher + + def _level(self, hashes): + return self.merkle.level(hashes, self.depth_higher) + + async def _extend_to(self, length): + '''Extend the length of the cache if necessary.''' + if length <= self.length: + return + # Start from the beginning of any final partial segment. + # Retain the value of depth_higher; in practice this is fine + start = self._leaf_start(self.length) + hashes = await self.source_func(start, length - start) + self.level[start >> self.depth_higher:] = self._level(hashes) + self.length = length + + async def _level_for(self, length): + '''Return a (level_length, final_hash) pair for a truncation + of the hashes to the given length.''' + if length == self.length: + return self.level + level = self.level[:length >> self.depth_higher] + leaf_start = self._leaf_start(length) + count = min(self._segment_length(), length - leaf_start) + hashes = await self.source_func(leaf_start, count) + level += self._level(hashes) + return level + + async def initialize(self, length): + '''Call to initialize the cache to a source of given length.''' + self.length = length + self.depth_higher = self.merkle.tree_depth(length) // 2 + self.level = self._level(await self.source_func(0, length)) + self.initialized.set() + + def truncate(self, length): + '''Truncate the cache so it covers no more than length underlying + hashes.''' + if not isinstance(length, int): + raise TypeError('length must be an integer') + if length <= 0: + raise ValueError('length must be positive') + if length >= self.length: + return + length = self._leaf_start(length) + self.length = length + self.level[length >> self.depth_higher:] = [] + + async def branch_and_root(self, length, index): + '''Return a merkle branch and root. Length is the number of + hashes used to calculate the merkle root, index is the position + of the hash to calculate the branch of. + + index must be less than length, which must be at least 1.''' + if not isinstance(length, int): + raise TypeError('length must be an integer') + if not isinstance(index, int): + raise TypeError('index must be an integer') + if length <= 0: + raise ValueError('length must be positive') + if index >= length: + raise ValueError('index must be less than length') + await self.initialized.wait() + await self._extend_to(length) + leaf_start = self._leaf_start(index) + count = min(self._segment_length(), length - leaf_start) + leaf_hashes = await self.source_func(leaf_start, count) + if length < self._segment_length(): + return self.merkle.branch_and_root(leaf_hashes, index) + level = await self._level_for(length) + return self.merkle.branch_and_root_from_level( + level, leaf_hashes, index, self.depth_higher) diff --git a/torba/server/peer.py b/torba/server/peer.py new file mode 100644 index 000000000..7b392acbe --- /dev/null +++ b/torba/server/peer.py @@ -0,0 +1,301 @@ +# Copyright (c) 2017, Neil Booth +# +# All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +'''Representation of a peer server.''' + +from ipaddress import ip_address + +from torba.server.util import cachedproperty +import torba.server.util as util + +from typing import Dict + + +class Peer(object): + + # Protocol version + ATTRS = ('host', 'features', + # metadata + 'source', 'ip_addr', + 'last_good', 'last_try', 'try_count') + FEATURES = ('pruning', 'server_version', 'protocol_min', 'protocol_max', + 'ssl_port', 'tcp_port') + # This should be set by the application + DEFAULT_PORTS: Dict[str, int] = {} + + def __init__(self, host, features, source='unknown', ip_addr=None, + last_good=0, last_try=0, try_count=0): + '''Create a peer given a host name (or IP address as a string), + a dictionary of features, and a record of the source.''' + assert isinstance(host, str) + assert isinstance(features, dict) + assert host in features.get('hosts', {}) + self.host = host + self.features = features.copy() + # Canonicalize / clean-up + for feature in self.FEATURES: + self.features[feature] = getattr(self, feature) + # Metadata + self.source = source + self.ip_addr = ip_addr + # last_good represents the last connection that was + # successful *and* successfully verified, at which point + # try_count is set to 0. Failure to connect or failure to + # verify increment the try_count. + self.last_good = last_good + self.last_try = last_try + self.try_count = try_count + # Transient, non-persisted metadata + self.bad = False + self.other_port_pairs = set() + + @classmethod + def peers_from_features(cls, features, source): + peers = [] + if isinstance(features, dict): + hosts = features.get('hosts') + if isinstance(hosts, dict): + peers = [Peer(host, features, source=source) + for host in hosts if isinstance(host, str)] + return peers + + @classmethod + def deserialize(cls, item): + '''Deserialize from a dictionary.''' + return cls(**item) + + def matches(self, peers): + '''Return peers whose host matches our hostname or IP address. + Additionally include all peers whose IP address matches our + hostname if that is an IP address. + ''' + candidates = (self.host.lower(), self.ip_addr) + return [peer for peer in peers + if peer.host.lower() in candidates + or peer.ip_addr == self.host] + + def __str__(self): + return self.host + + def update_features(self, features): + '''Update features in-place.''' + try: + tmp = Peer(self.host, features) + except Exception: + pass + else: + self.update_features_from_peer(tmp) + + def update_features_from_peer(self, peer): + if peer != self: + self.features = peer.features + for feature in self.FEATURES: + setattr(self, feature, getattr(peer, feature)) + + def connection_port_pairs(self): + '''Return a list of (kind, port) pairs to try when making a + connection.''' + # Use a list not a set - it's important to try the registered + # ports first. + pairs = [('SSL', self.ssl_port), ('TCP', self.tcp_port)] + while self.other_port_pairs: + pairs.append(self.other_port_pairs.pop()) + return [pair for pair in pairs if pair[1]] + + def mark_bad(self): + '''Mark as bad to avoid reconnects but also to remember for a + while.''' + self.bad = True + + def check_ports(self, other): + '''Remember differing ports in case server operator changed them + or removed one.''' + if other.ssl_port != self.ssl_port: + self.other_port_pairs.add(('SSL', other.ssl_port)) + if other.tcp_port != self.tcp_port: + self.other_port_pairs.add(('TCP', other.tcp_port)) + return bool(self.other_port_pairs) + + @cachedproperty + def is_tor(self): + return self.host.endswith('.onion') + + @cachedproperty + def is_valid(self): + ip = self.ip_address + if ip: + return ((ip.is_global or ip.is_private) + and not (ip.is_multicast or ip.is_unspecified)) + return util.is_valid_hostname(self.host) + + @cachedproperty + def is_public(self): + ip = self.ip_address + if ip: + return self.is_valid and not ip.is_private + else: + return self.is_valid and self.host != 'localhost' + + @cachedproperty + def ip_address(self): + '''The host as a python ip_address object, or None.''' + try: + return ip_address(self.host) + except ValueError: + return None + + def bucket(self): + if self.is_tor: + return 'onion' + if not self.ip_addr: + return '' + return tuple(self.ip_addr.split('.')[:2]) + + def serialize(self): + '''Serialize to a dictionary.''' + return {attr: getattr(self, attr) for attr in self.ATTRS} + + def _port(self, key): + hosts = self.features.get('hosts') + if isinstance(hosts, dict): + host = hosts.get(self.host) + port = self._integer(key, host) + if port and 0 < port < 65536: + return port + return None + + def _integer(self, key, d=None): + d = d or self.features + result = d.get(key) if isinstance(d, dict) else None + if isinstance(result, str): + try: + result = int(result) + except ValueError: + pass + return result if isinstance(result, int) else None + + def _string(self, key): + result = self.features.get(key) + return result if isinstance(result, str) else None + + @cachedproperty + def genesis_hash(self): + '''Returns None if no SSL port, otherwise the port as an integer.''' + return self._string('genesis_hash') + + @cachedproperty + def ssl_port(self): + '''Returns None if no SSL port, otherwise the port as an integer.''' + return self._port('ssl_port') + + @cachedproperty + def tcp_port(self): + '''Returns None if no TCP port, otherwise the port as an integer.''' + return self._port('tcp_port') + + @cachedproperty + def server_version(self): + '''Returns the server version as a string if known, otherwise None.''' + return self._string('server_version') + + @cachedproperty + def pruning(self): + '''Returns the pruning level as an integer. None indicates no + pruning.''' + pruning = self._integer('pruning') + if pruning and pruning > 0: + return pruning + return None + + def _protocol_version_string(self, key): + version_str = self.features.get(key) + ptuple = util.protocol_tuple(version_str) + return util.version_string(ptuple) + + @cachedproperty + def protocol_min(self): + '''Minimum protocol version as a string, e.g., 1.0''' + return self._protocol_version_string('protocol_min') + + @cachedproperty + def protocol_max(self): + '''Maximum protocol version as a string, e.g., 1.1''' + return self._protocol_version_string('protocol_max') + + def to_tuple(self): + '''The tuple ((ip, host, details) expected in response + to a peers subscription.''' + details = self.real_name().split()[1:] + return (self.ip_addr or self.host, self.host, details) + + def real_name(self): + '''Real name of this peer as used on IRC.''' + def port_text(letter, port): + if port == self.DEFAULT_PORTS.get(letter): + return letter + else: + return letter + str(port) + + parts = [self.host, 'v' + self.protocol_max] + if self.pruning: + parts.append('p{:d}'.format(self.pruning)) + for letter, port in (('s', self.ssl_port), ('t', self.tcp_port)): + if port: + parts.append(port_text(letter, port)) + return ' '.join(parts) + + @classmethod + def from_real_name(cls, real_name, source): + '''Real name is a real name as on IRC, such as + + "erbium1.sytes.net v1.0 s t" + + Returns an instance of this Peer class. + ''' + host = 'nohost' + features = {} + ports = {} + for n, part in enumerate(real_name.split()): + if n == 0: + host = part + continue + if part[0] in ('s', 't'): + if len(part) == 1: + port = cls.DEFAULT_PORTS[part[0]] + else: + port = part[1:] + if part[0] == 's': + ports['ssl_port'] = port + else: + ports['tcp_port'] = port + elif part[0] == 'v': + features['protocol_max'] = features['protocol_min'] = part[1:] + elif part[0] == 'p': + features['pruning'] = part[1:] + + features.update(ports) + features['hosts'] = {host: ports} + + return cls(host, features, source) diff --git a/torba/server/peers.py b/torba/server/peers.py new file mode 100644 index 000000000..86e8a292a --- /dev/null +++ b/torba/server/peers.py @@ -0,0 +1,510 @@ +# Copyright (c) 2017-2018, Neil Booth +# +# All rights reserved. +# +# See the file "LICENCE" for information about the copyright +# and warranty status of this software. + +'''Peer management.''' + +import asyncio +import random +import socket +import ssl +import time +from collections import defaultdict, Counter + +from aiorpcx import (Connector, RPCSession, SOCKSProxy, + Notification, handler_invocation, + SOCKSError, RPCError, TaskTimeout, TaskGroup, Event, + sleep, run_in_thread, ignore_after, timeout_after) + +from torba.server.peer import Peer +from torba.server.util import class_logger, protocol_tuple + +PEER_GOOD, PEER_STALE, PEER_NEVER, PEER_BAD = range(4) +STALE_SECS = 24 * 3600 +WAKEUP_SECS = 300 + + +class BadPeerError(Exception): + pass + + +def assert_good(message, result, instance): + if not isinstance(result, instance): + raise BadPeerError(f'{message} returned bad result type ' + f'{type(result).__name__}') + + +class PeerSession(RPCSession): + '''An outgoing session to a peer.''' + + async def handle_request(self, request): + # We subscribe so might be unlucky enough to get a notification... + if (isinstance(request, Notification) and + request.method == 'blockchain.headers.subscribe'): + pass + else: + await handler_invocation(None, request) # Raises + + +class PeerManager(object): + '''Looks after the DB of peer network servers. + + Attempts to maintain a connection with up to 8 peers. + Issues a 'peers.subscribe' RPC to them and tells them our data. + ''' + def __init__(self, env, db): + self.logger = class_logger(__name__, self.__class__.__name__) + # Initialise the Peer class + Peer.DEFAULT_PORTS = env.coin.PEER_DEFAULT_PORTS + self.env = env + self.db = db + + # Our clearnet and Tor Peers, if any + sclass = env.coin.SESSIONCLS + self.myselves = [Peer(ident.host, sclass.server_features(env), 'env') + for ident in env.identities] + self.server_version_args = sclass.server_version_args() + # Peers have one entry per hostname. Once connected, the + # ip_addr property is either None, an onion peer, or the + # IP address that was connected to. Adding a peer will evict + # any other peers with the same host name or IP address. + self.peers = set() + self.permit_onion_peer_time = time.time() + self.proxy = None + self.group = TaskGroup() + + def _my_clearnet_peer(self): + '''Returns the clearnet peer representing this server, if any.''' + clearnet = [peer for peer in self.myselves if not peer.is_tor] + return clearnet[0] if clearnet else None + + def _set_peer_statuses(self): + '''Set peer statuses.''' + cutoff = time.time() - STALE_SECS + for peer in self.peers: + if peer.bad: + peer.status = PEER_BAD + elif peer.last_good > cutoff: + peer.status = PEER_GOOD + elif peer.last_good: + peer.status = PEER_STALE + else: + peer.status = PEER_NEVER + + def _features_to_register(self, peer, remote_peers): + '''If we should register ourselves to the remote peer, which has + reported the given list of known peers, return the clearnet + identity features to register, otherwise None. + ''' + # Announce ourself if not present. Don't if disabled, we + # are a non-public IP address, or to ourselves. + if not self.env.peer_announce or peer in self.myselves: + return None + my = self._my_clearnet_peer() + if not my or not my.is_public: + return None + # Register if no matches, or ports have changed + for peer in my.matches(remote_peers): + if peer.tcp_port == my.tcp_port and peer.ssl_port == my.ssl_port: + return None + return my.features + + def _permit_new_onion_peer(self): + '''Accept a new onion peer only once per random time interval.''' + now = time.time() + if now < self.permit_onion_peer_time: + return False + self.permit_onion_peer_time = now + random.randrange(0, 1200) + return True + + async def _import_peers(self): + '''Import hard-coded peers from a file or the coin defaults.''' + imported_peers = self.myselves.copy() + # Add the hard-coded ones unless only reporting ourself + if self.env.peer_discovery != self.env.PD_SELF: + imported_peers.extend(Peer.from_real_name(real_name, 'coins.py') + for real_name in self.env.coin.PEERS) + await self._note_peers(imported_peers, limit=None) + + async def _detect_proxy(self): + '''Detect a proxy if we don't have one and some time has passed since + the last attempt. + + If found self.proxy is set to a SOCKSProxy instance, otherwise + None. + ''' + host = self.env.tor_proxy_host + if self.env.tor_proxy_port is None: + ports = [9050, 9150, 1080] + else: + ports = [self.env.tor_proxy_port] + while True: + self.logger.info(f'trying to detect proxy on "{host}" ' + f'ports {ports}') + proxy = await SOCKSProxy.auto_detect_host(host, ports, None) + if proxy: + self.proxy = proxy + self.logger.info(f'detected {proxy}') + return + self.logger.info('no proxy detected, will try later') + await sleep(900) + + async def _note_peers(self, peers, limit=2, check_ports=False, + source=None): + '''Add a limited number of peers that are not already present.''' + new_peers = [] + for peer in peers: + if not peer.is_public or (peer.is_tor and not self.proxy): + continue + + matches = peer.matches(self.peers) + if not matches: + new_peers.append(peer) + elif check_ports: + for match in matches: + if match.check_ports(peer): + self.logger.info(f'ports changed for {peer}') + match.retry_event.set() + + if new_peers: + source = source or new_peers[0].source + if limit: + random.shuffle(new_peers) + use_peers = new_peers[:limit] + else: + use_peers = new_peers + for peer in use_peers: + self.logger.info(f'accepted new peer {peer} from {source}') + peer.retry_event = Event() + self.peers.add(peer) + await self.group.spawn(self._monitor_peer(peer)) + + async def _monitor_peer(self, peer): + # Stop monitoring if we were dropped (a duplicate peer) + while peer in self.peers: + if await self._should_drop_peer(peer): + self.peers.discard(peer) + break + # Figure out how long to sleep before retrying. Retry a + # good connection when it is about to turn stale, otherwise + # exponentially back off retries. + if peer.try_count == 0: + pause = STALE_SECS - WAKEUP_SECS * 2 + else: + pause = WAKEUP_SECS * 2 ** peer.try_count + async with ignore_after(pause): + await peer.retry_event.wait() + peer.retry_event.clear() + + async def _should_drop_peer(self, peer): + peer.try_count += 1 + is_good = False + for kind, port in peer.connection_port_pairs(): + peer.last_try = time.time() + + kwargs = {} + if kind == 'SSL': + kwargs['ssl'] = ssl.SSLContext(ssl.PROTOCOL_TLS) + + host = self.env.cs_host(for_rpc=False) + if isinstance(host, list): + host = host[0] + + if self.env.force_proxy or peer.is_tor: + if not self.proxy: + return + kwargs['proxy'] = self.proxy + kwargs['resolve'] = not peer.is_tor + elif host: + # Use our listening Host/IP for outgoing non-proxy + # connections so our peers see the correct source. + kwargs['local_addr'] = (host, None) + + peer_text = f'[{peer}:{port} {kind}]' + try: + async with timeout_after(120 if peer.is_tor else 30): + async with Connector(PeerSession, peer.host, port, + **kwargs) as session: + await self._verify_peer(session, peer) + is_good = True + break + except BadPeerError as e: + self.logger.error(f'{peer_text} marking bad: ({e})') + peer.mark_bad() + break + except RPCError as e: + self.logger.error(f'{peer_text} RPC error: {e.message} ' + f'({e.code})') + except (OSError, SOCKSError, ConnectionError, TaskTimeout) as e: + self.logger.info(f'{peer_text} {e}') + + if is_good: + now = time.time() + elapsed = now - peer.last_try + self.logger.info(f'{peer_text} verified in {elapsed:.1f}s') + peer.try_count = 0 + peer.last_good = now + peer.source = 'peer' + # At most 2 matches if we're a host name, potentially + # several if we're an IP address (several instances + # can share a NAT). + matches = peer.matches(self.peers) + for match in matches: + if match.ip_address: + if len(matches) > 1: + self.peers.remove(match) + # Force the peer's monitoring task to exit + match.retry_event.set() + elif peer.host in match.features['hosts']: + match.update_features_from_peer(peer) + else: + # Forget the peer if long-term unreachable + if peer.last_good and not peer.bad: + try_limit = 10 + else: + try_limit = 3 + if peer.try_count >= try_limit: + desc = 'bad' if peer.bad else 'unreachable' + self.logger.info(f'forgetting {desc} peer: {peer}') + return True + return False + + async def _verify_peer(self, session, peer): + if not peer.is_tor: + address = session.peer_address() + if address: + peer.ip_addr = address[0] + + # server.version goes first + message = 'server.version' + result = await session.send_request(message, self.server_version_args) + assert_good(message, result, list) + + # Protocol version 1.1 returns a pair with the version first + if len(result) != 2 or not all(isinstance(x, str) for x in result): + raise BadPeerError(f'bad server.version result: {result}') + server_version, protocol_version = result + peer.server_version = server_version + peer.features['server_version'] = server_version + ptuple = protocol_tuple(protocol_version) + + async with TaskGroup() as g: + await g.spawn(self._send_headers_subscribe(session, peer, ptuple)) + await g.spawn(self._send_server_features(session, peer)) + await g.spawn(self._send_peers_subscribe(session, peer)) + + async def _send_headers_subscribe(self, session, peer, ptuple): + message = 'blockchain.headers.subscribe' + result = await session.send_request(message) + assert_good(message, result, dict) + + our_height = self.db.db_height + if ptuple < (1, 3): + their_height = result.get('block_height') + else: + their_height = result.get('height') + if not isinstance(their_height, int): + raise BadPeerError(f'invalid height {their_height}') + if abs(our_height - their_height) > 5: + raise BadPeerError(f'bad height {their_height:,d} ' + f'(ours: {our_height:,d})') + + # Check prior header too in case of hard fork. + check_height = min(our_height, their_height) + raw_header = await self.db.raw_header(check_height) + if ptuple >= (1, 4): + ours = raw_header.hex() + message = 'blockchain.block.header' + theirs = await session.send_request(message, [check_height]) + assert_good(message, theirs, str) + if ours != theirs: + raise BadPeerError(f'our header {ours} and ' + f'theirs {theirs} differ') + else: + ours = self.env.coin.electrum_header(raw_header, check_height) + ours = ours.get('prev_block_hash') + message = 'blockchain.block.get_header' + theirs = await session.send_request(message, [check_height]) + assert_good(message, theirs, dict) + theirs = theirs.get('prev_block_hash') + if ours != theirs: + raise BadPeerError(f'our header hash {ours} and ' + f'theirs {theirs} differ') + + async def _send_server_features(self, session, peer): + message = 'server.features' + features = await session.send_request(message) + assert_good(message, features, dict) + hosts = [host.lower() for host in features.get('hosts', {})] + if self.env.coin.GENESIS_HASH != features.get('genesis_hash'): + raise BadPeerError('incorrect genesis hash') + elif peer.host.lower() in hosts: + peer.update_features(features) + else: + raise BadPeerError(f'not listed in own hosts list {hosts}') + + async def _send_peers_subscribe(self, session, peer): + message = 'server.peers.subscribe' + raw_peers = await session.send_request(message) + assert_good(message, raw_peers, list) + + # Check the peers list we got from a remote peer. + # Each is expected to be of the form: + # [ip_addr, hostname, ['v1.0', 't51001', 's51002']] + # Call add_peer if the remote doesn't appear to know about us. + try: + real_names = [' '.join([u[1]] + u[2]) for u in raw_peers] + peers = [Peer.from_real_name(real_name, str(peer)) + for real_name in real_names] + except Exception: + raise BadPeerError('bad server.peers.subscribe response') + + await self._note_peers(peers) + features = self._features_to_register(peer, peers) + if not features: + return + self.logger.info(f'registering ourself with {peer}') + # We only care to wait for the response + await session.send_request('server.add_peer', [features]) + + # + # External interface + # + async def discover_peers(self): + '''Perform peer maintenance. This includes + + 1) Forgetting unreachable peers. + 2) Verifying connectivity of new peers. + 3) Retrying old peers at regular intervals. + ''' + if self.env.peer_discovery != self.env.PD_ON: + self.logger.info('peer discovery is disabled') + return + + self.logger.info(f'beginning peer discovery. Force use of ' + f'proxy: {self.env.force_proxy}') + forever = Event() + async with self.group as group: + await group.spawn(forever.wait()) + await group.spawn(self._detect_proxy()) + await group.spawn(self._import_peers()) + # Consume tasks as they complete, logging unexpected failures + async for task in group: + if not task.cancelled(): + try: + task.result() + except Exception: + self.logger.exception('task failed unexpectedly') + + def info(self): + '''The number of peers.''' + self._set_peer_statuses() + counter = Counter(peer.status for peer in self.peers) + return { + 'bad': counter[PEER_BAD], + 'good': counter[PEER_GOOD], + 'never': counter[PEER_NEVER], + 'stale': counter[PEER_STALE], + 'total': len(self.peers), + } + + async def add_localRPC_peer(self, real_name): + '''Add a peer passed by the admin over LocalRPC.''' + await self._note_peers([Peer.from_real_name(real_name, 'RPC')]) + + async def on_add_peer(self, features, source_info): + '''Add a peer (but only if the peer resolves to the source).''' + if not source_info: + self.logger.info('ignored add_peer request: no source info') + return False + source = source_info[0] + peers = Peer.peers_from_features(features, source) + if not peers: + self.logger.info('ignored add_peer request: no peers given') + return False + + # Just look at the first peer, require it + peer = peers[0] + host = peer.host + if peer.is_tor: + permit = self._permit_new_onion_peer() + reason = 'rate limiting' + else: + getaddrinfo = asyncio.get_event_loop().getaddrinfo + try: + infos = await getaddrinfo(host, 80, type=socket.SOCK_STREAM) + except socket.gaierror: + permit = False + reason = 'address resolution failure' + else: + permit = any(source == info[-1][0] for info in infos) + reason = 'source-destination mismatch' + + if permit: + self.logger.info(f'accepted add_peer request from {source} ' + f'for {host}') + await self._note_peers([peer], check_ports=True) + else: + self.logger.warning(f'rejected add_peer request from {source} ' + f'for {host} ({reason})') + + return permit + + def on_peers_subscribe(self, is_tor): + '''Returns the server peers as a list of (ip, host, details) tuples. + + We return all peers we've connected to in the last day. + Additionally, if we don't have onion routing, we return a few + hard-coded onion servers. + ''' + cutoff = time.time() - STALE_SECS + recent = [peer for peer in self.peers + if peer.last_good > cutoff and + not peer.bad and peer.is_public] + onion_peers = [] + + # Always report ourselves if valid (even if not public) + peers = set(myself for myself in self.myselves + if myself.last_good > cutoff) + + # Bucket the clearnet peers and select up to two from each + buckets = defaultdict(list) + for peer in recent: + if peer.is_tor: + onion_peers.append(peer) + else: + buckets[peer.bucket()].append(peer) + for bucket_peers in buckets.values(): + random.shuffle(bucket_peers) + peers.update(bucket_peers[:2]) + + # Add up to 20% onion peers (but up to 10 is OK anyway) + random.shuffle(onion_peers) + max_onion = 50 if is_tor else max(10, len(peers) // 4) + + peers.update(onion_peers[:max_onion]) + + return [peer.to_tuple() for peer in peers] + + def proxy_peername(self): + '''Return the peername of the proxy, if there is a proxy, otherwise + None.''' + return self.proxy.peername if self.proxy else None + + def rpc_data(self): + '''Peer data for the peers RPC method.''' + self._set_peer_statuses() + descs = ['good', 'stale', 'never', 'bad'] + + def peer_data(peer): + data = peer.serialize() + data['status'] = descs[peer.status] + return data + + def peer_key(peer): + return (peer.bad, -peer.last_good) + + return [peer_data(peer) for peer in sorted(self.peers, key=peer_key)] diff --git a/torba/server/script.py b/torba/server/script.py new file mode 100644 index 000000000..9ff0047d6 --- /dev/null +++ b/torba/server/script.py @@ -0,0 +1,251 @@ +# Copyright (c) 2016-2017, Neil Booth +# +# All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# and warranty status of this software. + +'''Script-related classes and functions.''' + + +import struct +from collections import namedtuple + +from torba.server.enum import Enumeration +from torba.server.hash import hash160 +from torba.server.util import unpack_le_uint16_from, unpack_le_uint32_from, \ + pack_le_uint16, pack_le_uint32 + + +class ScriptError(Exception): + '''Exception used for script errors.''' + + +OpCodes = Enumeration("Opcodes", [ + ("OP_0", 0), ("OP_PUSHDATA1", 76), + "OP_PUSHDATA2", "OP_PUSHDATA4", "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" +]) + + +# Paranoia to make it hard to create bad scripts +assert OpCodes.OP_DUP == 0x76 +assert OpCodes.OP_HASH160 == 0xa9 +assert OpCodes.OP_EQUAL == 0x87 +assert OpCodes.OP_EQUALVERIFY == 0x88 +assert OpCodes.OP_CHECKSIG == 0xac +assert OpCodes.OP_CHECKMULTISIG == 0xae + + +def _match_ops(ops, pattern): + if len(ops) != len(pattern): + return False + for op, pop in zip(ops, pattern): + if pop != op: + # -1 means 'data push', whose op is an (op, data) tuple + if pop == -1 and isinstance(op, tuple): + continue + return False + + return True + + +class ScriptPubKey(object): + '''A class for handling a tx output script that gives conditions + necessary for spending. + ''' + + TO_ADDRESS_OPS = [OpCodes.OP_DUP, OpCodes.OP_HASH160, -1, + OpCodes.OP_EQUALVERIFY, OpCodes.OP_CHECKSIG] + TO_P2SH_OPS = [OpCodes.OP_HASH160, -1, OpCodes.OP_EQUAL] + TO_PUBKEY_OPS = [-1, OpCodes.OP_CHECKSIG] + + PayToHandlers = namedtuple('PayToHandlers', 'address script_hash pubkey ' + 'unspendable strange') + + @classmethod + def pay_to(cls, handlers, script): + '''Parse a script, invoke the appropriate handler and + return the result. + + One of the following handlers is invoked: + handlers.address(hash160) + handlers.script_hash(hash160) + handlers.pubkey(pubkey) + handlers.unspendable() + handlers.strange(script) + ''' + try: + ops = Script.get_ops(script) + except ScriptError: + return handlers.unspendable() + + match = _match_ops + + if match(ops, cls.TO_ADDRESS_OPS): + return handlers.address(ops[2][-1]) + if match(ops, cls.TO_P2SH_OPS): + return handlers.script_hash(ops[1][-1]) + if match(ops, cls.TO_PUBKEY_OPS): + return handlers.pubkey(ops[0][-1]) + if ops and ops[0] == OpCodes.OP_RETURN: + return handlers.unspendable() + return handlers.strange(script) + + @classmethod + def P2SH_script(cls, hash160): + return (bytes([OpCodes.OP_HASH160]) + + Script.push_data(hash160) + + bytes([OpCodes.OP_EQUAL])) + + @classmethod + def P2PKH_script(cls, hash160): + return (bytes([OpCodes.OP_DUP, OpCodes.OP_HASH160]) + + Script.push_data(hash160) + + bytes([OpCodes.OP_EQUALVERIFY, OpCodes.OP_CHECKSIG])) + + @classmethod + def validate_pubkey(cls, pubkey, req_compressed=False): + if isinstance(pubkey, (bytes, bytearray)): + if len(pubkey) == 33 and pubkey[0] in (2, 3): + return # Compressed + if len(pubkey) == 65 and pubkey[0] == 4: + if not req_compressed: + return + raise PubKeyError('uncompressed pubkeys are invalid') + raise PubKeyError('invalid pubkey {}'.format(pubkey)) + + @classmethod + def pubkey_script(cls, pubkey): + cls.validate_pubkey(pubkey) + return Script.push_data(pubkey) + bytes([OpCodes.OP_CHECKSIG]) + + @classmethod + def multisig_script(cls, m, pubkeys): + '''Returns the script for a pay-to-multisig transaction.''' + n = len(pubkeys) + if not 1 <= m <= n <= 15: + raise ScriptError('{:d} of {:d} multisig script not possible' + .format(m, n)) + for pubkey in pubkeys: + cls.validate_pubkey(pubkey, req_compressed=True) + # See https://bitcoin.org/en/developer-guide + # 2 of 3 is: OP_2 pubkey1 pubkey2 pubkey3 OP_3 OP_CHECKMULTISIG + return (bytes([OP_1 + m - 1]) + + b''.join(cls.push_data(pubkey) for pubkey in pubkeys) + + bytes([OP_1 + n - 1, OP_CHECK_MULTISIG])) + + +class Script(object): + + @classmethod + def get_ops(cls, script): + ops = [] + + # The unpacks or script[n] below throw on truncated scripts + try: + n = 0 + while n < len(script): + op = script[n] + n += 1 + + if op <= OpCodes.OP_PUSHDATA4: + # Raw bytes follow + if op < OpCodes.OP_PUSHDATA1: + dlen = op + elif op == OpCodes.OP_PUSHDATA1: + dlen = script[n] + n += 1 + elif op == OpCodes.OP_PUSHDATA2: + dlen, = unpack_le_uint16_from(script[n: n + 2]) + n += 2 + else: + dlen, = unpack_le_uint32_from(script[n: n + 4]) + n += 4 + if n + dlen > len(script): + raise IndexError + op = (op, script[n:n + dlen]) + n += dlen + + ops.append(op) + except Exception: + # Truncated script; e.g. tx_hash + # ebc9fa1196a59e192352d76c0f6e73167046b9d37b8302b6bb6968dfd279b767 + raise ScriptError('truncated script') + + return ops + + @classmethod + def push_data(cls, data): + '''Returns the opcodes to push the data on the stack.''' + assert isinstance(data, (bytes, bytearray)) + + n = len(data) + if n < OpCodes.OP_PUSHDATA1: + return bytes([n]) + data + if n < 256: + return bytes([OpCodes.OP_PUSHDATA1, n]) + data + if n < 65536: + return bytes([OpCodes.OP_PUSHDATA2]) + pack_le_uint16(n) + data + return bytes([OpCodes.OP_PUSHDATA4]) + pack_le_uint32(n) + data + + @classmethod + def opcode_name(cls, opcode): + if OpCodes.OP_0 < opcode < OpCodes.OP_PUSHDATA1: + return 'OP_{:d}'.format(opcode) + try: + return OpCodes.whatis(opcode) + except KeyError: + return 'OP_UNKNOWN:{:d}'.format(opcode) + + @classmethod + def dump(cls, script): + opcodes, datas = cls.get_ops(script) + for opcode, data in zip(opcodes, datas): + name = cls.opcode_name(opcode) + if data is None: + print(name) + else: + print('{} {} ({:d} bytes)' + .format(name, data.hex(), len(data))) diff --git a/torba/server/server.py b/torba/server/server.py new file mode 100644 index 000000000..5b22e6b7e --- /dev/null +++ b/torba/server/server.py @@ -0,0 +1,129 @@ +import signal +import time +import logging +from functools import partial +import asyncio + +import torba +from torba.server.db import DB +from torba.server.mempool import MemPool, MemPoolAPI +from torba.server.session import SessionManager + + +class Notifications: + # hashX notifications come from two sources: new blocks and + # mempool refreshes. + # + # A user with a pending transaction is notified after the block it + # gets in is processed. Block processing can take an extended + # time, and the prefetcher might poll the daemon after the mempool + # code in any case. In such cases the transaction will not be in + # the mempool after the mempool refresh. We want to avoid + # notifying clients twice - for the mempool refresh and when the + # block is done. This object handles that logic by deferring + # notifications appropriately. + + def __init__(self): + self._touched_mp = {} + self._touched_bp = {} + self._highest_block = -1 + + async def _maybe_notify(self): + tmp, tbp = self._touched_mp, self._touched_bp + common = set(tmp).intersection(tbp) + if common: + height = max(common) + elif tmp and max(tmp) == self._highest_block: + height = self._highest_block + else: + # Either we are processing a block and waiting for it to + # come in, or we have not yet had a mempool update for the + # new block height + return + touched = tmp.pop(height) + for old in [h for h in tmp if h <= height]: + del tmp[old] + for old in [h for h in tbp if h <= height]: + touched.update(tbp.pop(old)) + await self.notify(height, touched) + + async def notify(self, height, touched): + pass + + async def start(self, height, notify_func): + self._highest_block = height + self.notify = notify_func + await self.notify(height, set()) + + async def on_mempool(self, touched, height): + self._touched_mp[height] = touched + await self._maybe_notify() + + async def on_block(self, touched, height): + self._touched_bp[height] = touched + self._highest_block = height + await self._maybe_notify() + + +class Server: + + def __init__(self, env): + self.env = env + self.log = logging.getLogger(__name__).getChild(self.__class__.__name__) + self.shutdown_event = asyncio.Event() + self.cancellable_tasks = [] + + async def start(self): + env = self.env + min_str, max_str = env.coin.SESSIONCLS.protocol_min_max_strings() + self.log.info(f'software version: {torba.__version__}') + self.log.info(f'supported protocol versions: {min_str}-{max_str}') + self.log.info(f'event loop policy: {env.loop_policy}') + self.log.info(f'reorg limit is {env.reorg_limit:,d} blocks') + + notifications = Notifications() + Daemon = env.coin.DAEMON + BlockProcessor = env.coin.BLOCK_PROCESSOR + + daemon = Daemon(env.coin, env.daemon_url) + db = DB(env) + bp = BlockProcessor(env, db, daemon, notifications) + + # Set notifications up to implement the MemPoolAPI + notifications.height = daemon.height + notifications.cached_height = daemon.cached_height + notifications.mempool_hashes = daemon.mempool_hashes + notifications.raw_transactions = daemon.getrawtransactions + notifications.lookup_utxos = db.lookup_utxos + MemPoolAPI.register(Notifications) + mempool = MemPool(env.coin, notifications) + + session_mgr = SessionManager( + env, db, bp, daemon, mempool, self.shutdown_event + ) + + await daemon.height() + + def _start_cancellable(run, *args): + _flag = asyncio.Event() + self.cancellable_tasks.append(asyncio.ensure_future(run(*args, _flag))) + return _flag.wait() + + await _start_cancellable(bp.fetch_and_process_blocks) + await db.populate_header_merkle_cache() + await _start_cancellable(mempool.keep_synchronized) + await _start_cancellable(session_mgr.serve, notifications) + + def stop(self): + for task in reversed(self.cancellable_tasks): + task.cancel() + + def run(self): + loop = asyncio.get_event_loop() + try: + loop.add_signal_handler(signal.SIGINT, self.stop) + loop.add_signal_handler(signal.SIGTERM, self.stop) + loop.run_until_complete(self.start()) + loop.run_forever() + finally: + loop.run_until_complete(loop.shutdown_asyncgens()) diff --git a/torba/server/session.py b/torba/server/session.py new file mode 100644 index 000000000..787302075 --- /dev/null +++ b/torba/server/session.py @@ -0,0 +1,1436 @@ +# Copyright (c) 2016-2018, Neil Booth +# +# All rights reserved. +# +# See the file "LICENCE" for information about the copyright +# and warranty status of this software. + +'''Classes for local RPC server and remote client TCP/SSL servers.''' + +import asyncio +import codecs +import datetime +import itertools +import json +import os +import pylru +import ssl +import time +from collections import defaultdict +from functools import partial + +from aiorpcx import ( + RPCSession, JSONRPCAutoDetect, JSONRPCConnection, + TaskGroup, handler_invocation, RPCError, Request, ignore_after, sleep, + Event +) + +import torba +import torba.server.text as text +import torba.server.util as util +from torba.server.hash import (sha256, hash_to_hex_str, hex_str_to_hash, + HASHX_LEN, Base58Error) +from torba.server.peer import Peer +from torba.server.daemon import DaemonError +from torba.server.peers import PeerManager + + +BAD_REQUEST = 1 +DAEMON_ERROR = 2 + + +def scripthash_to_hashX(scripthash): + try: + bin_hash = hex_str_to_hash(scripthash) + if len(bin_hash) == 32: + return bin_hash[:HASHX_LEN] + except Exception: + pass + raise RPCError(BAD_REQUEST, f'{scripthash} is not a valid script hash') + + +def non_negative_integer(value): + '''Return param value it is or can be converted to a non-negative + integer, otherwise raise an RPCError.''' + try: + value = int(value) + if value >= 0: + return value + except ValueError: + pass + raise RPCError(BAD_REQUEST, + f'{value} should be a non-negative integer') + + +def assert_boolean(value): + '''Return param value it is boolean otherwise raise an RPCError.''' + if value in (False, True): + return value + raise RPCError(BAD_REQUEST, f'{value} should be a boolean value') + + +def assert_tx_hash(value): + '''Raise an RPCError if the value is not a valid transaction + hash.''' + try: + if len(util.hex_to_bytes(value)) == 32: + return + except Exception: + pass + raise RPCError(BAD_REQUEST, f'{value} should be a transaction hash') + + +class Semaphores(object): + '''For aiorpcX's semaphore handling.''' + + def __init__(self, semaphores): + self.semaphores = semaphores + self.acquired = [] + + async def __aenter__(self): + for semaphore in self.semaphores: + await semaphore.acquire() + self.acquired.append(semaphore) + + async def __aexit__(self, exc_type, exc_value, traceback): + for semaphore in self.acquired: + semaphore.release() + + +class SessionGroup(object): + + def __init__(self, gid): + self.gid = gid + # Concurrency per group + self.semaphore = asyncio.Semaphore(20) + + +class SessionManager(object): + '''Holds global state about all sessions.''' + + def __init__(self, env, db, bp, daemon, mempool, shutdown_event): + env.max_send = max(350000, env.max_send) + self.env = env + self.db = db + self.bp = bp + self.daemon = daemon + self.mempool = mempool + self.peer_mgr = PeerManager(env, db) + self.shutdown_event = shutdown_event + self.logger = util.class_logger(__name__, self.__class__.__name__) + self.servers = {} + self.sessions = set() + self.max_subs = env.max_subs + self.cur_group = SessionGroup(0) + self.txs_sent = 0 + self.start_time = time.time() + self.history_cache = pylru.lrucache(256) + self.notified_height = None + # Cache some idea of room to avoid recounting on each subscription + self.subs_room = 0 + # Masternode stuff only for such coins + if issubclass(env.coin.SESSIONCLS, DashElectrumX): + self.mn_cache_height = 0 + self.mn_cache = [] + + self.session_event = Event() + + # Set up the RPC request handlers + cmds = ('add_peer daemon_url disconnect getinfo groups log peers ' + 'query reorg sessions stop'.split()) + LocalRPC.request_handlers = {cmd: getattr(self, 'rpc_' + cmd) + for cmd in cmds} + + async def _start_server(self, kind, *args, **kw_args): + loop = asyncio.get_event_loop() + if kind == 'RPC': + protocol_class = LocalRPC + else: + protocol_class = self.env.coin.SESSIONCLS + protocol_factory = partial(protocol_class, self, self.db, + self.mempool, self.peer_mgr, kind) + server = loop.create_server(protocol_factory, *args, **kw_args) + + host, port = args[:2] + try: + self.servers[kind] = await server + except OSError as e: # don't suppress CancelledError + self.logger.error(f'{kind} server failed to listen on {host}:' + f'{port:d} :{e!r}') + else: + self.logger.info(f'{kind} server listening on {host}:{port:d}') + + async def _start_external_servers(self): + '''Start listening on TCP and SSL ports, but only if the respective + port was given in the environment. + ''' + env = self.env + host = env.cs_host(for_rpc=False) + if env.tcp_port is not None: + await self._start_server('TCP', host, env.tcp_port) + if env.ssl_port is not None: + sslc = ssl.SSLContext(ssl.PROTOCOL_TLS) + sslc.load_cert_chain(env.ssl_certfile, keyfile=env.ssl_keyfile) + await self._start_server('SSL', host, env.ssl_port, ssl=sslc) + + async def _close_servers(self, kinds): + '''Close the servers of the given kinds (TCP etc.).''' + if kinds: + self.logger.info('closing down {} listening servers' + .format(', '.join(kinds))) + for kind in kinds: + server = self.servers.pop(kind, None) + if server: + server.close() + await server.wait_closed() + + async def _manage_servers(self): + paused = False + max_sessions = self.env.max_sessions + low_watermark = max_sessions * 19 // 20 + while True: + await self.session_event.wait() + self.session_event.clear() + if not paused and len(self.sessions) >= max_sessions: + self.logger.info(f'maximum sessions {max_sessions:,d} ' + f'reached, stopping new connections until ' + f'count drops to {low_watermark:,d}') + await self._close_servers(['TCP', 'SSL']) + paused = True + # Start listening for incoming connections if paused and + # session count has fallen + if paused and len(self.sessions) <= low_watermark: + self.logger.info('resuming listening for incoming connections') + await self._start_external_servers() + paused = False + + async def _log_sessions(self): + '''Periodically log sessions.''' + log_interval = self.env.log_sessions + if log_interval: + while True: + await sleep(log_interval) + data = self._session_data(for_log=True) + for line in text.sessions_lines(data): + self.logger.info(line) + self.logger.info(json.dumps(self._get_info())) + + def _group_map(self): + group_map = defaultdict(list) + for session in self.sessions: + group_map[session.group].append(session) + return group_map + + def _sub_count(self): + return sum(s.sub_count() for s in self.sessions) + + def _lookup_session(self, session_id): + try: + session_id = int(session_id) + except Exception: + pass + else: + for session in self.sessions: + if session.session_id == session_id: + return session + return None + + async def _for_each_session(self, session_ids, operation): + if not isinstance(session_ids, list): + raise RPCError(BAD_REQUEST, 'expected a list of session IDs') + + result = [] + for session_id in session_ids: + session = self._lookup_session(session_id) + if session: + result.append(await operation(session)) + else: + result.append(f'unknown session: {session_id}') + return result + + async def _clear_stale_sessions(self): + '''Cut off sessions that haven't done anything for 10 minutes.''' + while True: + await sleep(60) + stale_cutoff = time.time() - self.env.session_timeout + stale_sessions = [session for session in self.sessions + if session.last_recv < stale_cutoff] + if stale_sessions: + text = ', '.join(str(session.session_id) + for session in stale_sessions) + self.logger.info(f'closing stale connections {text}') + # Give the sockets some time to close gracefully + async with TaskGroup() as group: + for session in stale_sessions: + await group.spawn(session.close()) + + # Consolidate small groups + bw_limit = self.env.bandwidth_limit + group_map = self._group_map() + groups = [group for group, sessions in group_map.items() + if len(sessions) <= 5 and + sum(s.bw_charge for s in sessions) < bw_limit] + if len(groups) > 1: + new_group = groups[-1] + for group in groups: + for session in group_map[group]: + session.group = new_group + + def _get_info(self): + '''A summary of server state.''' + group_map = self._group_map() + return { + 'closing': len([s for s in self.sessions if s.is_closing()]), + 'daemon': self.daemon.logged_url(), + 'daemon_height': self.daemon.cached_height(), + 'db_height': self.db.db_height, + 'errors': sum(s.errors for s in self.sessions), + 'groups': len(group_map), + 'logged': len([s for s in self.sessions if s.log_me]), + 'paused': sum(not s.can_send.is_set() for s in self.sessions), + 'pid': os.getpid(), + 'peers': self.peer_mgr.info(), + 'requests': sum(s.count_pending_items() for s in self.sessions), + 'sessions': self.session_count(), + 'subs': self._sub_count(), + 'txs_sent': self.txs_sent, + 'uptime': util.formatted_time(time.time() - self.start_time), + 'version': torba.__version__, + } + + def _session_data(self, for_log): + '''Returned to the RPC 'sessions' call.''' + now = time.time() + sessions = sorted(self.sessions, key=lambda s: s.start_time) + return [(session.session_id, + session.flags(), + session.peer_address_str(for_log=for_log), + session.client, + session.protocol_version_string(), + session.count_pending_items(), + session.txs_sent, + session.sub_count(), + session.recv_count, session.recv_size, + session.send_count, session.send_size, + now - session.start_time) + for session in sessions] + + def _group_data(self): + '''Returned to the RPC 'groups' call.''' + result = [] + group_map = self._group_map() + for group, sessions in group_map.items(): + result.append([group.gid, + len(sessions), + sum(s.bw_charge for s in sessions), + sum(s.count_pending_items() for s in sessions), + sum(s.txs_sent for s in sessions), + sum(s.sub_count() for s in sessions), + sum(s.recv_count for s in sessions), + sum(s.recv_size for s in sessions), + sum(s.send_count for s in sessions), + sum(s.send_size for s in sessions), + ]) + return result + + async def _electrum_and_raw_headers(self, height): + raw_header = await self.raw_header(height) + electrum_header = self.env.coin.electrum_header(raw_header, height) + return electrum_header, raw_header + + async def _refresh_hsub_results(self, height): + '''Refresh the cached header subscription responses to be for height, + and record that as notified_height. + ''' + # Paranoia: a reorg could race and leave db_height lower + height = min(height, self.db.db_height) + electrum, raw = await self._electrum_and_raw_headers(height) + self.hsub_results = (electrum, {'hex': raw.hex(), 'height': height}) + self.notified_height = height + + # --- LocalRPC command handlers + + async def rpc_add_peer(self, real_name): + '''Add a peer. + + real_name: "bch.electrumx.cash t50001 s50002" for example + ''' + await self.peer_mgr.add_localRPC_peer(real_name) + return "peer '{}' added".format(real_name) + + async def rpc_disconnect(self, session_ids): + '''Disconnect sesssions. + + session_ids: array of session IDs + ''' + async def close(session): + '''Close the session's transport.''' + await session.close(force_after=2) + return f'disconnected {session.session_id}' + + return await self._for_each_session(session_ids, close) + + async def rpc_log(self, session_ids): + '''Toggle logging of sesssions. + + session_ids: array of session IDs + ''' + async def toggle_logging(session): + '''Toggle logging of the session.''' + session.toggle_logging() + return f'log {session.session_id}: {session.log_me}' + + return await self._for_each_session(session_ids, toggle_logging) + + async def rpc_daemon_url(self, daemon_url): + '''Replace the daemon URL.''' + daemon_url = daemon_url or self.env.daemon_url + try: + self.daemon.set_url(daemon_url) + except Exception as e: + raise RPCError(BAD_REQUEST, f'an error occured: {e!r}') + return f'now using daemon at {self.daemon.logged_url()}' + + async def rpc_stop(self): + '''Shut down the server cleanly.''' + self.shutdown_event.set() + return 'stopping' + + async def rpc_getinfo(self): + '''Return summary information about the server process.''' + return self._get_info() + + async def rpc_groups(self): + '''Return statistics about the session groups.''' + return self._group_data() + + async def rpc_peers(self): + '''Return a list of data about server peers.''' + return self.peer_mgr.rpc_data() + + async def rpc_query(self, items, limit): + '''Return a list of data about server peers.''' + coin = self.env.coin + db = self.db + lines = [] + + def arg_to_hashX(arg): + try: + script = bytes.fromhex(arg) + lines.append(f'Script: {arg}') + return coin.hashX_from_script(script) + except ValueError: + pass + + try: + hashX = coin.address_to_hashX(arg) + except Base58Error as e: + lines.append(e.args[0]) + return None + lines.append(f'Address: {arg}') + return hashX + + for arg in items: + hashX = arg_to_hashX(arg) + if not hashX: + continue + n = None + history = await db.limited_history(hashX, limit=limit) + for n, (tx_hash, height) in enumerate(history): + lines.append(f'History #{n:,d}: height {height:,d} ' + f'tx_hash {hash_to_hex_str(tx_hash)}') + if n is None: + lines.append('No history found') + n = None + utxos = await db.all_utxos(hashX) + for n, utxo in enumerate(utxos, start=1): + lines.append(f'UTXO #{n:,d}: tx_hash ' + f'{hash_to_hex_str(utxo.tx_hash)} ' + f'tx_pos {utxo.tx_pos:,d} height ' + f'{utxo.height:,d} value {utxo.value:,d}') + if n == limit: + break + if n is None: + lines.append('No UTXOs found') + + balance = sum(utxo.value for utxo in utxos) + lines.append(f'Balance: {coin.decimal_value(balance):,f} ' + f'{coin.SHORTNAME}') + + return lines + + async def rpc_sessions(self): + '''Return statistics about connected sessions.''' + return self._session_data(for_log=False) + + async def rpc_reorg(self, count): + '''Force a reorg of the given number of blocks. + + count: number of blocks to reorg + ''' + count = non_negative_integer(count) + if not self.bp.force_chain_reorg(count): + raise RPCError(BAD_REQUEST, 'still catching up with daemon') + return f'scheduled a reorg of {count:,d} blocks' + + # --- External Interface + + async def serve(self, notifications, server_listening_event): + '''Start the RPC server if enabled. When the event is triggered, + start TCP and SSL servers.''' + try: + if self.env.rpc_port is not None: + await self._start_server('RPC', self.env.cs_host(for_rpc=True), + self.env.rpc_port) + self.logger.info(f'max session count: {self.env.max_sessions:,d}') + self.logger.info(f'session timeout: ' + f'{self.env.session_timeout:,d} seconds') + self.logger.info('session bandwidth limit {:,d} bytes' + .format(self.env.bandwidth_limit)) + self.logger.info('max response size {:,d} bytes' + .format(self.env.max_send)) + self.logger.info('max subscriptions across all sessions: {:,d}' + .format(self.max_subs)) + self.logger.info('max subscriptions per session: {:,d}' + .format(self.env.max_session_subs)) + if self.env.drop_client is not None: + self.logger.info('drop clients matching: {}' + .format(self.env.drop_client.pattern)) + # Start notifications; initialize hsub_results + await notifications.start(self.db.db_height, self._notify_sessions) + await self._start_external_servers() + server_listening_event.set() + # Peer discovery should start after the external servers + # because we connect to ourself + async with TaskGroup() as group: + await group.spawn(self.peer_mgr.discover_peers()) + await group.spawn(self._clear_stale_sessions()) + await group.spawn(self._log_sessions()) + await group.spawn(self._manage_servers()) + finally: + # Close servers and sessions + await self._close_servers(list(self.servers.keys())) + async with TaskGroup() as group: + for session in list(self.sessions): + await group.spawn(session.close(force_after=1)) + + def session_count(self): + '''The number of connections that we've sent something to.''' + return len(self.sessions) + + async def daemon_request(self, method, *args): + '''Catch a DaemonError and convert it to an RPCError.''' + try: + return await getattr(self.daemon, method)(*args) + except DaemonError as e: + raise RPCError(DAEMON_ERROR, f'daemon error: {e!r}') from None + + async def raw_header(self, height): + '''Return the binary header at the given height.''' + try: + return await self.db.raw_header(height) + except IndexError: + raise RPCError(BAD_REQUEST, f'height {height:,d} ' + 'out of range') from None + + async def electrum_header(self, height): + '''Return the deserialized header at the given height.''' + electrum_header, _ = await self._electrum_and_raw_headers(height) + return electrum_header + + async def broadcast_transaction(self, raw_tx): + hex_hash = await self.daemon.broadcast_transaction(raw_tx) + self.txs_sent += 1 + return hex_hash + + async def limited_history(self, hashX): + '''A caching layer.''' + hc = self.history_cache + if hashX not in hc: + # History DoS limit. Each element of history is about 99 + # bytes when encoded as JSON. This limits resource usage + # on bloated history requests, and uses a smaller divisor + # so large requests are logged before refusing them. + limit = self.env.max_send // 97 + hc[hashX] = await self.db.limited_history(hashX, limit=limit) + return hc[hashX] + + async def _notify_sessions(self, height, touched): + '''Notify sessions about height changes and touched addresses.''' + height_changed = height != self.notified_height + if height_changed: + await self._refresh_hsub_results(height) + # Invalidate our history cache for touched hashXs + hc = self.history_cache + for hashX in set(hc).intersection(touched): + del hc[hashX] + + async with TaskGroup() as group: + for session in self.sessions: + await group.spawn(session.notify(touched, height_changed)) + + def add_session(self, session): + self.sessions.add(session) + self.session_event.set() + gid = int(session.start_time - self.start_time) // 900 + if self.cur_group.gid != gid: + self.cur_group = SessionGroup(gid) + return self.cur_group + + def remove_session(self, session): + '''Remove a session from our sessions list if there.''' + self.sessions.remove(session) + self.session_event.set() + + def new_subscription(self): + if self.subs_room <= 0: + self.subs_room = self.max_subs - self._sub_count() + if self.subs_room <= 0: + raise RPCError(BAD_REQUEST, f'server subscription limit ' + f'{self.max_subs:,d} reached') + self.subs_room -= 1 + + +class SessionBase(RPCSession): + '''Base class of ElectrumX JSON sessions. + + Each session runs its tasks in asynchronous parallelism with other + sessions. + ''' + + MAX_CHUNK_SIZE = 2016 + session_counter = itertools.count() + + def __init__(self, session_mgr, db, mempool, peer_mgr, kind): + connection = JSONRPCConnection(JSONRPCAutoDetect) + super().__init__(connection=connection) + self.logger = util.class_logger(__name__, self.__class__.__name__) + self.session_mgr = session_mgr + self.db = db + self.mempool = mempool + self.peer_mgr = peer_mgr + self.kind = kind # 'RPC', 'TCP' etc. + self.env = session_mgr.env + self.coin = self.env.coin + self.client = 'unknown' + self.anon_logs = self.env.anon_logs + self.txs_sent = 0 + self.log_me = False + self.bw_limit = self.env.bandwidth_limit + self.daemon_request = self.session_mgr.daemon_request + # Hijack the connection so we can log messages + self._receive_message_orig = self.connection.receive_message + self.connection.receive_message = self.receive_message + + async def notify(self, touched, height_changed): + pass + + def peer_address_str(self, *, for_log=True): + '''Returns the peer's IP address and port as a human-readable + string, respecting anon logs if the output is for a log.''' + if for_log and self.anon_logs: + return 'xx.xx.xx.xx:xx' + return super().peer_address_str() + + def receive_message(self, message): + if self.log_me: + self.logger.info(f'processing {message}') + return self._receive_message_orig(message) + + def toggle_logging(self): + self.log_me = not self.log_me + + def flags(self): + '''Status flags.''' + status = self.kind[0] + if self.is_closing(): + status += 'C' + if self.log_me: + status += 'L' + status += str(self.concurrency.max_concurrent) + return status + + def connection_made(self, transport): + '''Handle an incoming client connection.''' + super().connection_made(transport) + self.session_id = next(self.session_counter) + context = {'conn_id': f'{self.session_id}'} + self.logger = util.ConnectionLogger(self.logger, context) + self.group = self.session_mgr.add_session(self) + self.logger.info(f'{self.kind} {self.peer_address_str()}, ' + f'{self.session_mgr.session_count():,d} total') + + def connection_lost(self, exc): + '''Handle client disconnection.''' + super().connection_lost(exc) + self.session_mgr.remove_session(self) + msg = '' + if not self.can_send.is_set(): + msg += ' whilst paused' + if self.concurrency.max_concurrent != self.max_concurrent: + msg += ' whilst throttled' + if self.send_size >= 1024*1024: + msg += ('. Sent {:,d} bytes in {:,d} messages' + .format(self.send_size, self.send_count)) + if msg: + msg = 'disconnected' + msg + self.logger.info(msg) + + def count_pending_items(self): + return len(self.connection.pending_requests()) + + def semaphore(self): + return Semaphores([self.concurrency.semaphore, self.group.semaphore]) + + def sub_count(self): + return 0 + + async def handle_request(self, request): + '''Handle an incoming request. ElectrumX doesn't receive + notifications from client sessions. + ''' + if isinstance(request, Request): + handler = self.request_handlers.get(request.method) + else: + handler = None + coro = handler_invocation(handler, request)() + return await coro + + +class ElectrumX(SessionBase): + '''A TCP server that handles incoming Electrum connections.''' + + PROTOCOL_MIN = (1, 1) + PROTOCOL_MAX = (1, 4) + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.subscribe_headers = False + self.subscribe_headers_raw = False + self.connection.max_response_size = self.env.max_send + self.max_subs = self.env.max_session_subs + self.hashX_subs = {} + self.sv_seen = False + self.mempool_statuses = {} + self.set_request_handlers(self.PROTOCOL_MIN) + + @classmethod + def protocol_min_max_strings(cls): + return [util.version_string(ver) + for ver in (cls.PROTOCOL_MIN, cls.PROTOCOL_MAX)] + + @classmethod + def server_features(cls, env): + '''Return the server features dictionary.''' + min_str, max_str = cls.protocol_min_max_strings() + return { + 'hosts': env.hosts_dict(), + 'pruning': None, + 'server_version': torba.__version__, + 'protocol_min': min_str, + 'protocol_max': max_str, + 'genesis_hash': env.coin.GENESIS_HASH, + 'hash_function': 'sha256', + } + + async def server_features_async(self): + return self.server_features(self.env) + + @classmethod + def server_version_args(cls): + '''The arguments to a server.version RPC call to a peer.''' + return [torba.__version__, cls.protocol_min_max_strings()] + + def protocol_version_string(self): + return util.version_string(self.protocol_tuple) + + def sub_count(self): + return len(self.hashX_subs) + + async def notify(self, touched, height_changed): + '''Notify the client about changes to touched addresses (from mempool + updates or new blocks) and height. + ''' + if height_changed and self.subscribe_headers: + args = (await self.subscribe_headers_result(), ) + await self.send_notification('blockchain.headers.subscribe', args) + + touched = touched.intersection(self.hashX_subs) + if touched or (height_changed and self.mempool_statuses): + changed = {} + + for hashX in touched: + alias = self.hashX_subs[hashX] + status = await self.address_status(hashX) + changed[alias] = status + + # Check mempool hashXs - the status is a function of the + # confirmed state of other transactions. Note: we cannot + # iterate over mempool_statuses as it changes size. + for hashX in tuple(self.mempool_statuses): + # Items can be evicted whilst await-ing status; False + # ensures such hashXs are notified + old_status = self.mempool_statuses.get(hashX, False) + status = await self.address_status(hashX) + if status != old_status: + alias = self.hashX_subs[hashX] + changed[alias] = status + + for alias, status in changed.items(): + if len(alias) == 64: + method = 'blockchain.scripthash.subscribe' + else: + method = 'blockchain.address.subscribe' + await self.send_notification(method, (alias, status)) + + if changed: + es = '' if len(changed) == 1 else 'es' + self.logger.info(f'notified of {len(changed):,d} address{es}') + + async def subscribe_headers_result(self): + '''The result of a header subscription or notification.''' + return self.session_mgr.hsub_results[self.subscribe_headers_raw] + + async def _headers_subscribe(self, raw): + '''Subscribe to get headers of new blocks.''' + self.subscribe_headers_raw = assert_boolean(raw) + self.subscribe_headers = True + return await self.subscribe_headers_result() + + async def headers_subscribe(self): + '''Subscribe to get raw headers of new blocks.''' + return await self._headers_subscribe(True) + + async def headers_subscribe_True(self, raw=True): + '''Subscribe to get headers of new blocks.''' + return await self._headers_subscribe(raw) + + async def headers_subscribe_False(self, raw=False): + '''Subscribe to get headers of new blocks.''' + return await self._headers_subscribe(raw) + + async def add_peer(self, features): + '''Add a peer (but only if the peer resolves to the source).''' + return await self.peer_mgr.on_add_peer(features, self.peer_address()) + + async def peers_subscribe(self): + '''Return the server peers as a list of (ip, host, details) tuples.''' + return self.peer_mgr.on_peers_subscribe(self.is_tor()) + + async def address_status(self, hashX): + '''Returns an address status. + + Status is a hex string, but must be None if there is no history. + ''' + # Note history is ordered and mempool unordered in electrum-server + # For mempool, height is -1 if it has unconfirmed inputs, otherwise 0 + db_history = await self.session_mgr.limited_history(hashX) + mempool = await self.mempool.transaction_summaries(hashX) + + status = ''.join(f'{hash_to_hex_str(tx_hash)}:' + f'{height:d}:' + for tx_hash, height in db_history) + status += ''.join(f'{hash_to_hex_str(tx.hash)}:' + f'{-tx.has_unconfirmed_inputs:d}:' + for tx in mempool) + if status: + status = sha256(status.encode()).hex() + else: + status = None + + if mempool: + self.mempool_statuses[hashX] = status + else: + self.mempool_statuses.pop(hashX, None) + + return status + + async def hashX_listunspent(self, hashX): + '''Return the list of UTXOs of a script hash, including mempool + effects.''' + utxos = await self.db.all_utxos(hashX) + utxos = sorted(utxos) + utxos.extend(await self.mempool.unordered_UTXOs(hashX)) + spends = await self.mempool.potential_spends(hashX) + + return [{'tx_hash': hash_to_hex_str(utxo.tx_hash), + 'tx_pos': utxo.tx_pos, + 'height': utxo.height, 'value': utxo.value} + for utxo in utxos + if (utxo.tx_hash, utxo.tx_pos) not in spends] + + async def hashX_subscribe(self, hashX, alias): + # First check our limit. + if len(self.hashX_subs) >= self.max_subs: + raise RPCError(BAD_REQUEST, 'your address subscription limit ' + f'{self.max_subs:,d} reached') + + # Now let the session manager check its limit + self.session_mgr.new_subscription() + self.hashX_subs[hashX] = alias + return await self.address_status(hashX) + + def address_to_hashX(self, address): + try: + return self.coin.address_to_hashX(address) + except Exception: + pass + raise RPCError(BAD_REQUEST, f'{address} is not a valid address') + + async def address_get_balance(self, address): + '''Return the confirmed and unconfirmed balance of an address.''' + hashX = self.address_to_hashX(address) + return await self.get_balance(hashX) + + async def address_get_history(self, address): + '''Return the confirmed and unconfirmed history of an address.''' + hashX = self.address_to_hashX(address) + return await self.confirmed_and_unconfirmed_history(hashX) + + async def address_get_mempool(self, address): + '''Return the mempool transactions touching an address.''' + hashX = self.address_to_hashX(address) + return await self.unconfirmed_history(hashX) + + async def address_listunspent(self, address): + '''Return the list of UTXOs of an address.''' + hashX = self.address_to_hashX(address) + return await self.hashX_listunspent(hashX) + + async def address_subscribe(self, address): + '''Subscribe to an address. + + address: the address to subscribe to''' + hashX = self.address_to_hashX(address) + return await self.hashX_subscribe(hashX, address) + + async def get_balance(self, hashX): + utxos = await self.db.all_utxos(hashX) + confirmed = sum(utxo.value for utxo in utxos) + unconfirmed = await self.mempool.balance_delta(hashX) + return {'confirmed': confirmed, 'unconfirmed': unconfirmed} + + async def scripthash_get_balance(self, scripthash): + '''Return the confirmed and unconfirmed balance of a scripthash.''' + hashX = scripthash_to_hashX(scripthash) + return await self.get_balance(hashX) + + async def unconfirmed_history(self, hashX): + # Note unconfirmed history is unordered in electrum-server + # height is -1 if it has unconfirmed inputs, otherwise 0 + return [{'tx_hash': hash_to_hex_str(tx.hash), + 'height': -tx.has_unconfirmed_inputs, + 'fee': tx.fee} + for tx in await self.mempool.transaction_summaries(hashX)] + + async def confirmed_and_unconfirmed_history(self, hashX): + # Note history is ordered but unconfirmed is unordered in e-s + history = await self.session_mgr.limited_history(hashX) + conf = [{'tx_hash': hash_to_hex_str(tx_hash), 'height': height} + for tx_hash, height in history] + return conf + await self.unconfirmed_history(hashX) + + async def scripthash_get_history(self, scripthash): + '''Return the confirmed and unconfirmed history of a scripthash.''' + hashX = scripthash_to_hashX(scripthash) + return await self.confirmed_and_unconfirmed_history(hashX) + + async def scripthash_get_mempool(self, scripthash): + '''Return the mempool transactions touching a scripthash.''' + hashX = scripthash_to_hashX(scripthash) + return await self.unconfirmed_history(hashX) + + async def scripthash_listunspent(self, scripthash): + '''Return the list of UTXOs of a scripthash.''' + hashX = scripthash_to_hashX(scripthash) + return await self.hashX_listunspent(hashX) + + async def scripthash_subscribe(self, scripthash): + '''Subscribe to a script hash. + + scripthash: the SHA256 hash of the script to subscribe to''' + hashX = scripthash_to_hashX(scripthash) + return await self.hashX_subscribe(hashX, scripthash) + + async def _merkle_proof(self, cp_height, height): + max_height = self.db.db_height + if not height <= cp_height <= max_height: + raise RPCError(BAD_REQUEST, + f'require header height {height:,d} <= ' + f'cp_height {cp_height:,d} <= ' + f'chain height {max_height:,d}') + branch, root = await self.db.header_branch_and_root(cp_height + 1, + height) + return { + 'branch': [hash_to_hex_str(elt) for elt in branch], + 'root': hash_to_hex_str(root), + } + + async def block_header(self, height, cp_height=0): + '''Return a raw block header as a hexadecimal string, or as a + dictionary with a merkle proof.''' + height = non_negative_integer(height) + cp_height = non_negative_integer(cp_height) + raw_header_hex = (await self.session_mgr.raw_header(height)).hex() + if cp_height == 0: + return raw_header_hex + result = {'header': raw_header_hex} + result.update(await self._merkle_proof(cp_height, height)) + return result + + async def block_header_13(self, height): + '''Return a raw block header as a hexadecimal string. + + height: the header's height''' + return await self.block_header(height) + + async def block_headers(self, start_height, count, cp_height=0): + '''Return count concatenated block headers as hex for the main chain; + starting at start_height. + + start_height and count must be non-negative integers. At most + MAX_CHUNK_SIZE headers will be returned. + ''' + start_height = non_negative_integer(start_height) + count = non_negative_integer(count) + cp_height = non_negative_integer(cp_height) + + max_size = self.MAX_CHUNK_SIZE + count = min(count, max_size) + headers, count = await self.db.read_headers(start_height, count) + result = {'hex': headers.hex(), 'count': count, 'max': max_size} + if count and cp_height: + last_height = start_height + count - 1 + result.update(await self._merkle_proof(cp_height, last_height)) + return result + + async def block_headers_12(self, start_height, count): + return await self.block_headers(start_height, count) + + async def block_get_chunk(self, index): + '''Return a chunk of block headers as a hexadecimal string. + + index: the chunk index''' + index = non_negative_integer(index) + size = self.coin.CHUNK_SIZE + start_height = index * size + headers, _ = await self.db.read_headers(start_height, size) + return headers.hex() + + async def block_get_header(self, height): + '''The deserialized header at a given height. + + height: the header's height''' + height = non_negative_integer(height) + return await self.session_mgr.electrum_header(height) + + def is_tor(self): + '''Try to detect if the connection is to a tor hidden service we are + running.''' + peername = self.peer_mgr.proxy_peername() + if not peername: + return False + peer_address = self.peer_address() + return peer_address and peer_address[0] == peername[0] + + async def replaced_banner(self, banner): + network_info = await self.daemon_request('getnetworkinfo') + ni_version = network_info['version'] + major, minor = divmod(ni_version, 1000000) + minor, revision = divmod(minor, 10000) + revision //= 100 + daemon_version = '{:d}.{:d}.{:d}'.format(major, minor, revision) + for pair in [ + ('$SERVER_VERSION', torba.__version__), + ('$DAEMON_VERSION', daemon_version), + ('$DAEMON_SUBVERSION', network_info['subversion']), + ('$DONATION_ADDRESS', self.env.donation_address), + ]: + banner = banner.replace(*pair) + return banner + + async def donation_address(self): + '''Return the donation address as a string, empty if there is none.''' + return self.env.donation_address + + async def banner(self): + '''Return the server banner text.''' + banner = f'You are connected to an {torba.__version__} server.' + + if self.is_tor(): + banner_file = self.env.tor_banner_file + else: + banner_file = self.env.banner_file + if banner_file: + try: + with codecs.open(banner_file, 'r', 'utf-8') as f: + banner = f.read() + except Exception as e: + self.logger.error(f'reading banner file {banner_file}: {e!r}') + else: + banner = await self.replaced_banner(banner) + + return banner + + async def relayfee(self): + '''The minimum fee a low-priority tx must pay in order to be accepted + to the daemon's memory pool.''' + return await self.daemon_request('relayfee') + + async def estimatefee(self, number): + '''The estimated transaction fee per kilobyte to be paid for a + transaction to be included within a certain number of blocks. + + number: the number of blocks + ''' + number = non_negative_integer(number) + return await self.daemon_request('estimatefee', number) + + async def ping(self): + '''Serves as a connection keep-alive mechanism and for the client to + confirm the server is still responding. + ''' + return None + + async def server_version(self, client_name='', protocol_version=None): + '''Returns the server version as a string. + + client_name: a string identifying the client + protocol_version: the protocol version spoken by the client + ''' + if self.sv_seen and self.protocol_tuple >= (1, 4): + raise RPCError(BAD_REQUEST, f'server.version already sent') + self.sv_seen = True + + if client_name: + client_name = str(client_name) + if self.env.drop_client is not None and \ + self.env.drop_client.match(client_name): + self.close_after_send = True + raise RPCError(BAD_REQUEST, + f'unsupported client: {client_name}') + self.client = client_name[:17] + + # Find the highest common protocol version. Disconnect if + # that protocol version in unsupported. + ptuple, client_min = util.protocol_version( + protocol_version, self.PROTOCOL_MIN, self.PROTOCOL_MAX) + if ptuple is None: + if client_min > self.PROTOCOL_MIN: + self.logger.info(f'client requested future protocol version ' + f'{util.version_string(client_min)} ' + f'- is your software out of date?') + self.close_after_send = True + raise RPCError(BAD_REQUEST, + f'unsupported protocol version: {protocol_version}') + self.set_request_handlers(ptuple) + + return torba.__version__, self.protocol_version_string() + + async def transaction_broadcast(self, raw_tx): + '''Broadcast a raw transaction to the network. + + raw_tx: the raw transaction as a hexadecimal string''' + # This returns errors as JSON RPC errors, as is natural + try: + hex_hash = await self.session_mgr.broadcast_transaction(raw_tx) + self.txs_sent += 1 + self.logger.info(f'sent tx: {hex_hash}') + return hex_hash + except DaemonError as e: + error, = e.args + message = error['message'] + self.logger.info(f'error sending transaction: {message}') + raise RPCError(BAD_REQUEST, 'the transaction was rejected by ' + f'network rules.\n\n{message}\n[{raw_tx}]') + + async def transaction_get(self, tx_hash, verbose=False): + '''Return the serialized raw transaction given its hash + + tx_hash: the transaction hash as a hexadecimal string + verbose: passed on to the daemon + ''' + assert_tx_hash(tx_hash) + if verbose not in (True, False): + raise RPCError(BAD_REQUEST, f'"verbose" must be a boolean') + + return await self.daemon_request('getrawtransaction', tx_hash, verbose) + + async def _block_hash_and_tx_hashes(self, height): + '''Returns a pair (block_hash, tx_hashes) for the main chain block at + the given height. + + block_hash is a hexadecimal string, and tx_hashes is an + ordered list of hexadecimal strings. + ''' + height = non_negative_integer(height) + hex_hashes = await self.daemon_request('block_hex_hashes', height, 1) + block_hash = hex_hashes[0] + block = await self.daemon_request('deserialised_block', block_hash) + return block_hash, block['tx'] + + def _get_merkle_branch(self, tx_hashes, tx_pos): + '''Return a merkle branch to a transaction. + + tx_hashes: ordered list of hex strings of tx hashes in a block + tx_pos: index of transaction in tx_hashes to create branch for + ''' + hashes = [hex_str_to_hash(hash) for hash in tx_hashes] + branch, root = self.db.merkle.branch_and_root(hashes, tx_pos) + branch = [hash_to_hex_str(hash) for hash in branch] + return branch + + async def transaction_merkle(self, tx_hash, height): + '''Return the markle branch to a confirmed transaction given its hash + and height. + + tx_hash: the transaction hash as a hexadecimal string + height: the height of the block it is in + ''' + assert_tx_hash(tx_hash) + block_hash, tx_hashes = await self._block_hash_and_tx_hashes(height) + try: + pos = tx_hashes.index(tx_hash) + except ValueError: + raise RPCError(BAD_REQUEST, f'tx hash {tx_hash} not in ' + f'block {block_hash} at height {height:,d}') + branch = self._get_merkle_branch(tx_hashes, pos) + return {"block_height": height, "merkle": branch, "pos": pos} + + async def transaction_id_from_pos(self, height, tx_pos, merkle=False): + '''Return the txid and optionally a merkle proof, given + a block height and position in the block. + ''' + tx_pos = non_negative_integer(tx_pos) + if merkle not in (True, False): + raise RPCError(BAD_REQUEST, f'"merkle" must be a boolean') + + block_hash, tx_hashes = await self._block_hash_and_tx_hashes(height) + try: + tx_hash = tx_hashes[tx_pos] + except IndexError: + raise RPCError(BAD_REQUEST, f'no tx at position {tx_pos:,d} in ' + f'block {block_hash} at height {height:,d}') + + if merkle: + branch = self._get_merkle_branch(tx_hashes, tx_pos) + return {"tx_hash": tx_hash, "merkle": branch} + else: + return tx_hash + + def set_request_handlers(self, ptuple): + self.protocol_tuple = ptuple + + handlers = { + 'blockchain.block.get_chunk': self.block_get_chunk, + 'blockchain.block.get_header': self.block_get_header, + 'blockchain.estimatefee': self.estimatefee, + 'blockchain.relayfee': self.relayfee, + 'blockchain.scripthash.get_balance': self.scripthash_get_balance, + 'blockchain.scripthash.get_history': self.scripthash_get_history, + 'blockchain.scripthash.get_mempool': self.scripthash_get_mempool, + 'blockchain.scripthash.listunspent': self.scripthash_listunspent, + 'blockchain.scripthash.subscribe': self.scripthash_subscribe, + 'blockchain.transaction.broadcast': self.transaction_broadcast, + 'blockchain.transaction.get': self.transaction_get, + 'blockchain.transaction.get_merkle': self.transaction_merkle, + 'server.add_peer': self.add_peer, + 'server.banner': self.banner, + 'server.donation_address': self.donation_address, + 'server.features': self.server_features_async, + 'server.peers.subscribe': self.peers_subscribe, + 'server.version': self.server_version, + } + + if ptuple >= (1, 2): + # New handler as of 1.2 + handlers.update({ + 'mempool.get_fee_histogram': + self.mempool.compact_fee_histogram, + 'blockchain.block.headers': self.block_headers_12, + 'server.ping': self.ping, + }) + + if ptuple >= (1, 4): + handlers.update({ + 'blockchain.block.header': self.block_header, + 'blockchain.block.headers': self.block_headers, + 'blockchain.headers.subscribe': self.headers_subscribe, + 'blockchain.transaction.id_from_pos': + self.transaction_id_from_pos, + }) + elif ptuple >= (1, 3): + handlers.update({ + 'blockchain.block.header': self.block_header_13, + 'blockchain.headers.subscribe': self.headers_subscribe_True, + }) + else: + handlers.update({ + 'blockchain.headers.subscribe': self.headers_subscribe_False, + 'blockchain.address.get_balance': self.address_get_balance, + 'blockchain.address.get_history': self.address_get_history, + 'blockchain.address.get_mempool': self.address_get_mempool, + 'blockchain.address.listunspent': self.address_listunspent, + 'blockchain.address.subscribe': self.address_subscribe, + }) + + self.request_handlers = handlers + + +class LocalRPC(SessionBase): + '''A local TCP RPC server session.''' + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.client = 'RPC' + self.connection._max_response_size = 0 + + def protocol_version_string(self): + return 'RPC' + + +class DashElectrumX(ElectrumX): + '''A TCP server that handles incoming Electrum Dash connections.''' + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.mns = set() + + def set_request_handlers(self, ptuple): + super().set_request_handlers(ptuple) + self.request_handlers.update({ + 'masternode.announce.broadcast': + self.masternode_announce_broadcast, + 'masternode.subscribe': self.masternode_subscribe, + 'masternode.list': self.masternode_list + }) + + async def notify(self, touched, height_changed): + '''Notify the client about changes in masternode list.''' + await super().notify(touched, height_changed) + for mn in self.mns: + status = await self.daemon_request('masternode_list', + ['status', mn]) + await self.send_notification('masternode.subscribe', + [mn, status.get(mn)]) + + # Masternode command handlers + async def masternode_announce_broadcast(self, signmnb): + '''Pass through the masternode announce message to be broadcast + by the daemon. + + signmnb: signed masternode broadcast message.''' + try: + return await self.daemon_request('masternode_broadcast', + ['relay', signmnb]) + except DaemonError as e: + error, = e.args + message = error['message'] + self.logger.info(f'masternode_broadcast: {message}') + raise RPCError(BAD_REQUEST, 'the masternode broadcast was ' + f'rejected.\n\n{message}\n[{signmnb}]') + + async def masternode_subscribe(self, collateral): + '''Returns the status of masternode. + + collateral: masternode collateral. + ''' + result = await self.daemon_request('masternode_list', + ['status', collateral]) + if result is not None: + self.mns.add(collateral) + return result.get(collateral) + return None + + async def masternode_list(self, payees): + ''' + Returns the list of masternodes. + + payees: a list of masternode payee addresses. + ''' + if not isinstance(payees, list): + raise RPCError(BAD_REQUEST, 'expected a list of payees') + + def get_masternode_payment_queue(mns): + '''Returns the calculated position in the payment queue for all the + valid masterernodes in the given mns list. + + mns: a list of masternodes information. + ''' + now = int(datetime.datetime.utcnow().strftime("%s")) + mn_queue = [] + + # Only ENABLED masternodes are considered for the list. + for line in mns: + mnstat = mns[line].split() + if mnstat[0] == 'ENABLED': + # if last paid time == 0 + if int(mnstat[5]) == 0: + # use active seconds + mnstat.append(int(mnstat[4])) + else: + # now minus last paid + delta = now - int(mnstat[5]) + # if > active seconds, use active seconds + if delta >= int(mnstat[4]): + mnstat.append(int(mnstat[4])) + # use active seconds + else: + mnstat.append(delta) + mn_queue.append(mnstat) + mn_queue = sorted(mn_queue, key=lambda x: x[8], reverse=True) + return mn_queue + + def get_payment_position(payment_queue, address): + ''' + Returns the position of the payment list for the given address. + + payment_queue: position in the payment queue for the masternode. + address: masternode payee address. + ''' + position = -1 + for pos, mn in enumerate(payment_queue, start=1): + if mn[2] == address: + position = pos + break + return position + + # Accordingly with the masternode payment queue, a custom list + # with the masternode information including the payment + # position is returned. + cache = self.session_mgr.mn_cache + if not cache or self.session_mgr.mn_cache_height != self.db.db_height: + full_mn_list = await self.daemon_request('masternode_list', + ['full']) + mn_payment_queue = get_masternode_payment_queue(full_mn_list) + mn_payment_count = len(mn_payment_queue) + mn_list = [] + for key, value in full_mn_list.items(): + mn_data = value.split() + mn_info = {} + mn_info['vin'] = key + mn_info['status'] = mn_data[0] + mn_info['protocol'] = mn_data[1] + mn_info['payee'] = mn_data[2] + mn_info['lastseen'] = mn_data[3] + mn_info['activeseconds'] = mn_data[4] + mn_info['lastpaidtime'] = mn_data[5] + mn_info['lastpaidblock'] = mn_data[6] + mn_info['ip'] = mn_data[7] + mn_info['paymentposition'] = get_payment_position( + mn_payment_queue, mn_info['payee']) + mn_info['inselection'] = ( + mn_info['paymentposition'] < mn_payment_count // 10) + balance = await self.address_get_balance(mn_info['payee']) + mn_info['balance'] = (sum(balance.values()) + / self.coin.VALUE_PER_COIN) + mn_list.append(mn_info) + cache.clear() + cache.extend(mn_list) + self.session_mgr.mn_cache_height = self.db.db_height + + # If payees is an empty list the whole masternode list is returned + if payees: + return [mn for mn in cache if mn['payee'] in payees] + else: + return cache diff --git a/torba/server/storage.py b/torba/server/storage.py new file mode 100644 index 000000000..859b26ffd --- /dev/null +++ b/torba/server/storage.py @@ -0,0 +1,166 @@ +# Copyright (c) 2016-2017, the ElectrumX authors +# +# All rights reserved. +# +# See the file "LICENCE" for information about the copyright +# and warranty status of this software. + +'''Backend database abstraction.''' + +import os +from functools import partial + +import torba.server.util as util + + +def db_class(name): + '''Returns a DB engine class.''' + for db_class in util.subclasses(Storage): + if db_class.__name__.lower() == name.lower(): + db_class.import_module() + return db_class + raise RuntimeError('unrecognised DB engine "{}"'.format(name)) + + +class Storage(object): + '''Abstract base class of the DB backend abstraction.''' + + def __init__(self, name, for_sync): + self.is_new = not os.path.exists(name) + self.for_sync = for_sync or self.is_new + self.open(name, create=self.is_new) + + @classmethod + def import_module(cls): + '''Import the DB engine module.''' + raise NotImplementedError + + def open(self, name, create): + '''Open an existing database or create a new one.''' + raise NotImplementedError + + def close(self): + '''Close an existing database.''' + raise NotImplementedError + + def get(self, key): + raise NotImplementedError + + def put(self, key, value): + raise NotImplementedError + + def write_batch(self): + '''Return a context manager that provides `put` and `delete`. + + Changes should only be committed when the context manager + closes without an exception. + ''' + raise NotImplementedError + + def iterator(self, prefix=b'', reverse=False): + '''Return an iterator that yields (key, value) pairs from the + database sorted by key. + + If `prefix` is set, only keys starting with `prefix` will be + included. If `reverse` is True the items are returned in + reverse order. + ''' + raise NotImplementedError + + +class LevelDB(Storage): + '''LevelDB database engine.''' + + @classmethod + def import_module(cls): + import plyvel + cls.module = plyvel + + def open(self, name, create): + mof = 512 if self.for_sync else 128 + # Use snappy compression (the default) + self.db = self.module.DB(name, create_if_missing=create, + max_open_files=mof) + self.close = self.db.close + self.get = self.db.get + self.put = self.db.put + self.iterator = self.db.iterator + self.write_batch = partial(self.db.write_batch, transaction=True, + sync=True) + + +class RocksDB(Storage): + '''RocksDB database engine.''' + + @classmethod + def import_module(cls): + import rocksdb + cls.module = rocksdb + + def open(self, name, create): + mof = 512 if self.for_sync else 128 + # Use snappy compression (the default) + options = self.module.Options(create_if_missing=create, + use_fsync=True, + target_file_size_base=33554432, + max_open_files=mof) + self.db = self.module.DB(name, options) + self.get = self.db.get + self.put = self.db.put + + def close(self): + # PyRocksDB doesn't provide a close method; hopefully this is enough + self.db = self.get = self.put = None + import gc + gc.collect() + + def write_batch(self): + return RocksDBWriteBatch(self.db) + + def iterator(self, prefix=b'', reverse=False): + return RocksDBIterator(self.db, prefix, reverse) + + +class RocksDBWriteBatch(object): + '''A write batch for RocksDB.''' + + def __init__(self, db): + self.batch = RocksDB.module.WriteBatch() + self.db = db + + def __enter__(self): + return self.batch + + def __exit__(self, exc_type, exc_val, exc_tb): + if not exc_val: + self.db.write(self.batch) + + +class RocksDBIterator(object): + '''An iterator for RocksDB.''' + + def __init__(self, db, prefix, reverse): + self.prefix = prefix + if reverse: + self.iterator = reversed(db.iteritems()) + nxt_prefix = util.increment_byte_string(prefix) + if nxt_prefix: + self.iterator.seek(nxt_prefix) + try: + next(self.iterator) + except StopIteration: + self.iterator.seek(nxt_prefix) + else: + self.iterator.seek_to_last() + else: + self.iterator = db.iteritems() + self.iterator.seek(prefix) + + def __iter__(self): + return self + + def __next__(self): + k, v = next(self.iterator) + if not k.startswith(self.prefix): + raise StopIteration + return k, v diff --git a/torba/server/text.py b/torba/server/text.py new file mode 100644 index 000000000..409276f8e --- /dev/null +++ b/torba/server/text.py @@ -0,0 +1,82 @@ +import time + +import torba.server.util as util + + +def sessions_lines(data): + '''A generator returning lines for a list of sessions. + + data is the return value of rpc_sessions().''' + fmt = ('{:<6} {:<5} {:>17} {:>5} {:>5} {:>5} ' + '{:>7} {:>7} {:>7} {:>7} {:>7} {:>9} {:>21}') + yield fmt.format('ID', 'Flags', 'Client', 'Proto', + 'Reqs', 'Txs', 'Subs', + 'Recv', 'Recv KB', 'Sent', 'Sent KB', 'Time', 'Peer') + for (id_, flags, peer, client, proto, reqs, txs_sent, subs, + recv_count, recv_size, send_count, send_size, time) in data: + yield fmt.format(id_, flags, client, proto, + '{:,d}'.format(reqs), + '{:,d}'.format(txs_sent), + '{:,d}'.format(subs), + '{:,d}'.format(recv_count), + '{:,d}'.format(recv_size // 1024), + '{:,d}'.format(send_count), + '{:,d}'.format(send_size // 1024), + util.formatted_time(time, sep=''), peer) + + +def groups_lines(data): + '''A generator returning lines for a list of groups. + + data is the return value of rpc_groups().''' + + fmt = ('{:<6} {:>9} {:>9} {:>6} {:>6} {:>8}' + '{:>7} {:>9} {:>7} {:>9}') + yield fmt.format('ID', 'Sessions', 'Bwidth KB', 'Reqs', 'Txs', 'Subs', + 'Recv', 'Recv KB', 'Sent', 'Sent KB') + for (id_, session_count, bandwidth, reqs, txs_sent, subs, + recv_count, recv_size, send_count, send_size) in data: + yield fmt.format(id_, + '{:,d}'.format(session_count), + '{:,d}'.format(bandwidth // 1024), + '{:,d}'.format(reqs), + '{:,d}'.format(txs_sent), + '{:,d}'.format(subs), + '{:,d}'.format(recv_count), + '{:,d}'.format(recv_size // 1024), + '{:,d}'.format(send_count), + '{:,d}'.format(send_size // 1024)) + + +def peers_lines(data): + '''A generator returning lines for a list of peers. + + data is the return value of rpc_peers().''' + def time_fmt(t): + if not t: + return 'Never' + return util.formatted_time(now - t) + + now = time.time() + fmt = ('{:<30} {:<6} {:>5} {:>5} {:<17} {:>4} ' + '{:>4} {:>8} {:>11} {:>11} {:>5} {:>20} {:<15}') + yield fmt.format('Host', 'Status', 'TCP', 'SSL', 'Server', 'Min', + 'Max', 'Pruning', 'Last Good', 'Last Try', + 'Tries', 'Source', 'IP Address') + for item in data: + features = item['features'] + hostname = item['host'] + host = features['hosts'][hostname] + yield fmt.format(hostname[:30], + item['status'], + host.get('tcp_port') or '', + host.get('ssl_port') or '', + features['server_version'] or 'unknown', + features['protocol_min'], + features['protocol_max'], + features['pruning'] or '', + time_fmt(item['last_good']), + time_fmt(item['last_try']), + item['try_count'], + item['source'][:20], + item['ip_addr'] or '') diff --git a/torba/server/tx.py b/torba/server/tx.py new file mode 100644 index 000000000..b1d578c7e --- /dev/null +++ b/torba/server/tx.py @@ -0,0 +1,625 @@ +# Copyright (c) 2016-2017, Neil Booth +# Copyright (c) 2017, the ElectrumX authors +# +# All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# and warranty status of this software. + +'''Transaction-related classes and functions.''' + +from collections import namedtuple + +from torba.server.hash import sha256, double_sha256, hash_to_hex_str +from torba.server.script import OpCodes +from torba.server.util import ( + unpack_le_int32_from, unpack_le_int64_from, unpack_le_uint16_from, + unpack_le_uint32_from, unpack_le_uint64_from, pack_le_int32, pack_varint, + pack_le_uint32, pack_le_int64, pack_varbytes, +) + +ZERO = bytes(32) +MINUS_1 = 4294967295 + + +class Tx(namedtuple("Tx", "version inputs outputs locktime")): + '''Class representing a transaction.''' + + def serialize(self): + return b''.join(( + pack_le_int32(self.version), + pack_varint(len(self.inputs)), + b''.join(tx_in.serialize() for tx_in in self.inputs), + pack_varint(len(self.outputs)), + b''.join(tx_out.serialize() for tx_out in self.outputs), + pack_le_uint32(self.locktime) + )) + + +class TxInput(namedtuple("TxInput", "prev_hash prev_idx script sequence")): + '''Class representing a transaction input.''' + def __str__(self): + script = self.script.hex() + prev_hash = hash_to_hex_str(self.prev_hash) + return ("Input({}, {:d}, script={}, sequence={:d})" + .format(prev_hash, self.prev_idx, script, self.sequence)) + + def is_generation(self): + '''Test if an input is generation/coinbase like''' + return self.prev_idx == MINUS_1 and self.prev_hash == ZERO + + def serialize(self): + return b''.join(( + self.prev_hash, + pack_le_uint32(self.prev_idx), + pack_varbytes(self.script), + pack_le_uint32(self.sequence), + )) + + +class TxOutput(namedtuple("TxOutput", "value pk_script")): + + def serialize(self): + return b''.join(( + pack_le_int64(self.value), + pack_varbytes(self.pk_script), + )) + + +class Deserializer(object): + '''Deserializes blocks into transactions. + + External entry points are read_tx(), read_tx_and_hash(), + read_tx_and_vsize() and read_block(). + + This code is performance sensitive as it is executed 100s of + millions of times during sync. + ''' + + TX_HASH_FN = staticmethod(double_sha256) + + def __init__(self, binary, start=0): + assert isinstance(binary, bytes) + self.binary = binary + self.binary_length = len(binary) + self.cursor = start + + def read_tx(self): + '''Return a deserialized transaction.''' + return Tx( + self._read_le_int32(), # version + self._read_inputs(), # inputs + self._read_outputs(), # outputs + self._read_le_uint32() # locktime + ) + + def read_tx_and_hash(self): + '''Return a (deserialized TX, tx_hash) pair. + + The hash needs to be reversed for human display; for efficiency + we process it in the natural serialized order. + ''' + start = self.cursor + return self.read_tx(), self.TX_HASH_FN(self.binary[start:self.cursor]) + + def read_tx_and_vsize(self): + '''Return a (deserialized TX, vsize) pair.''' + return self.read_tx(), self.binary_length + + def read_tx_block(self): + '''Returns a list of (deserialized_tx, tx_hash) pairs.''' + read = self.read_tx_and_hash + # Some coins have excess data beyond the end of the transactions + return [read() for _ in range(self._read_varint())] + + def _read_inputs(self): + read_input = self._read_input + return [read_input() for i in range(self._read_varint())] + + def _read_input(self): + return TxInput( + self._read_nbytes(32), # prev_hash + self._read_le_uint32(), # prev_idx + self._read_varbytes(), # script + self._read_le_uint32() # sequence + ) + + def _read_outputs(self): + read_output = self._read_output + return [read_output() for i in range(self._read_varint())] + + def _read_output(self): + return TxOutput( + self._read_le_int64(), # value + self._read_varbytes(), # pk_script + ) + + def _read_byte(self): + cursor = self.cursor + self.cursor += 1 + return self.binary[cursor] + + def _read_nbytes(self, n): + cursor = self.cursor + self.cursor = end = cursor + n + assert self.binary_length >= end + return self.binary[cursor:end] + + def _read_varbytes(self): + return self._read_nbytes(self._read_varint()) + + def _read_varint(self): + n = self.binary[self.cursor] + self.cursor += 1 + if n < 253: + return n + if n == 253: + return self._read_le_uint16() + if n == 254: + return self._read_le_uint32() + return self._read_le_uint64() + + def _read_le_int32(self): + result, = unpack_le_int32_from(self.binary, self.cursor) + self.cursor += 4 + return result + + def _read_le_int64(self): + result, = unpack_le_int64_from(self.binary, self.cursor) + self.cursor += 8 + return result + + def _read_le_uint16(self): + result, = unpack_le_uint16_from(self.binary, self.cursor) + self.cursor += 2 + return result + + def _read_le_uint32(self): + result, = unpack_le_uint32_from(self.binary, self.cursor) + self.cursor += 4 + return result + + def _read_le_uint64(self): + result, = unpack_le_uint64_from(self.binary, self.cursor) + self.cursor += 8 + return result + + +class TxSegWit(namedtuple("Tx", "version marker flag inputs outputs " + "witness locktime")): + '''Class representing a SegWit transaction.''' + + +class DeserializerSegWit(Deserializer): + + # https://bitcoincore.org/en/segwit_wallet_dev/#transaction-serialization + + def _read_witness(self, fields): + read_witness_field = self._read_witness_field + return [read_witness_field() for i in range(fields)] + + def _read_witness_field(self): + read_varbytes = self._read_varbytes + return [read_varbytes() for i in range(self._read_varint())] + + def _read_tx_parts(self): + '''Return a (deserialized TX, tx_hash, vsize) tuple.''' + start = self.cursor + marker = self.binary[self.cursor + 4] + if marker: + tx = super().read_tx() + tx_hash = self.TX_HASH_FN(self.binary[start:self.cursor]) + return tx, tx_hash, self.binary_length + + # Ugh, this is nasty. + version = self._read_le_int32() + orig_ser = self.binary[start:self.cursor] + + marker = self._read_byte() + flag = self._read_byte() + + start = self.cursor + inputs = self._read_inputs() + outputs = self._read_outputs() + orig_ser += self.binary[start:self.cursor] + + base_size = self.cursor - start + witness = self._read_witness(len(inputs)) + + start = self.cursor + locktime = self._read_le_uint32() + orig_ser += self.binary[start:self.cursor] + vsize = (3 * base_size + self.binary_length) // 4 + + return TxSegWit(version, marker, flag, inputs, outputs, witness, + locktime), self.TX_HASH_FN(orig_ser), vsize + + def read_tx(self): + return self._read_tx_parts()[0] + + def read_tx_and_hash(self): + tx, tx_hash, vsize = self._read_tx_parts() + return tx, tx_hash + + def read_tx_and_vsize(self): + tx, tx_hash, vsize = self._read_tx_parts() + return tx, vsize + + +class DeserializerAuxPow(Deserializer): + VERSION_AUXPOW = (1 << 8) + + def read_header(self, height, static_header_size): + '''Return the AuxPow block header bytes''' + start = self.cursor + version = self._read_le_uint32() + if version & self.VERSION_AUXPOW: + # We are going to calculate the block size then read it as bytes + self.cursor = start + self.cursor += static_header_size # Block normal header + self.read_tx() # AuxPow transaction + self.cursor += 32 # Parent block hash + merkle_size = self._read_varint() + self.cursor += 32 * merkle_size # Merkle branch + self.cursor += 4 # Index + merkle_size = self._read_varint() + self.cursor += 32 * merkle_size # Chain merkle branch + self.cursor += 4 # Chain index + self.cursor += 80 # Parent block header + header_end = self.cursor + else: + header_end = static_header_size + self.cursor = start + return self._read_nbytes(header_end) + + +class DeserializerAuxPowSegWit(DeserializerSegWit, DeserializerAuxPow): + pass + + +class DeserializerEquihash(Deserializer): + def read_header(self, height, static_header_size): + '''Return the block header bytes''' + start = self.cursor + # We are going to calculate the block size then read it as bytes + self.cursor += static_header_size + solution_size = self._read_varint() + self.cursor += solution_size + header_end = self.cursor + self.cursor = start + return self._read_nbytes(header_end) + + +class DeserializerEquihashSegWit(DeserializerSegWit, DeserializerEquihash): + pass + + +class TxJoinSplit(namedtuple("Tx", "version inputs outputs locktime")): + '''Class representing a JoinSplit transaction.''' + + +class DeserializerZcash(DeserializerEquihash): + def read_tx(self): + header = self._read_le_uint32() + overwintered = ((header >> 31) == 1) + if overwintered: + version = header & 0x7fffffff + self.cursor += 4 # versionGroupId + else: + version = header + + is_overwinter_v3 = version == 3 + is_sapling_v4 = version == 4 + + base_tx = TxJoinSplit( + version, + self._read_inputs(), # inputs + self._read_outputs(), # outputs + self._read_le_uint32() # locktime + ) + + if is_overwinter_v3 or is_sapling_v4: + self.cursor += 4 # expiryHeight + + has_shielded = False + if is_sapling_v4: + self.cursor += 8 # valueBalance + shielded_spend_size = self._read_varint() + self.cursor += shielded_spend_size * 384 # vShieldedSpend + shielded_output_size = self._read_varint() + self.cursor += shielded_output_size * 948 # vShieldedOutput + has_shielded = shielded_spend_size > 0 or shielded_output_size > 0 + + if base_tx.version >= 2: + joinsplit_size = self._read_varint() + if joinsplit_size > 0: + joinsplit_desc_len = 1506 + (192 if is_sapling_v4 else 296) + # JSDescription + self.cursor += joinsplit_size * joinsplit_desc_len + self.cursor += 32 # joinSplitPubKey + self.cursor += 64 # joinSplitSig + + if is_sapling_v4 and has_shielded: + self.cursor += 64 # bindingSig + + return base_tx + + +class TxTime(namedtuple("Tx", "version time inputs outputs locktime")): + '''Class representing transaction that has a time field.''' + + +class DeserializerTxTime(Deserializer): + def read_tx(self): + return TxTime( + self._read_le_int32(), # version + self._read_le_uint32(), # time + self._read_inputs(), # inputs + self._read_outputs(), # outputs + self._read_le_uint32(), # locktime + ) + + +class DeserializerReddcoin(Deserializer): + def read_tx(self): + version = self._read_le_int32() + inputs = self._read_inputs() + outputs = self._read_outputs() + locktime = self._read_le_uint32() + if version > 1: + time = self._read_le_uint32() + else: + time = 0 + + return TxTime(version, time, inputs, outputs, locktime) + + +class DeserializerTxTimeAuxPow(DeserializerTxTime): + VERSION_AUXPOW = (1 << 8) + + def is_merged_block(self): + start = self.cursor + self.cursor = 0 + version = self._read_le_uint32() + self.cursor = start + if version & self.VERSION_AUXPOW: + return True + return False + + def read_header(self, height, static_header_size): + '''Return the AuxPow block header bytes''' + start = self.cursor + version = self._read_le_uint32() + if version & self.VERSION_AUXPOW: + # We are going to calculate the block size then read it as bytes + self.cursor = start + self.cursor += static_header_size # Block normal header + self.read_tx() # AuxPow transaction + self.cursor += 32 # Parent block hash + merkle_size = self._read_varint() + self.cursor += 32 * merkle_size # Merkle branch + self.cursor += 4 # Index + merkle_size = self._read_varint() + self.cursor += 32 * merkle_size # Chain merkle branch + self.cursor += 4 # Chain index + self.cursor += 80 # Parent block header + header_end = self.cursor + else: + header_end = static_header_size + self.cursor = start + return self._read_nbytes(header_end) + + +class DeserializerBitcoinAtom(DeserializerSegWit): + FORK_BLOCK_HEIGHT = 505888 + + def read_header(self, height, static_header_size): + '''Return the block header bytes''' + header_len = static_header_size + if height >= self.FORK_BLOCK_HEIGHT: + header_len += 4 # flags + return self._read_nbytes(header_len) + + +class DeserializerGroestlcoin(DeserializerSegWit): + TX_HASH_FN = staticmethod(sha256) + + +class TxInputTokenPay(TxInput): + '''Class representing a TokenPay transaction input.''' + + OP_ANON_MARKER = 0xb9 + # 2byte marker (cpubkey + sigc + sigr) + MIN_ANON_IN_SIZE = 2 + (33 + 32 + 32) + + def _is_anon_input(self): + return (len(self.script) >= self.MIN_ANON_IN_SIZE and + self.script[0] == OpCodes.OP_RETURN and + self.script[1] == self.OP_ANON_MARKER) + + def is_generation(self): + # Transactions comming in from stealth addresses are seen by + # the blockchain as newly minted coins. The reverse, where coins + # are sent TO a stealth address, are seen by the blockchain as + # a coin burn. + if self._is_anon_input(): + return True + return super(TxInputTokenPay, self).is_generation() + + +class TxInputTokenPayStealth( + namedtuple("TxInput", "keyimage ringsize script sequence")): + '''Class representing a TokenPay stealth transaction input.''' + + def __str__(self): + script = self.script.hex() + keyimage = bytes(self.keyimage).hex() + return ("Input({}, {:d}, script={}, sequence={:d})" + .format(keyimage, self.ringsize[1], script, self.sequence)) + + def is_generation(self): + return True + + def serialize(self): + return b''.join(( + self.keyimage, + self.ringsize, + pack_varbytes(self.script), + pack_le_uint32(self.sequence), + )) + + +class DeserializerTokenPay(DeserializerTxTime): + + def _read_input(self): + txin = TxInputTokenPay( + self._read_nbytes(32), # prev_hash + self._read_le_uint32(), # prev_idx + self._read_varbytes(), # script + self._read_le_uint32(), # sequence + ) + if txin._is_anon_input(): + # Not sure if this is actually needed, and seems + # extra work for no immediate benefit, but it at + # least correctly represents a stealth input + raw = txin.serialize() + deserializer = Deserializer(raw) + txin = TxInputTokenPayStealth( + deserializer._read_nbytes(33), # keyimage + deserializer._read_nbytes(3), # ringsize + deserializer._read_varbytes(), # script + deserializer._read_le_uint32() # sequence + ) + return txin + + +# Decred +class TxInputDcr(namedtuple("TxInput", "prev_hash prev_idx tree sequence")): + '''Class representing a Decred transaction input.''' + + def __str__(self): + prev_hash = hash_to_hex_str(self.prev_hash) + return ("Input({}, {:d}, tree={}, sequence={:d})" + .format(prev_hash, self.prev_idx, self.tree, self.sequence)) + + def is_generation(self): + '''Test if an input is generation/coinbase like''' + return self.prev_idx == MINUS_1 and self.prev_hash == ZERO + + +class TxOutputDcr(namedtuple("TxOutput", "value version pk_script")): + '''Class representing a Decred transaction output.''' + pass + + +class TxDcr(namedtuple("Tx", "version inputs outputs locktime expiry " + "witness")): + '''Class representing a Decred transaction.''' + + +class DeserializerDecred(Deserializer): + @staticmethod + def blake256(data): + from blake256.blake256 import blake_hash + return blake_hash(data) + + @staticmethod + def blake256d(data): + from blake256.blake256 import blake_hash + return blake_hash(blake_hash(data)) + + def read_tx(self): + return self._read_tx_parts(produce_hash=False)[0] + + def read_tx_and_hash(self): + tx, tx_hash, vsize = self._read_tx_parts() + return tx, tx_hash + + def read_tx_and_vsize(self): + tx, tx_hash, vsize = self._read_tx_parts(produce_hash=False) + return tx, vsize + + def read_tx_block(self): + '''Returns a list of (deserialized_tx, tx_hash) pairs.''' + read = self.read_tx_and_hash + txs = [read() for _ in range(self._read_varint())] + stxs = [read() for _ in range(self._read_varint())] + return txs + stxs + + def read_tx_tree(self): + '''Returns a list of deserialized_tx without tx hashes.''' + read_tx = self.read_tx + return [read_tx() for _ in range(self._read_varint())] + + def _read_input(self): + return TxInputDcr( + self._read_nbytes(32), # prev_hash + self._read_le_uint32(), # prev_idx + self._read_byte(), # tree + self._read_le_uint32(), # sequence + ) + + def _read_output(self): + return TxOutputDcr( + self._read_le_int64(), # value + self._read_le_uint16(), # version + self._read_varbytes(), # pk_script + ) + + def _read_witness(self, fields): + read_witness_field = self._read_witness_field + assert fields == self._read_varint() + return [read_witness_field() for _ in range(fields)] + + def _read_witness_field(self): + value_in = self._read_le_int64() + block_height = self._read_le_uint32() + block_index = self._read_le_uint32() + script = self._read_varbytes() + return value_in, block_height, block_index, script + + def _read_tx_parts(self, produce_hash=True): + start = self.cursor + version = self._read_le_int32() + inputs = self._read_inputs() + outputs = self._read_outputs() + locktime = self._read_le_uint32() + expiry = self._read_le_uint32() + end_prefix = self.cursor + witness = self._read_witness(len(inputs)) + + if produce_hash: + # TxSerializeNoWitness << 16 == 0x10000 + no_witness_header = pack_le_uint32(0x10000 | (version & 0xffff)) + prefix_tx = no_witness_header + self.binary[start+4:end_prefix] + tx_hash = self.blake256(prefix_tx) + else: + tx_hash = None + + return TxDcr( + version, + inputs, + outputs, + locktime, + expiry, + witness + ), tx_hash, self.cursor - start diff --git a/torba/server/util.py b/torba/server/util.py new file mode 100644 index 000000000..37694373c --- /dev/null +++ b/torba/server/util.py @@ -0,0 +1,359 @@ +# Copyright (c) 2016-2017, Neil Booth +# +# All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# and warranty status of this software. + +'''Miscellaneous utility classes and functions.''' + + +import array +import inspect +from ipaddress import ip_address +import logging +import re +import sys +from collections import Container, Mapping +from struct import pack, Struct + +# Logging utilities + + +class ConnectionLogger(logging.LoggerAdapter): + '''Prepends a connection identifier to a logging message.''' + def process(self, msg, kwargs): + conn_id = self.extra.get('conn_id', 'unknown') + return f'[{conn_id}] {msg}', kwargs + + +class CompactFormatter(logging.Formatter): + '''Strips the module from the logger name to leave the class only.''' + def format(self, record): + record.name = record.name.rpartition('.')[-1] + return super().format(record) + + +def make_logger(name, *, handler, level): + '''Return the root ElectrumX logger.''' + logger = logging.getLogger(name) + logger.addHandler(handler) + logger.setLevel(logging.INFO) + logger.propagate = False + return logger + + +def class_logger(path, classname): + '''Return a hierarchical logger for a class.''' + return logging.getLogger(path).getChild(classname) + + +# Method decorator. To be used for calculations that will always +# deliver the same result. The method cannot take any arguments +# and should be accessed as an attribute. +class cachedproperty(object): + + def __init__(self, f): + self.f = f + + def __get__(self, obj, type): + obj = obj or type + value = self.f(obj) + setattr(obj, self.f.__name__, value) + return value + + +def formatted_time(t, sep=' '): + '''Return a number of seconds as a string in days, hours, mins and + maybe secs.''' + t = int(t) + fmts = (('{:d}d', 86400), ('{:02d}h', 3600), ('{:02d}m', 60)) + parts = [] + for fmt, n in fmts: + val = t // n + if parts or val: + parts.append(fmt.format(val)) + t %= n + if len(parts) < 3: + parts.append('{:02d}s'.format(t)) + return sep.join(parts) + + +def deep_getsizeof(obj): + """Find the memory footprint of a Python object. + + Based on code from code.tutsplus.com: http://goo.gl/fZ0DXK + + This is a recursive function that drills down a Python object graph + like a dictionary holding nested dictionaries with lists of lists + and tuples and sets. + + The sys.getsizeof function does a shallow size of only. It counts each + object inside a container as pointer only regardless of how big it + really is. + """ + + ids = set() + + def size(o): + if id(o) in ids: + return 0 + + r = sys.getsizeof(o) + ids.add(id(o)) + + if isinstance(o, (str, bytes, bytearray, array.array)): + return r + + if isinstance(o, Mapping): + return r + sum(size(k) + size(v) for k, v in o.items()) + + if isinstance(o, Container): + return r + sum(size(x) for x in o) + + return r + + return size(obj) + + +def subclasses(base_class, strict=True): + '''Return a list of subclasses of base_class in its module.''' + def select(obj): + return (inspect.isclass(obj) and issubclass(obj, base_class) and + (not strict or obj != base_class)) + + pairs = inspect.getmembers(sys.modules[base_class.__module__], select) + return [pair[1] for pair in pairs] + + +def chunks(items, size): + '''Break up items, an iterable, into chunks of length size.''' + for i in range(0, len(items), size): + yield items[i: i + size] + + +def resolve_limit(limit): + if limit is None: + return -1 + assert isinstance(limit, int) and limit >= 0 + return limit + + +def bytes_to_int(be_bytes): + '''Interprets a big-endian sequence of bytes as an integer''' + return int.from_bytes(be_bytes, 'big') + + +def int_to_bytes(value): + '''Converts an integer to a big-endian sequence of bytes''' + return value.to_bytes((value.bit_length() + 7) // 8, 'big') + + +def increment_byte_string(bs): + '''Return the lexicographically next byte string of the same length. + + Return None if there is none (when the input is all 0xff bytes).''' + for n in range(1, len(bs) + 1): + if bs[-n] != 0xff: + return bs[:-n] + bytes([bs[-n] + 1]) + bytes(n - 1) + return None + + +class LogicalFile(object): + '''A logical binary file split across several separate files on disk.''' + + def __init__(self, prefix, digits, file_size): + digit_fmt = '{' + ':0{:d}d'.format(digits) + '}' + self.filename_fmt = prefix + digit_fmt + self.file_size = file_size + + def read(self, start, size=-1): + '''Read up to size bytes from the virtual file, starting at offset + start, and return them. + + If size is -1 all bytes are read.''' + parts = [] + while size != 0: + try: + with self.open_file(start, False) as f: + part = f.read(size) + if not part: + break + except FileNotFoundError: + break + parts.append(part) + start += len(part) + if size > 0: + size -= len(part) + return b''.join(parts) + + def write(self, start, b): + '''Write the bytes-like object, b, to the underlying virtual file.''' + while b: + size = min(len(b), self.file_size - (start % self.file_size)) + with self.open_file(start, True) as f: + f.write(b if size == len(b) else b[:size]) + b = b[size:] + start += size + + def open_file(self, start, create): + '''Open the virtual file and seek to start. Return a file handle. + Raise FileNotFoundError if the file does not exist and create + is False. + ''' + file_num, offset = divmod(start, self.file_size) + filename = self.filename_fmt.format(file_num) + f = open_file(filename, create) + f.seek(offset) + return f + + +def open_file(filename, create=False): + '''Open the file name. Return its handle.''' + try: + return open(filename, 'rb+') + except FileNotFoundError: + if create: + return open(filename, 'wb+') + raise + + +def open_truncate(filename): + '''Open the file name. Return its handle.''' + return open(filename, 'wb+') + + +def address_string(address): + '''Return an address as a correctly formatted string.''' + fmt = '{}:{:d}' + host, port = address + try: + host = ip_address(host) + except ValueError: + pass + else: + if host.version == 6: + fmt = '[{}]:{:d}' + return fmt.format(host, port) + +# See http://stackoverflow.com/questions/2532053/validate-a-hostname-string +# Note underscores are valid in domain names, but strictly invalid in host +# names. We ignore that distinction. + + +SEGMENT_REGEX = re.compile("(?!-)[A-Z_\\d-]{1,63}(? 255: + return False + # strip exactly one dot from the right, if present + if hostname and hostname[-1] == ".": + hostname = hostname[:-1] + return all(SEGMENT_REGEX.match(x) for x in hostname.split(".")) + + +def protocol_tuple(s): + '''Converts a protocol version number, such as "1.0" to a tuple (1, 0). + + If the version number is bad, (0, ) indicating version 0 is returned.''' + try: + return tuple(int(part) for part in s.split('.')) + except Exception: + return (0, ) + + +def version_string(ptuple): + '''Convert a version tuple such as (1, 2) to "1.2". + There is always at least one dot, so (1, ) becomes "1.0".''' + while len(ptuple) < 2: + ptuple += (0, ) + return '.'.join(str(p) for p in ptuple) + + +def protocol_version(client_req, min_tuple, max_tuple): + '''Given a client's protocol version string, return a pair of + protocol tuples: + + (negotiated version, client min request) + + If the request is unsupported, the negotiated protocol tuple is + None. + ''' + if client_req is None: + client_min = client_max = min_tuple + else: + if isinstance(client_req, list) and len(client_req) == 2: + client_min, client_max = client_req + else: + client_min = client_max = client_req + client_min = protocol_tuple(client_min) + client_max = protocol_tuple(client_max) + + result = min(client_max, max_tuple) + if result < max(client_min, min_tuple) or result == (0, ): + result = None + + return result, client_min + + +struct_le_i = Struct('H') +struct_be_I = Struct('>I') +structB = Struct('B') + +unpack_le_int32_from = struct_le_i.unpack_from +unpack_le_int64_from = struct_le_q.unpack_from +unpack_le_uint16_from = struct_le_H.unpack_from +unpack_le_uint32_from = struct_le_I.unpack_from +unpack_le_uint64_from = struct_le_Q.unpack_from +unpack_be_uint16_from = struct_be_H.unpack_from +unpack_be_uint32_from = struct_be_I.unpack_from + +pack_le_int32 = struct_le_i.pack +pack_le_int64 = struct_le_q.pack +pack_le_uint16 = struct_le_H.pack +pack_le_uint32 = struct_le_I.pack +pack_le_uint64 = struct_le_Q.pack +pack_be_uint16 = struct_be_H.pack +pack_be_uint32 = struct_be_I.pack +pack_byte = structB.pack + +hex_to_bytes = bytes.fromhex + + +def pack_varint(n): + if n < 253: + return pack_byte(n) + if n < 65536: + return pack_byte(253) + pack_le_uint16(n) + if n < 4294967296: + return pack_byte(254) + pack_le_uint32(n) + return pack_byte(255) + pack_le_uint64(n) + + +def pack_varbytes(data): + return pack_varint(len(data)) + data diff --git a/torba/testing/__init__.py b/torba/testing/__init__.py new file mode 100644 index 000000000..7b2ed3e52 --- /dev/null +++ b/torba/testing/__init__.py @@ -0,0 +1 @@ +from .testcase import IntegrationTestCase diff --git a/torba/testing/node.py b/torba/testing/node.py new file mode 100644 index 000000000..e3580814c --- /dev/null +++ b/torba/testing/node.py @@ -0,0 +1,344 @@ +import os +import sys +import shutil +import asyncio +import zipfile +import tarfile +import logging +import tempfile +import subprocess +import importlib +import requests +from binascii import hexlify +from typing import Type + +from torba.server.server import Server +from torba.server.env import Env +from torba.wallet import Wallet +from torba.baseledger import BaseLedger, BlockHeightEvent +from torba.basemanager import BaseWalletManager +from torba.baseaccount import BaseAccount + +root = logging.getLogger() +ch = logging.StreamHandler(sys.stdout) +formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') +ch.setFormatter(formatter) +root.addHandler(ch) + + +def get_manager_from_environment(default_manager=BaseWalletManager): + if 'TORBA_MANAGER' not in os.environ: + return default_manager + module_name = os.environ['TORBA_MANAGER'].split('-')[-1] # tox support + return importlib.import_module(module_name) + + +def get_ledger_from_environment(): + if 'TORBA_LEDGER' not in os.environ: + raise ValueError('Environment variable TORBA_LEDGER must point to a torba based ledger module.') + module_name = os.environ['TORBA_LEDGER'].split('-')[-1] # tox support + return importlib.import_module(module_name) + + +def get_spvserver_from_ledger(ledger_module): + spvserver_path, regtest_class_name = ledger_module.__spvserver__.rsplit('.', 1) + spvserver_module = importlib.import_module(spvserver_path) + return getattr(spvserver_module, regtest_class_name) + + +def get_blockchain_node_from_ledger(ledger_module): + return BlockchainNode( + ledger_module.__node_url__, + os.path.join(ledger_module.__node_bin__, ledger_module.__node_daemon__), + os.path.join(ledger_module.__node_bin__, ledger_module.__node_cli__) + ) + + +def set_logging(ledger_module, level): + logging.getLogger('torba').setLevel(level) + logging.getLogger('torba.server').setLevel(level) + #logging.getLogger('asyncio').setLevel(level) + logging.getLogger('blockchain').setLevel(level) + logging.getLogger(ledger_module.__name__).setLevel(level) + + +class Conductor: + + def __init__(self, ledger_module=None, manager_module=None, verbosity=logging.WARNING): + self.ledger_module = ledger_module or get_ledger_from_environment() + self.manager_module = manager_module or get_manager_from_environment() + self.spv_module = get_spvserver_from_ledger(self.ledger_module) + + self.blockchain_node = get_blockchain_node_from_ledger(self.ledger_module) + self.spv_node = SPVNode(self.spv_module) + self.wallet_node = WalletNode(self.manager_module, self.ledger_module.RegTestLedger) + + set_logging(self.ledger_module, verbosity) + + self.blockchain_started = False + self.spv_started = False + self.wallet_started = False + + async def start_blockchain(self): + await self.blockchain_node.start() + await self.blockchain_node.generate(200) + self.blockchain_started = True + + async def start_spv(self): + await self.spv_node.start() + self.spv_started = True + + async def start_wallet(self): + await self.wallet_node.start() + self.wallet_started = True + + async def start(self): + self.blockchain_started or await self.start_blockchain() + self.spv_started or await self.start_spv() + self.wallet_started or await self.start_wallet() + + async def stop(self): + if self.wallet_started: + try: + await self.wallet_node.stop(cleanup=True) + except Exception as e: + print(e) + if self.spv_started: + try: + await self.spv_node.stop(cleanup=True) + except Exception as e: + print(e) + if self.blockchain_started: + try: + await self.blockchain_node.stop(cleanup=True) + except Exception as e: + print(e) + + +class WalletNode: + + def __init__(self, manager_class: Type[BaseWalletManager], ledger_class: Type[BaseLedger], + verbose: bool = False) -> None: + self.manager_class = manager_class + self.ledger_class = ledger_class + self.verbose = verbose + self.manager: BaseWalletManager = None + self.ledger: BaseLedger = None + self.wallet: Wallet = None + self.account: BaseAccount = None + self.data_path: str = None + + async def start(self): + self.data_path = tempfile.mkdtemp() + wallet_file_name = os.path.join(self.data_path, 'my_wallet.json') + with open(wallet_file_name, 'w') as wf: + wf.write('{"version": 1, "accounts": []}\n') + self.manager = self.manager_class.from_config({ + 'ledgers': { + self.ledger_class.get_id(): { + 'default_servers': [('localhost', 1984)], + 'data_path': self.data_path + } + }, + 'wallets': [wallet_file_name] + }) + self.ledger = self.manager.ledgers[self.ledger_class] + self.wallet = self.manager.default_wallet + self.wallet.generate_account(self.ledger) + self.account = self.wallet.default_account + await self.manager.start() + + async def stop(self, cleanup=True): + try: + await self.manager.stop() + finally: + cleanup and self.cleanup() + + def cleanup(self): + shutil.rmtree(self.data_path, ignore_errors=True) + + +class SPVNode: + + def __init__(self, coin_class): + self.coin_class = coin_class + self.controller = None + self.data_path = None + + async def start(self): + self.data_path = tempfile.mkdtemp() + conf = { + 'DB_DIRECTORY': self.data_path, + 'DAEMON_URL': 'http://rpcuser:rpcpassword@localhost:50001/', + 'REORG_LIMIT': '100', + 'TCP_PORT': '1984' + } + os.environ.update(conf) + self.server = Server(Env(self.coin_class)) + await self.server.start() + + async def stop(self, cleanup=True): + try: + await self.controller.shutdown() + finally: + cleanup and self.cleanup() + + def cleanup(self): + shutil.rmtree(self.data_path, ignore_errors=True) + + +class BlockchainProcess(asyncio.SubprocessProtocol): + + IGNORE_OUTPUT = [ + b'keypool keep', + b'keypool reserve', + b'keypool return', + ] + + def __init__(self, log): + self.ready = asyncio.Event() + self.stopped = asyncio.Event() + self.log = log + + def pipe_data_received(self, fd, data): + if self.log and not any(ignore in data for ignore in self.IGNORE_OUTPUT): + if b'Error:' in data: + self.log.error(data.decode('ascii')) + else: + self.log.info(data.decode('ascii')) + if b'Error:' in data: + self.ready.set() + raise SystemError(data.decode('ascii')) + elif b'Done loading' in data: + self.ready.set() + elif b'Shutdown: done' in data: + self.stopped.set() + + def process_exited(self): + self.stopped.set() + + +class BlockchainNode: + + def __init__(self, url, daemon, cli): + self.latest_release_url = url + self.project_dir = os.path.dirname(os.path.dirname(__file__)) + self.bin_dir = os.path.join(self.project_dir, 'bin') + self.daemon_bin = os.path.join(self.bin_dir, daemon) + self.cli_bin = os.path.join(self.bin_dir, cli) + self.log = logging.getLogger('blockchain') + self.data_path = None + self.protocol = None + self.transport = None + self._block_expected = 0 + + def is_expected_block(self, e: BlockHeightEvent): + return self._block_expected == e.height + + @property + def exists(self): + return ( + os.path.exists(self.cli_bin) and + os.path.exists(self.daemon_bin) + ) + + def download(self): + downloaded_file = os.path.join( + self.bin_dir, + self.latest_release_url[self.latest_release_url.rfind('/')+1:] + ) + + if not os.path.exists(self.bin_dir): + os.mkdir(self.bin_dir) + + if not os.path.exists(downloaded_file): + self.log.info('Downloading: %s', self.latest_release_url) + r = requests.get(self.latest_release_url, stream=True) + with open(downloaded_file, 'wb') as f: + shutil.copyfileobj(r.raw, f) + + self.log.info('Extracting: %s', downloaded_file) + + if downloaded_file.endswith('.zip'): + with zipfile.ZipFile(downloaded_file) as zf: + zf.extractall(self.bin_dir) + # zipfile bug https://bugs.python.org/issue15795 + os.chmod(self.cli_bin, 0o755) + os.chmod(self.daemon_bin, 0o755) + + elif downloaded_file.endswith('.tar.gz'): + with tarfile.open(downloaded_file) as tar: + tar.extractall(self.bin_dir) + + return self.exists + + def ensure(self): + return self.exists or self.download() + + async def start(self): + assert self.ensure() + self.data_path = tempfile.mkdtemp() + loop = asyncio.get_event_loop() + asyncio.get_child_watcher().attach_loop(loop) + command = ( + self.daemon_bin, + '-datadir={}'.format(self.data_path), + '-printtoconsole', '-regtest', '-server', '-txindex', + '-rpcuser=rpcuser', '-rpcpassword=rpcpassword', '-rpcport=50001' + ) + self.log.info(' '.join(command)) + self.transport, self.protocol = await loop.subprocess_exec( + lambda: BlockchainProcess(self.log), *command + ) + await self.protocol.ready.wait() + + async def stop(self, cleanup=True): + try: + self.transport.terminate() + await self.protocol.stopped.wait() + finally: + if cleanup: + self.cleanup() + + def cleanup(self): + shutil.rmtree(self.data_path, ignore_errors=True) + + async def _cli_cmnd(self, *args): + cmnd_args = [ + self.cli_bin, '-datadir={}'.format(self.data_path), '-regtest', + '-rpcuser=rpcuser', '-rpcpassword=rpcpassword', '-rpcport=50001' + ] + list(args) + self.log.info(' '.join(cmnd_args)) + loop = asyncio.get_event_loop() + asyncio.get_child_watcher().attach_loop(loop) + process = await asyncio.create_subprocess_exec( + *cmnd_args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT + ) + out, err = await process.communicate() + self.log.info(out.decode().strip()) + return out.decode().strip() + + def generate(self, blocks): + self._block_expected += blocks + return self._cli_cmnd('generate', str(blocks)) + + def invalidateblock(self, hash): + return self._cli_cmnd('invalidateblock', hash) + + def get_raw_change_address(self): + return self._cli_cmnd('getrawchangeaddress') + + async def get_balance(self): + return float(await self._cli_cmnd('getbalance')) + + def send_to_address(self, address, credits): + return self._cli_cmnd('sendtoaddress', address, str(credits)) + + def send_raw_transaction(self, tx): + return self._cli_cmnd('sendrawtransaction', tx.decode()) + + def decode_raw_transaction(self, tx): + return self._cli_cmnd('decoderawtransaction', hexlify(tx.raw).decode()) + + def get_raw_transaction(self, txid): + return self._cli_cmnd('getrawtransaction', txid, '1') diff --git a/torba/testing/service.py b/torba/testing/service.py new file mode 100644 index 000000000..29806cd65 --- /dev/null +++ b/torba/testing/service.py @@ -0,0 +1,147 @@ +import asyncio +import logging +from aiohttp.web import Application, WebSocketResponse, json_response +from aiohttp.http_websocket import WSMsgType, WSCloseCode +from .node import Conductor + + +PORT = 7954 + + +class WebSocketLogHandler(logging.Handler): + + def __init__(self, send_message): + super().__init__() + self.send_message = send_message + + def emit(self, record): + try: + self.send_message({ + 'type': 'log', + 'name': record.name, + 'message': self.format(record) + }) + except Exception: + self.handleError(record) + + +class TestingServiceAPI: + + def __init__(self, stack: Conductor, loop: asyncio.AbstractEventLoop): + self.stack = stack + self.loop = loop + self.app = Application() + self.app.router.add_post('/start', self.start_stack) + self.app.router.add_post('/generate', self.generate) + self.app.router.add_post('/transfer', self.transfer) + self.app.router.add_post('/balance', self.balance) + self.app.router.add_get('/log', self.log) + self.app['websockets'] = set() + self.app.on_shutdown.append(self.on_shutdown) + self.handler = self.app.make_handler() + self.server = None + + async def start(self): + self.server = await self.loop.create_server( + self.handler, '0.0.0.0', PORT + ) + print('serving on', self.server.sockets[0].getsockname()) + + async def stop(self): + await self.stack.stop() + self.server.close() + await self.server.wait_closed() + await self.app.shutdown() + await self.handler.shutdown(60.0) + await self.app.cleanup() + + async def start_stack(self, _): + handler = WebSocketLogHandler(self.send_message) + logging.getLogger('blockchain').setLevel(logging.DEBUG) + logging.getLogger('blockchain').addHandler(handler) + logging.getLogger('electrumx').setLevel(logging.DEBUG) + logging.getLogger('electrumx').addHandler(handler) + logging.getLogger('Controller').setLevel(logging.DEBUG) + logging.getLogger('Controller').addHandler(handler) + logging.getLogger('LBRYBlockProcessor').setLevel(logging.DEBUG) + logging.getLogger('LBRYBlockProcessor').addHandler(handler) + logging.getLogger('LBCDaemon').setLevel(logging.DEBUG) + logging.getLogger('LBCDaemon').addHandler(handler) + logging.getLogger('torba').setLevel(logging.DEBUG) + logging.getLogger('torba').addHandler(handler) + logging.getLogger(self.stack.ledger_module.__name__).setLevel(logging.DEBUG) + logging.getLogger(self.stack.ledger_module.__name__).addHandler(handler) + logging.getLogger(self.stack.ledger_module.__electrumx__.split('.')[0]).setLevel(logging.DEBUG) + logging.getLogger(self.stack.ledger_module.__electrumx__.split('.')[0]).addHandler(handler) + #await self.stack.start() + self.stack.blockchain_started or await self.stack.start_blockchain() + self.send_message({'type': 'service', 'name': 'blockchain'}) + self.stack.spv_started or await self.stack.start_spv() + self.send_message({'type': 'service', 'name': 'spv'}) + self.stack.wallet_started or await self.stack.start_wallet() + self.send_message({'type': 'service', 'name': 'wallet'}) + self.stack.wallet_node.ledger.on_header.listen(self.on_status) + self.stack.wallet_node.ledger.on_transaction.listen(self.on_status) + return json_response({'started': True}) + + async def generate(self, request): + data = await request.post() + blocks = data.get('blocks', 1) + await self.stack.blockchain_node.generate(int(blocks)) + return json_response({'blocks': blocks}) + + async def transfer(self, request): + data = await request.post() + address = data.get('address') + if not address: + address = await self.stack.wallet_node.account.receiving.get_or_create_usable_address() + amount = data.get('amount', 1) + txid = await self.stack.blockchain_node.send_to_address(address, amount) + await self.stack.wallet_node.ledger.on_transaction.where( + lambda e: e.tx.id == txid and e.address == address + ) + return json_response({ + 'address': address, + 'amount': amount, + 'txid': txid + }) + + async def balance(self, _): + return json_response({ + 'balance': await self.stack.blockchain_node.get_balance() + }) + + async def log(self, request): + ws = WebSocketResponse() + await ws.prepare(request) + self.app['websockets'].add(ws) + try: + async for msg in ws: + if msg.type == WSMsgType.TEXT: + if msg.data == 'close': + await ws.close() + elif msg.type == WSMsgType.ERROR: + print('ws connection closed with exception %s' % + ws.exception()) + finally: + self.app['websockets'].remove(ws) + return ws + + @staticmethod + async def on_shutdown(app): + for ws in app['websockets']: + await ws.close(code=WSCloseCode.GOING_AWAY, message='Server shutdown') + + async def on_status(self, _): + if not self.app['websockets']: + return + self.send_message({ + 'type': 'status', + 'height': self.stack.wallet_node.ledger.headers.height, + 'balance': await self.stack.wallet_node.account.get_balance(), + 'miner': await self.stack.blockchain_node.get_balance() + }) + + def send_message(self, msg): + for ws in self.app['websockets']: + asyncio.ensure_future(ws.send_json(msg)) diff --git a/torba/testing/testcase.py b/torba/testing/testcase.py new file mode 100644 index 000000000..00ac9b112 --- /dev/null +++ b/torba/testing/testcase.py @@ -0,0 +1,176 @@ +import asyncio +import unittest +import logging +from unittest.case import _Outcome +from .node import Conductor + + +try: + from asyncio.runners import _cancel_all_tasks +except ImportError: + # this is only available in py3.7 + def _cancel_all_tasks(loop): + pass + + +class AsyncioTestCase(unittest.TestCase): + # Implementation inspired by discussion: + # https://bugs.python.org/issue32972 + + async def asyncSetUp(self): + pass + + async def asyncTearDown(self): + pass + + async def doAsyncCleanups(self): + pass + + def run(self, result=None): + orig_result = result + if result is None: + result = self.defaultTestResult() + startTestRun = getattr(result, 'startTestRun', None) + if startTestRun is not None: + startTestRun() + + result.startTest(self) + + testMethod = getattr(self, self._testMethodName) + if (getattr(self.__class__, "__unittest_skip__", False) or + getattr(testMethod, "__unittest_skip__", False)): + # If the class or method was skipped. + try: + skip_why = (getattr(self.__class__, '__unittest_skip_why__', '') + or getattr(testMethod, '__unittest_skip_why__', '')) + self._addSkip(result, self, skip_why) + finally: + result.stopTest(self) + return + expecting_failure_method = getattr(testMethod, + "__unittest_expecting_failure__", False) + expecting_failure_class = getattr(self, + "__unittest_expecting_failure__", False) + expecting_failure = expecting_failure_class or expecting_failure_method + outcome = _Outcome(result) + try: + self._outcome = outcome + + loop = asyncio.new_event_loop() + try: + asyncio.set_event_loop(loop) + loop.set_debug(True) + + with outcome.testPartExecutor(self): + self.setUp() + loop.run_until_complete(self.asyncSetUp()) + if outcome.success: + outcome.expecting_failure = expecting_failure + with outcome.testPartExecutor(self, isTest=True): + possible_coroutine = testMethod() + if asyncio.iscoroutine(possible_coroutine): + loop.run_until_complete(possible_coroutine) + outcome.expecting_failure = False + with outcome.testPartExecutor(self): + loop.run_until_complete(self.asyncTearDown()) + self.tearDown() + finally: + try: + _cancel_all_tasks(loop) + loop.run_until_complete(loop.shutdown_asyncgens()) + finally: + asyncio.set_event_loop(None) + loop.close() + + self.doCleanups() + + for test, reason in outcome.skipped: + self._addSkip(result, test, reason) + self._feedErrorsToResult(result, outcome.errors) + if outcome.success: + if expecting_failure: + if outcome.expectedFailure: + self._addExpectedFailure(result, outcome.expectedFailure) + else: + self._addUnexpectedSuccess(result) + else: + result.addSuccess(self) + return result + finally: + result.stopTest(self) + if orig_result is None: + stopTestRun = getattr(result, 'stopTestRun', None) + if stopTestRun is not None: + stopTestRun() + + # explicitly break reference cycles: + # outcome.errors -> frame -> outcome -> outcome.errors + # outcome.expectedFailure -> frame -> outcome -> outcome.expectedFailure + outcome.errors.clear() + outcome.expectedFailure = None + + # clear the outcome, no more needed + self._outcome = None + + +class IntegrationTestCase(AsyncioTestCase): + + LEDGER = None + MANAGER = None + VERBOSITY = logging.WARNING + + async def asyncSetUp(self): + self.conductor = Conductor( + ledger_module=self.LEDGER, manager_module=self.MANAGER, verbosity=self.VERBOSITY + ) + await self.conductor.start() + self.blockchain = self.conductor.blockchain_node + self.manager = self.conductor.wallet_node.manager + self.ledger = self.conductor.wallet_node.ledger + self.wallet = self.conductor.wallet_node.wallet + self.account = self.conductor.wallet_node.wallet.default_account + + async def asyncTearDown(self): + await self.conductor.stop() + + def broadcast(self, tx): + return self.ledger.broadcast(tx) + + def get_balance(self, account=None, confirmations=0): + if account is None: + return self.manager.get_balance(confirmations=confirmations) + else: + return account.get_balance(confirmations=confirmations) + + async def on_header(self, height): + if self.ledger.headers.height < height: + await self.ledger.on_header.where( + lambda e: e.height == height + ) + return True + + def on_transaction_id(self, txid): + return self.ledger.on_transaction.where( + lambda e: e.tx.id == txid + ) + + def on_transaction_address(self, tx, address): + return self.ledger.on_transaction.where( + lambda e: e.tx.id == tx.id and e.address == address + ) + + async def on_transaction(self, tx): + addresses = await self.get_tx_addresses(tx, self.ledger) + await asyncio.wait([ + self.ledger.on_transaction.where(lambda e: e.address == address) + for address in addresses + ]) + + async def get_tx_addresses(self, tx, ledger): + addresses = set() + for txo in tx.outputs: + address = ledger.hash160_to_address(txo.script.values['pubkey_hash']) + record = await ledger.db.get_address(address=address) + if record is not None: + addresses.add(address) + return list(addresses) diff --git a/tox.ini b/tox.ini index f7658651e..bda7daf51 100644 --- a/tox.ini +++ b/tox.ini @@ -8,17 +8,14 @@ TESTTYPE = integration: integration [testenv] -deps = - coverage - ../orchstr8 - ../electrumx -extras = test +deps = coverage +extras = test,server changedir = {toxinidir}/tests setenv = - integration: LEDGER={envname} + integration: TORBA_LEDGER={envname} commands = unit: coverage run -p --source={envsitepackagesdir}/torba -m unittest discover -t . unit - integration: orchstr8 download + integration: torba download integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest integration.test_transactions integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest integration.test_reconnect # Too slow on Travis From 48d7bfd225f7d17f430f83eb4f3ae118303f785a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 3 Nov 2018 19:45:28 -0400 Subject: [PATCH 216/383] pylint and mypy fixes --- setup.cfg | 5 +++-- torba/cli.py | 6 +++--- torba/testing/node.py | 45 +++++++++++++++++---------------------- torba/testing/service.py | 28 ++++++++++++------------ torba/testing/testcase.py | 31 +++++++++++++++++---------- 5 files changed, 60 insertions(+), 55 deletions(-) diff --git a/setup.cfg b/setup.cfg index 9a037263d..60a6219bf 100644 --- a/setup.cfg +++ b/setup.cfg @@ -6,17 +6,18 @@ source = torba .tox/*/lib/python*/site-packages/torba -[mypy-twisted.*,cryptography.*,coincurve.*,pbkdf2] +[cryptography.*,coincurve.*,pbkdf2] ignore_missing_imports = True [pylint] -ignore=words,server +ignore=words,server,workbench max-args=10 max-line-length=110 good-names=T,t,n,i,j,k,x,y,s,f,d,h,c,e,op,db,tx,io,cachedproperty,log,id valid-metaclass-classmethod-first-arg=mcs disable= fixme, + broad-except, no-else-return, cyclic-import, missing-docstring, diff --git a/torba/cli.py b/torba/cli.py index 17d293737..981e9698e 100644 --- a/torba/cli.py +++ b/torba/cli.py @@ -13,9 +13,9 @@ def get_argument_parser(): ) subparsers = parser.add_subparsers(dest='command', help='sub-command help') - gui = subparsers.add_parser("gui", help="Start Qt GUI.") + subparsers.add_parser("gui", help="Start Qt GUI.") - download = subparsers.add_parser("download", help="Download blockchain node binary.") + subparsers.add_parser("download", help="Download blockchain node binary.") start = subparsers.add_parser("start", help="Start orchstr8 service.") start.add_argument("--blockchain", help="Start blockchain node.", action="store_true") @@ -25,7 +25,7 @@ def get_argument_parser(): generate = subparsers.add_parser("generate", help="Call generate method on running orchstr8 instance.") generate.add_argument("blocks", type=int, help="Number of blocks to generate") - transfer = subparsers.add_parser("transfer", help="Call transfer method on running orchstr8 instance.") + subparsers.add_parser("transfer", help="Call transfer method on running orchstr8 instance.") return parser diff --git a/torba/testing/node.py b/torba/testing/node.py index e3580814c..14cf2e8d8 100644 --- a/torba/testing/node.py +++ b/torba/testing/node.py @@ -1,5 +1,4 @@ import os -import sys import shutil import asyncio import zipfile @@ -8,9 +7,10 @@ import logging import tempfile import subprocess import importlib -import requests from binascii import hexlify -from typing import Type +from typing import Type, Optional + +import requests from torba.server.server import Server from torba.server.env import Env @@ -19,12 +19,6 @@ from torba.baseledger import BaseLedger, BlockHeightEvent from torba.basemanager import BaseWalletManager from torba.baseaccount import BaseAccount -root = logging.getLogger() -ch = logging.StreamHandler(sys.stdout) -formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') -ch.setFormatter(formatter) -root.addHandler(ch) - def get_manager_from_environment(default_manager=BaseWalletManager): if 'TORBA_MANAGER' not in os.environ: @@ -122,17 +116,17 @@ class WalletNode: self.manager_class = manager_class self.ledger_class = ledger_class self.verbose = verbose - self.manager: BaseWalletManager = None - self.ledger: BaseLedger = None - self.wallet: Wallet = None - self.account: BaseAccount = None - self.data_path: str = None + self.manager: Optional[BaseWalletManager] = None + self.ledger: Optional[BaseLedger] = None + self.wallet: Optional[Wallet] = None + self.account: Optional[BaseAccount] = None + self.data_path: Optional[str] = None async def start(self): self.data_path = tempfile.mkdtemp() wallet_file_name = os.path.join(self.data_path, 'my_wallet.json') - with open(wallet_file_name, 'w') as wf: - wf.write('{"version": 1, "accounts": []}\n') + with open(wallet_file_name, 'w') as wallet_file: + wallet_file.write('{"version": 1, "accounts": []}\n') self.manager = self.manager_class.from_config({ 'ledgers': { self.ledger_class.get_id(): { @@ -164,6 +158,7 @@ class SPVNode: self.coin_class = coin_class self.controller = None self.data_path = None + self.server = None async def start(self): self.data_path = tempfile.mkdtemp() @@ -253,15 +248,15 @@ class BlockchainNode: if not os.path.exists(downloaded_file): self.log.info('Downloading: %s', self.latest_release_url) - r = requests.get(self.latest_release_url, stream=True) + response = requests.get(self.latest_release_url, stream=True) with open(downloaded_file, 'wb') as f: - shutil.copyfileobj(r.raw, f) + shutil.copyfileobj(response.raw, f) self.log.info('Extracting: %s', downloaded_file) if downloaded_file.endswith('.zip'): - with zipfile.ZipFile(downloaded_file) as zf: - zf.extractall(self.bin_dir) + with zipfile.ZipFile(downloaded_file) as dotzip: + dotzip.extractall(self.bin_dir) # zipfile bug https://bugs.python.org/issue15795 os.chmod(self.cli_bin, 0o755) os.chmod(self.daemon_bin, 0o755) @@ -314,7 +309,7 @@ class BlockchainNode: process = await asyncio.create_subprocess_exec( *cmnd_args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT ) - out, err = await process.communicate() + out, _ = await process.communicate() self.log.info(out.decode().strip()) return out.decode().strip() @@ -322,8 +317,8 @@ class BlockchainNode: self._block_expected += blocks return self._cli_cmnd('generate', str(blocks)) - def invalidateblock(self, hash): - return self._cli_cmnd('invalidateblock', hash) + def invalidateblock(self, blockhash): + return self._cli_cmnd('invalidateblock', blockhash) def get_raw_change_address(self): return self._cli_cmnd('getrawchangeaddress') @@ -331,8 +326,8 @@ class BlockchainNode: async def get_balance(self): return float(await self._cli_cmnd('getbalance')) - def send_to_address(self, address, credits): - return self._cli_cmnd('sendtoaddress', address, str(credits)) + def send_to_address(self, address, amount): + return self._cli_cmnd('sendtoaddress', address, str(amount)) def send_raw_transaction(self, tx): return self._cli_cmnd('sendrawtransaction', tx.decode()) diff --git a/torba/testing/service.py b/torba/testing/service.py index 29806cd65..1deaa0fc1 100644 --- a/torba/testing/service.py +++ b/torba/testing/service.py @@ -27,7 +27,7 @@ class WebSocketLogHandler(logging.Handler): class TestingServiceAPI: - def __init__(self, stack: Conductor, loop: asyncio.AbstractEventLoop): + def __init__(self, stack: Conductor, loop: asyncio.AbstractEventLoop) -> None: self.stack = stack self.loop = loop self.app = Application() @@ -112,25 +112,25 @@ class TestingServiceAPI: }) async def log(self, request): - ws = WebSocketResponse() - await ws.prepare(request) - self.app['websockets'].add(ws) + web_socket = WebSocketResponse() + await web_socket.prepare(request) + self.app['websockets'].add(web_socket) try: - async for msg in ws: + async for msg in web_socket: if msg.type == WSMsgType.TEXT: if msg.data == 'close': - await ws.close() + await web_socket.close() elif msg.type == WSMsgType.ERROR: - print('ws connection closed with exception %s' % - ws.exception()) + print('web socket connection closed with exception %s' % + web_socket.exception()) finally: - self.app['websockets'].remove(ws) - return ws + self.app['websockets'].remove(web_socket) + return web_socket @staticmethod async def on_shutdown(app): - for ws in app['websockets']: - await ws.close(code=WSCloseCode.GOING_AWAY, message='Server shutdown') + for web_socket in app['websockets']: + await web_socket.close(code=WSCloseCode.GOING_AWAY, message='Server shutdown') async def on_status(self, _): if not self.app['websockets']: @@ -143,5 +143,5 @@ class TestingServiceAPI: }) def send_message(self, msg): - for ws in self.app['websockets']: - asyncio.ensure_future(ws.send_json(msg)) + for web_socket in self.app['websockets']: + asyncio.ensure_future(web_socket.send_json(msg)) diff --git a/torba/testing/testcase.py b/torba/testing/testcase.py index 00ac9b112..8f2772c49 100644 --- a/torba/testing/testcase.py +++ b/torba/testing/testcase.py @@ -1,12 +1,12 @@ import asyncio -import unittest import logging +import unittest from unittest.case import _Outcome from .node import Conductor try: - from asyncio.runners import _cancel_all_tasks + from asyncio.runners import _cancel_all_tasks # pylint: disable=C0412 except ImportError: # this is only available in py3.7 def _cancel_all_tasks(loop): @@ -17,26 +17,26 @@ class AsyncioTestCase(unittest.TestCase): # Implementation inspired by discussion: # https://bugs.python.org/issue32972 - async def asyncSetUp(self): + async def asyncSetUp(self): # pylint: disable=C0103 pass - async def asyncTearDown(self): + async def asyncTearDown(self): # pylint: disable=C0103 pass - async def doAsyncCleanups(self): + async def doAsyncCleanups(self): # pylint: disable=C0103 pass - def run(self, result=None): + def run(self, result=None): # pylint: disable=R0915 orig_result = result if result is None: result = self.defaultTestResult() - startTestRun = getattr(result, 'startTestRun', None) + startTestRun = getattr(result, 'startTestRun', None) # pylint: disable=C0103 if startTestRun is not None: startTestRun() result.startTest(self) - testMethod = getattr(self, self._testMethodName) + testMethod = getattr(self, self._testMethodName) # pylint: disable=C0103 if (getattr(self.__class__, "__unittest_skip__", False) or getattr(testMethod, "__unittest_skip__", False)): # If the class or method was skipped. @@ -99,9 +99,9 @@ class AsyncioTestCase(unittest.TestCase): finally: result.stopTest(self) if orig_result is None: - stopTestRun = getattr(result, 'stopTestRun', None) + stopTestRun = getattr(result, 'stopTestRun', None) # pylint: disable=C0103 if stopTestRun is not None: - stopTestRun() + stopTestRun() # pylint: disable=E1102 # explicitly break reference cycles: # outcome.errors -> frame -> outcome -> outcome.errors @@ -119,6 +119,15 @@ class IntegrationTestCase(AsyncioTestCase): MANAGER = None VERBOSITY = logging.WARNING + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.conductor = None + self.blockchain = None + self.manager = None + self.ledger = None + self.wallet = None + self.account = None + async def asyncSetUp(self): self.conductor = Conductor( ledger_module=self.LEDGER, manager_module=self.MANAGER, verbosity=self.VERBOSITY @@ -162,7 +171,7 @@ class IntegrationTestCase(AsyncioTestCase): async def on_transaction(self, tx): addresses = await self.get_tx_addresses(tx, self.ledger) await asyncio.wait([ - self.ledger.on_transaction.where(lambda e: e.address == address) + self.ledger.on_transaction.where(lambda e: e.address == address) # pylint: disable=W0640 for address in addresses ]) From 77d8c68b13401df8dfe55b2620fc6fde032dfad7 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 3 Nov 2018 19:55:20 -0400 Subject: [PATCH 217/383] pylint disable workbench check for now --- torba/cli.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/cli.py b/torba/cli.py index 981e9698e..cc12527e9 100644 --- a/torba/cli.py +++ b/torba/cli.py @@ -42,7 +42,7 @@ def main(): command = getattr(args, 'command', 'help') if command == 'gui': - from torba.workbench import main as start_app + from torba.workbench import main as start_app # pylint: disable=E0611,E0401 return start_app() loop = asyncio.get_event_loop() From f0e1fc1a49befb1fce1f1651515048cbcb5d9570 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 3 Nov 2018 20:07:23 -0400 Subject: [PATCH 218/383] more pylint and mypy fixes --- .travis.yml | 2 +- torba/testing/testcase.py | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 3169a13fc..105b20b43 100644 --- a/.travis.yml +++ b/.travis.yml @@ -11,7 +11,7 @@ jobs: install: - pip install git+https://github.com/PyCQA/pylint.git - pip install mypy - - pip install -e . + - pip install -e .[test,server] script: - pylint --rcfile=setup.cfg torba - mypy --ignore-missing-imports torba diff --git a/torba/testing/testcase.py b/torba/testing/testcase.py index 8f2772c49..277cdf47a 100644 --- a/torba/testing/testcase.py +++ b/torba/testing/testcase.py @@ -1,4 +1,3 @@ -import asyncio import logging import unittest from unittest.case import _Outcome @@ -6,8 +5,11 @@ from .node import Conductor try: - from asyncio.runners import _cancel_all_tasks # pylint: disable=C0412 + import asyncio + from asyncio.runners import _cancel_all_tasks # type: ignore except ImportError: + import asyncio + # this is only available in py3.7 def _cancel_all_tasks(loop): pass From 5cdda0f3a838ba0bb5f556e891cdd59fcc1165a4 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 3 Nov 2018 20:13:07 -0400 Subject: [PATCH 219/383] fix AsyncTestCase imports --- tests/unit/test_account.py | 2 +- tests/unit/test_bip32.py | 2 +- tests/unit/test_coinselection.py | 2 +- tests/unit/test_database.py | 2 +- tests/unit/test_headers.py | 2 +- tests/unit/test_transaction.py | 2 +- tests/unit/test_wallet.py | 2 +- torba/testing/__init__.py | 2 +- 8 files changed, 8 insertions(+), 8 deletions(-) diff --git a/tests/unit/test_account.py b/tests/unit/test_account.py index 347c0f843..f99ea60b7 100644 --- a/tests/unit/test_account.py +++ b/tests/unit/test_account.py @@ -1,6 +1,6 @@ from binascii import hexlify -from orchstr8.testcase import AsyncioTestCase +from torba.testing import AsyncioTestCase from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class from torba.baseaccount import HierarchicalDeterministic, SingleKey diff --git a/tests/unit/test_bip32.py b/tests/unit/test_bip32.py index 1d3229f09..7ef4d74fa 100644 --- a/tests/unit/test_bip32.py +++ b/tests/unit/test_bip32.py @@ -1,6 +1,6 @@ from binascii import unhexlify, hexlify -from orchstr8.testcase import AsyncioTestCase +from torba.testing import AsyncioTestCase from .key_fixtures import expected_ids, expected_privkeys, expected_hardened_privkeys from torba.bip32 import PubKey, PrivateKey, from_extended_key_string diff --git a/tests/unit/test_coinselection.py b/tests/unit/test_coinselection.py index fc54639db..196d7aed0 100644 --- a/tests/unit/test_coinselection.py +++ b/tests/unit/test_coinselection.py @@ -1,6 +1,6 @@ from types import GeneratorType -from orchstr8.testcase import AsyncioTestCase +from torba.testing import AsyncioTestCase from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class from torba.coinselection import CoinSelector, MAXIMUM_TRIES diff --git a/tests/unit/test_database.py b/tests/unit/test_database.py index d6fcc564e..a55aba8a1 100644 --- a/tests/unit/test_database.py +++ b/tests/unit/test_database.py @@ -5,7 +5,7 @@ from torba.constants import COIN from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class from torba.basedatabase import query, constraints_to_sql -from orchstr8.testcase import AsyncioTestCase +from torba.testing import AsyncioTestCase from .test_transaction import get_output, NULL_HASH diff --git a/tests/unit/test_headers.py b/tests/unit/test_headers.py index 46489e733..dacb7832e 100644 --- a/tests/unit/test_headers.py +++ b/tests/unit/test_headers.py @@ -1,7 +1,7 @@ import os from urllib.request import Request, urlopen -from orchstr8.testcase import AsyncioTestCase +from torba.testing import AsyncioTestCase from torba.coin.bitcoinsegwit import MainHeaders diff --git a/tests/unit/test_transaction.py b/tests/unit/test_transaction.py index b082b6035..3e2ee01a1 100644 --- a/tests/unit/test_transaction.py +++ b/tests/unit/test_transaction.py @@ -2,7 +2,7 @@ import unittest from binascii import hexlify, unhexlify from itertools import cycle -from orchstr8.testcase import AsyncioTestCase +from torba.testing import AsyncioTestCase from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class from torba.wallet import Wallet diff --git a/tests/unit/test_wallet.py b/tests/unit/test_wallet.py index baf65505c..87e0d66fa 100644 --- a/tests/unit/test_wallet.py +++ b/tests/unit/test_wallet.py @@ -1,6 +1,6 @@ import tempfile -from orchstr8.testcase import AsyncioTestCase +from torba.testing import AsyncioTestCase from torba.coin.bitcoinsegwit import MainNetLedger as BTCLedger from torba.coin.bitcoincash import MainNetLedger as BCHLedger diff --git a/torba/testing/__init__.py b/torba/testing/__init__.py index 7b2ed3e52..7f73aff48 100644 --- a/torba/testing/__init__.py +++ b/torba/testing/__init__.py @@ -1 +1 @@ -from .testcase import IntegrationTestCase +from .testcase import IntegrationTestCase, AsyncioTestCase From c1b96a36a786223255096e31dbb6c595b86aeaf7 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 3 Nov 2018 20:25:44 -0400 Subject: [PATCH 220/383] skip running 3.6 tests --- .travis.yml | 2 -- tests/integration/test_reconnect.py | 2 +- tox.ini | 2 +- 3 files changed, 2 insertions(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index 105b20b43..65521a142 100644 --- a/.travis.yml +++ b/.travis.yml @@ -23,8 +23,6 @@ jobs: install: - pip install tox-travis script: tox - - <<: *tests - python: "3.6" - <<: *tests env: TESTTYPE=integration diff --git a/tests/integration/test_reconnect.py b/tests/integration/test_reconnect.py index a2cb19d67..d317105b8 100644 --- a/tests/integration/test_reconnect.py +++ b/tests/integration/test_reconnect.py @@ -1,7 +1,7 @@ import logging from asyncio import CancelledError -from orchstr8.testcase import IntegrationTestCase +from torba.testing import IntegrationTestCase from torba.constants import COIN diff --git a/tox.ini b/tox.ini index bda7daf51..733138e04 100644 --- a/tox.ini +++ b/tox.ini @@ -1,6 +1,6 @@ [tox] #envlist = unit,integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} -envlist = py{37,36}-unit,py37-integration-torba.coin.bitcoinsegwit +envlist = py37-unit,py37-integration-torba.coin.bitcoinsegwit [travis:env] TESTTYPE = From 5f70ae99239b899b02ce788ea410ad9d5cd846c6 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 4 Nov 2018 01:55:50 -0400 Subject: [PATCH 221/383] reorganization --- setup.py | 15 ++- .../{integration => client_tests}/__init__.py | 0 .../integration}/__init__.py | 0 .../test_blockchain_reorganization.py | 12 +-- .../integration/test_reconnect.py | 6 +- .../integration/test_transactions.py | 6 +- .../client_tests/unit}/__init__.py | 0 tests/client_tests/unit/bitcoin_headers | Bin 0 -> 2580800 bytes tests/{ => client_tests}/unit/key_fixtures.py | 0 tests/{ => client_tests}/unit/test_account.py | 6 +- .../unit/test_bcd_data_stream.py | 2 +- tests/{ => client_tests}/unit/test_bip32.py | 6 +- .../unit/test_coinselection.py | 8 +- .../{ => client_tests}/unit/test_database.py | 10 +- tests/{ => client_tests}/unit/test_hash.py | 2 +- tests/{ => client_tests}/unit/test_headers.py | 2 +- tests/{ => client_tests}/unit/test_ledger.py | 6 +- .../{ => client_tests}/unit/test_mnemonic.py | 2 +- tests/{ => client_tests}/unit/test_script.py | 8 +- .../unit/test_transaction.py | 6 +- tests/{ => client_tests}/unit/test_utils.py | 2 +- tests/{ => client_tests}/unit/test_wallet.py | 6 +- torba/client/__init__.py | 0 torba/{ => client}/baseaccount.py | 11 +- torba/{ => client}/basedatabase.py | 6 +- torba/{ => client}/baseheader.py | 4 +- torba/{ => client}/baseledger.py | 14 ++- torba/{ => client}/basemanager.py | 4 +- torba/{ => client}/basenetwork.py | 0 torba/{ => client}/basescript.py | 4 +- torba/{ => client}/basetransaction.py | 15 ++- torba/{ => client}/bcd_data_stream.py | 0 torba/{ => client}/bip32.py | 4 +- torba/{ => client}/cli.py | 4 +- torba/{ => client}/coinselection.py | 2 +- torba/{ => client}/constants.py | 0 torba/{ => client}/hash.py | 4 +- torba/{ => client}/mnemonic.py | 4 +- torba/{ => client}/util.py | 0 torba/{ => client}/wallet.py | 4 +- torba/client/words/__init__.py | 0 .../{ => client}/words/chinese_simplified.py | 0 torba/{ => client}/words/english.py | 0 torba/{ => client}/words/japanese.py | 0 torba/{ => client}/words/portuguese.py | 0 torba/{ => client}/words/spanish.py | 0 torba/coin/bitcoincash.py | 4 +- torba/coin/bitcoinsegwit.py | 4 +- torba/orchstr8/__init__.py | 2 + torba/orchstr8/cli.py | 89 ++++++++++++++++ torba/{testing => orchstr8}/node.py | 9 +- torba/{testing => orchstr8}/service.py | 2 +- torba/server/coins.py | 2 + torba/server/env.py | 95 +++++++++++++++-- torba/server/env_base.py | 99 ------------------ torba/server/server.py | 44 ++++---- torba/{testing => }/testcase.py | 21 ++-- torba/testing/__init__.py | 1 - torba/ui/__init__.py | 0 tox.ini | 6 +- 60 files changed, 320 insertions(+), 243 deletions(-) rename tests/{integration => client_tests}/__init__.py (100%) rename tests/{unit => client_tests/integration}/__init__.py (100%) rename tests/{ => client_tests}/integration/test_blockchain_reorganization.py (79%) rename tests/{ => client_tests}/integration/test_reconnect.py (92%) rename tests/{ => client_tests}/integration/test_transactions.py (95%) rename {torba/words => tests/client_tests/unit}/__init__.py (100%) create mode 100644 tests/client_tests/unit/bitcoin_headers rename tests/{ => client_tests}/unit/key_fixtures.py (100%) rename tests/{ => client_tests}/unit/test_account.py (99%) rename tests/{ => client_tests}/unit/test_bcd_data_stream.py (92%) rename tests/{ => client_tests}/unit/test_bip32.py (95%) rename tests/{ => client_tests}/unit/test_coinselection.py (96%) rename tests/{ => client_tests}/unit/test_database.py (97%) rename tests/{ => client_tests}/unit/test_hash.py (95%) rename tests/{ => client_tests}/unit/test_headers.py (99%) rename tests/{ => client_tests}/unit/test_ledger.py (96%) rename tests/{ => client_tests}/unit/test_mnemonic.py (94%) rename tests/{ => client_tests}/unit/test_script.py (96%) rename tests/{ => client_tests}/unit/test_transaction.py (99%) rename tests/{ => client_tests}/unit/test_utils.py (97%) rename tests/{ => client_tests}/unit/test_wallet.py (95%) create mode 100644 torba/client/__init__.py rename torba/{ => client}/baseaccount.py (98%) rename torba/{ => client}/basedatabase.py (99%) rename torba/{ => client}/baseheader.py (98%) rename torba/{ => client}/baseledger.py (97%) rename torba/{ => client}/basemanager.py (95%) rename torba/{ => client}/basenetwork.py (100%) rename torba/{ => client}/basescript.py (99%) rename torba/{ => client}/basetransaction.py (97%) rename torba/{ => client}/bcd_data_stream.py (100%) rename torba/{ => client}/bip32.py (98%) rename torba/{ => client}/cli.py (94%) rename torba/{ => client}/coinselection.py (99%) rename torba/{ => client}/constants.py (100%) rename torba/{ => client}/hash.py (98%) rename torba/{ => client}/mnemonic.py (98%) rename torba/{ => client}/util.py (100%) rename torba/{ => client}/wallet.py (97%) create mode 100644 torba/client/words/__init__.py rename torba/{ => client}/words/chinese_simplified.py (100%) rename torba/{ => client}/words/english.py (100%) rename torba/{ => client}/words/japanese.py (100%) rename torba/{ => client}/words/portuguese.py (100%) rename torba/{ => client}/words/spanish.py (100%) create mode 100644 torba/orchstr8/__init__.py create mode 100644 torba/orchstr8/cli.py rename torba/{testing => orchstr8}/node.py (97%) rename torba/{testing => orchstr8}/service.py (99%) delete mode 100644 torba/server/env_base.py rename torba/{testing => }/testcase.py (92%) delete mode 100644 torba/testing/__init__.py create mode 100644 torba/ui/__init__.py diff --git a/setup.py b/setup.py index f7e59b068..5e3565417 100644 --- a/setup.py +++ b/setup.py @@ -51,6 +51,19 @@ setup( 'plyvel', 'pylru' ), + 'ui': ( + 'pyside2', + ) }, - entry_points={'console_scripts': ['torba=torba.cli:main']} + entry_points={ + 'console_scripts': [ + 'torba-client=torba.client.cli:main', + 'torba-server=torba.server.cli:main [server]', + 'orchstr8=torba.orchstr8.cli:main [server]', + ], + 'gui_scripts': [ + 'torba=torba.ui:main [ui]' + 'torba-workbench=torba.workbench:main [ui]' + ] + } ) diff --git a/tests/integration/__init__.py b/tests/client_tests/__init__.py similarity index 100% rename from tests/integration/__init__.py rename to tests/client_tests/__init__.py diff --git a/tests/unit/__init__.py b/tests/client_tests/integration/__init__.py similarity index 100% rename from tests/unit/__init__.py rename to tests/client_tests/integration/__init__.py diff --git a/tests/integration/test_blockchain_reorganization.py b/tests/client_tests/integration/test_blockchain_reorganization.py similarity index 79% rename from tests/integration/test_blockchain_reorganization.py rename to tests/client_tests/integration/test_blockchain_reorganization.py index 0d6cd4068..0dce99368 100644 --- a/tests/integration/test_blockchain_reorganization.py +++ b/tests/client_tests/integration/test_blockchain_reorganization.py @@ -1,10 +1,10 @@ -from orchstr8.testcase import IntegrationTestCase -from asyncio import sleep +import logging +from torba.testcase import IntegrationTestCase class BlockchainReorganizationTests(IntegrationTestCase): - VERBOSE = True + VERBOSITY = logging.WARN async def test_reorg(self): self.assertEqual(self.ledger.headers.height, 200) @@ -14,11 +14,11 @@ class BlockchainReorganizationTests(IntegrationTestCase): self.assertEqual(self.ledger.headers.height, 201) height = 201 - #simple fork (rewind+advance to immediate best) + # simple fork (rewind+advance to immediate best) height = await self._simulate_reorg(height, 1, 1, 2) height = await self._simulate_reorg(height, 2, 1, 10) height = await self._simulate_reorg(height, 4, 1, 3) - #lagged fork (rewind+batch catch up with immediate best) + # lagged fork (rewind+batch catch up with immediate best) height = await self._simulate_reorg(height, 4, 2, 3) await self._simulate_reorg(height, 4, 4, 3) @@ -32,5 +32,5 @@ class BlockchainReorganizationTests(IntegrationTestCase): await self.blockchain.generate(1) height += 1 await self.on_header(height) - self.assertEquals(height, self.ledger.headers.height) + self.assertEqual(height, self.ledger.headers.height) return height diff --git a/tests/integration/test_reconnect.py b/tests/client_tests/integration/test_reconnect.py similarity index 92% rename from tests/integration/test_reconnect.py rename to tests/client_tests/integration/test_reconnect.py index d317105b8..779b45e77 100644 --- a/tests/integration/test_reconnect.py +++ b/tests/client_tests/integration/test_reconnect.py @@ -1,13 +1,13 @@ import logging from asyncio import CancelledError -from torba.testing import IntegrationTestCase -from torba.constants import COIN +from torba.testcase import IntegrationTestCase +from torba.client.constants import COIN class ReconnectTests(IntegrationTestCase): - VERBOSITY = logging.DEBUG + VERBOSITY = logging.WARN async def test_connection_drop_still_receives_events_after_reconnected(self): address1 = await self.account.receiving.get_or_create_usable_address() diff --git a/tests/integration/test_transactions.py b/tests/client_tests/integration/test_transactions.py similarity index 95% rename from tests/integration/test_transactions.py rename to tests/client_tests/integration/test_transactions.py index 99c5cd5fd..30fb12d52 100644 --- a/tests/integration/test_transactions.py +++ b/tests/client_tests/integration/test_transactions.py @@ -1,12 +1,12 @@ import logging import asyncio -from torba.testing import IntegrationTestCase -from torba.constants import COIN +from torba.testcase import IntegrationTestCase +from torba.client.constants import COIN class BasicTransactionTests(IntegrationTestCase): - VERBOSITY = logging.WARNING + VERBOSITY = logging.WARN async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) diff --git a/torba/words/__init__.py b/tests/client_tests/unit/__init__.py similarity index 100% rename from torba/words/__init__.py rename to tests/client_tests/unit/__init__.py diff --git a/tests/client_tests/unit/bitcoin_headers b/tests/client_tests/unit/bitcoin_headers new file mode 100644 index 0000000000000000000000000000000000000000..5cb342901aace97f1d3300ec88fc05b6a462d5f7 GIT binary patch literal 2580800 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 bnvDonVING%(2EzEdUSQa1W#8Xk80Vn4){Ds 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%0D+vDSeXRHUehX)P*hrKE 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�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%0D=820Y>G;yK%nKU(M=Q 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�X2LE;K9F4wNe`=N91;}%HludxJ@Zp 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

E*CyKLWR7WWNi3}o`*s~ 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Ξ_tp~flw3^Vu>OLu}u?xhIi>1k7g( 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 z

$iM2Tx|_%NENBbmo1FG@Ci6#&@|1=203Mk|eeSx#R0XTw2F-_vK||^d zg^#?1;YruhnD1#Mvk1Ox{9msPrz?=}HNQ(tHV>Kyb7LjH{cB8@iO}!0D{ZwZya=x$ z?cX)sbqvyZV*kNbF#CWln>F3w>Qjfg)holxPd1bMTm+&9pvTHTYY2GN1*=@Pm~QW^ z5DKx4e?3MbeZJ%O#E4Aud%X-gyQ_18yb3qavb@t zvqr`k^cbtoAf8M%A73K7{_(+q1DxLH6wWAw$v5%3#lJG`yCM4%kC^$wY|368jc120 zO1ab-A?#M-XCf|GC~h6SM|Bibpp{y?32&%eG&xWa@P!qcx@qwI+9W{`pNx zffb?s2XcMzy-FBjs_GKq`=tBygu*yQe01}9d+~$BF|xHBrdgUgwiDFpp?ohRs#1SgvS$1lb5hWrgIs$o=w{H9WaTNv#?;Q;wcS5;}ZcM{;W8k~!2 zSbAE;e3W|g+$FgECEdlaL97RZnv~d7^e^=%6K~Lak4ugOc;!89&CoX)wT3O%{$twH zLzws_heGFiiD66Jh=3D#kMO(T1NA%jc0P9`U(j17 zv4!-X#Uy=nXHuLG!V%FfJ8LK1uwUoszSuc$Zrv<}0X*rXzA7wRi}&mZwtOE)FwD9Q zU=vtu;E~huh<=Yu z;6*lJ_ay3Mv{?61e-?Y6oADrG+mhfag1>HTLrL-3W*03S^j;FgL%zS@y43S4;CH-; zShnx5*H^*8p6NcWMsajpMeU(dobHJab6b({UwY^199YwR zz}9s~l$Ss3|Mz~&GsyTY>6n$_(QONp+iOU`u=%iS_Fz6&(aF5A;sxqwUqnnKr~=TV zMJve%Jmtj2LO7v`Z`V_vsRQIaK?Rzjo|uWPZ}5QX6ObLWQ_^ zd#%XNe96_(JenDQEyfJ90D%YalKgT4V_wkQVB_+vmK9($8&dv2HdE;Qsk5vy5B0*8 zg|Zs-+=vAr<0IlUbG4ggVJ(cuXdekvxBHOy^|t0E{|1x@mXQD7R{PO_6p7OvF_npF zww>!%(G--xi&T@D)!`p_2(vIX+CM>$ZQBIW-x%l0i-L0!hx%)E>JeO`j%3_87c`bB zO?z+<5&-1$+fOjU`Y5X&%ET^)I47*8fBo+ZZ|>yyoa5fN-SsxP+x4Ia#W~XioDVu@ zZw~V}TQZL1Naq!GIC$Sy7Ujcg&UbR>pB4e{%yU|r*`e1lS4Uq{iW9MXfB#)N^lgSS zm9SblS(W>ENek#PUfn|0-xBDGs`m=7tq1mxxuY(1lma8=PV5$hHnGhX_yF%Mxg63Z zJxSSH+9xYxtuMt_&hX8gRhpDW!Z#HN20cRcouF6i-T=AYuvOG8?kn4ruKW?E9L}6X z@uDD?GUi|cl63`LWrc(kdi^(dG9V znW^)j_u`!!-&FWwH)<*p9e)o%+JoZ7THb zRXK%8u#J^05)|ob(F1SR9@d?s$reEm$-Rjb@M>HQ$IjQQ%LV1^irxD7yvT`lB7&r| zjxOiwECH_sd;NZ(zrs7BP%}l!N0>dtDuMP4Sqj#si*74 z<=)RZ>Q98=v1^mF(?NWx5{+_|Uym&0dAcb}+OT>59v_8<3h}3pMC&*hygL6zTT9rK zXhm2RRKhinB%+)h|RaMzr;<7-% z5a)#0sdtM!z1I2}sP{TSvUX0us>@#f`4$iV?-6r_oH0{nHM)~RKq((`bEw}Y=m}_t zLi*1|HzTf7x~2wkyj+#r)plBqf>kg%BR+OBulNH2&*b~ZbfU#CrP@~$>*i?_VhYhH zu8A_!0c&xU*_fP%VfDM9M|m}%1)Ps+4SJ`PM74$T)_mQ8aeK)V-{229E-#f|CX>Pg z-pX^SI^T{tu^9}EMJ&1it-qU|?a<{Fn^~8y-P~=DYSIblL8)?C0p5=RB$gn!B<(1@ z#CUOhqLoL56s?T(lAWWcYze?~OW7YdtMrwvGf~sx_!yhcC|*_0`xdzDkZ`*U&)#$3XqbQE?#H&rt75LZW`#%F^IJ6W!>rT$Y??KZz=I19}uPc<6w4Wj?gq z;xHYV5#i{`GMH-V>UvRZJDpefFn|sjAMxY<ZVy_YXxF z4R|w6WS_buAJui)3I{V(F5?+{%;A}fVTI4n_)a-!v5ut?K@U4s2XcM%BGJ$?6dcM^ z^Y&Qsv$`D+RD8~aUfb6T$Rmfe_sv6nTJx16B3Q{jaXrt_tULZU9v@~0-@TX#ad3$u zT|7hrJ(wHlJl+x?z3G)(Ry8@}-W|81t*mhy-_} zMj(}vtM%7;A^qD8Aoi_9jgl7xELfv!5R9#a0W*Ch{FSUX_T+ zfBPSM?9Yz@uW*kmF;`BZ;A8Ij-Sw0!rKr)9@TcojL`g>Y?A1`BX*Uee3p3JytOp!Q zDNlYd4aw+I(0%#ay)Z~?GNMWcC*iN|D#r!j1uoKt#KWDIU5c&6Fjqev62!>-;Ynl; z6koLNlKvY)KZOT+txK;V^X*O6p&!2dsg~Fi3pTLT4lG>wNWd&7r(g8MMwJM7U7r5c ziYkKAA&k|QPsn?Nk2SS?q?b*U$tSj3Fp>t`c!Z!wD?Vlc9KY{Us;`;rs>rBx+s^cA zCeFLLKa5~Ei6u3>5{3jBPv61z1iyW|{wDY<+(2fm#=hN9v0rg86*39v z(J${n*1O>fjT7fvJbM)LIBDN+X^ICRJ?=&wv!a#TJ3!j!Or7?+USh0Yy;rDS5+Xa4 ziI&H&NQcYoQ{c|pUgk^YeIW(CKNy~n^`r3kY!@viWvYJ%k-%1S+3WGAFAHu1&I{fg z4ig}sCL3)mYHx&9<+r?mS@wmxR$r69;xi}MEKRZ^ne^RXsi{DZ3hSW@s29uKMX(o@wqcy(h5mf5^lfGUA z@5e6liV^hS^>{rY?Tfa*w=Im&!e`c0{>E7%%K0&rMK`=vp8(=KO~50veHF9eu182y zyW?#JBRjw~LRlR$jNQjmv!@v+ey5tk{C~ci1Rubwek0vSc=T5i?U|=4br^=_>tHM5U5z`IQ;teyzmmR4!IA3AV zqco_n0rFk``8I@p6-2jm&3K|YZCl5dh8T&^O(UVUBf0{3ioR!Uj|qzPF&dAs!Bnap z!eL`I6xj@XSDKcg3XQf4?lPbUQ-`Jqcm?0u9PE01d9!1c?dmRcSj^~}hVV#iWbAxW zHUZC)QXZqjn6M#;32~HaFg~p3hIiA&S)%jAqO4r%7wgIK|DFmP2IPL}lEz_v#3!Q{ zeQOLSR2Q)mGguAOyXW53>4f7%f$Hzbu5YR^sr97;Pt~L` zjbig!Xeoc>cH=-g8Z z#Ym@UphH*IE+aQp)r-oCA96jze5%tHXJ)nN8eqN56jZFh@sq!xJG7dZ8LzR&OTIk4 z3<;J0=^m*3GlWc12J(N2!{{jMm~&AR-TKztkg|M~R=^~I{W+4+xA=D z-^~gGUW8M$XfX?(=aTe~mauM@&yyHlr>ZwW6E{euko71De71abEWN}B7fpAo(#c2d z{$;9bCK9D{x>VGxo^X{@BhX{<<-GwslV{}yYU`IqT%x`O1-1+C{K)*%GM%?4{IY0x z|NRVAl!D*g(^r< zXxtQZ_x9R;s6~H8qit-VjV^a&1vn@Mj|4)MFswL`V>2xYA>9&LiVc4ylL5SHHizt-)jpak z`!*MNi!78JUUiovWPdyJdX`3>2*=l2j-ZE6o&p)Kj%}~?lg9~6Ld!I!xrB7Uj+)Az zkg02AJ?EtP0v_#dQg=4C8(!&Y((^VOhsVO8kdD^`g>V*L+4MwlXncVO=;2|FzX$Sd z1Zts?W&B7J!eTr4C7{3F%+a|WA-WNStI7^(pGoJFO4DhuewF{=ffaZ!sb7ByEm-R* z5%oPdU9;i*7h$g#=pn$2Le>|u3e*^Fl9LD{S+IgbjFV_XU?@fwxPm9FKaN5AldbPm z?~}xr2Frd=T?X>ouyaUBm7Ukrn@A=su$Is*qoDbL-b(^%Nc&99P+*uku|utY+Fz}D zp%Zn$F9wAnLy+9D67UiIoZE?5j>cb_bnDEJ{dw5c}nnKK3G^_1=_5D@vp! zfCNJ_^9x6iM%NhUNc$x8rfCT1U7NRI0G<+I!1jP^=5NI}1$0m0U+Lr!4fT|$403XP zp+$jw^J`S3_pWsw3bf(Uwg#baU)WdC@}Fv~1Y>B#e-Hc9dWC`B+|3lEy(bbSJe-BH zv<(tyC&XXAjZVtpo=FRMjfy*3X9jpHqnabi*=QpE=#`In4`H%b^cFam`fn-vr-{-Y zTl(`yqd*U~MuG{*CsOaOPuI|!J~e#02j%(e%K#@i)9D-XT?&N`$o}Va1pCu(4Rf>1FN$8c@&oT3PiZo6`P$cm(UTARhE!7M_#=@4OPlEaA+Pqy7wGn_OK?>u3C# zOVAdR1aIUU$o`xp;|s-fI1K8HYMeUCeZ)(=UANNQz-Zen978gd>B@T4B+!e+$Ak1= zUeTD(xroKJ2P2(wzQQ_es-ts3IILKkPr-D79KSqe#lDoAQcWtO@%Wx7EH$UPZv;4q z)vzX!B zeVRj@pJ;Of!h4C@*u{|t0#vv^`Je}@R-y^id+of>9_HS#y|wbBtVqxJL@=<6Myi9d z57!pH4&Bh0_R&z5>T>U3!UJ!Dq# z7l3CmbPrS5J`ftH%8*D|mXyfAJ#cL81C6L@8?FF&8FuMClsNKVld^sX*mLY5u#TPO z$?7sNh*CPWG4q~{mNtPN6V+W5;2D|*gwm@8HZ?=_WTo2HRGxknC*UShR_#>hIsrVE z2719}bNg8mx?~D-D4*KDB`Ghe&EdAf+PBciu<zDV<%Z|3b zy*NGpP%%l&&mt^7yL=bnqG~x;!I10s0M_Gu{>KxZqRvRo@b|=$YvbINXBHCjA{0D7 z{c(m?v*tjLz*(pqs8?#(nk)9oEuwbZ=eNo`=*#w%FA}g_b#U*4enIv#j6C$xd;MC9 zapG3~_ayKWp$ObEbF4ycKOq|eIgHee<xw7F*bO4Uuty9Za;Y%n5=U~Ccu#mI}nOXT1 zS>dyv;}Id)r^F+u4I7}RM!bRocr_+r3oyQeItln+W1`9|`VDZuR`Z2+s-1BbL)Oc* zYN^V8r)3b~r`#~!A*^`fB(MDI_`XanmS79ZK%|Es`VD%_7o69C$NpBnw?Mw$+G4Sg zbWAF{TGzzoMjp0-n+hId0mv6I<{GaW$m(iTjx7wzv9c8M@{bVb$19O|X+xfOppVzS`=T`k}5={64c$ z?Y9Ih)mpkZ@ssi=_fs$W7pkfkpa<{3DhGJQyH5@Ud0IZGn*GeA(6D6h3blvaGCx7L z1zm3g9?$nrzE3*#Ps3J78`KyB-dsB#yY27fFTP1FeA8e=gf+YZJtzx<6u|opm8GWs zqj{ne2HEIFye8IfeVPOpb1M6186ISRgz#)A^`U&d!HZ9}+qUZ}X!31dv$f5rXL{)_tv(&n&9IT`IE-ElkFxr!P&U025DT2BwcBLR>Psv~d2n4R`* zZj_s2SADkY+FGUZ58_+md*=fn^9Qo>$%dFbY^z;#hO?Q}9z%a= z14>G7J4dgUwCR+@!(&PiKo2U?A`9@6BQLq|=_5E>((RI0G%U7!@q{^%N(19p_Of#R z{R|aDeYqiG5ad17*c&^J&;n12Bt$uj_2pQd`(6!GirVlB4fNP@dLZXxe$%pP0i74q zL;5e1mj28gEOy|K>wU(NP@b|5;Hj&7Eca@@k&25GR^nER^y1vz`(|}g1DDCFFs0|} z0n?8KdUnfX1VBE5v|y{H3#w;A{`1(mYcm2i3u zqcnB>{vAG3$d3&?K5)MUjCYRc2JpX&&4NoBBK~~O~7p>D<{@LOVLiR4Y zKs^L_43#CHuo1DO=naE#7ME6MCX*-WV|q~5s+n4y0WXDd8lCdPz9&yI!)L1{yxZ45 zYt7+^&;<Wd_Lu8SdKo7CP3$i}rpDOz%ED1?72wpOt^F#LKqwuL|y!l(FFy)$S zz*Et4{&M6Y6xI~G+`TSPuVu~WD^PFN|MqQNyO48_gnHQj9`2zbWdBP+2I3j{8hz_K zN-j^?bia(Z=VJ<=l;HNbZ4)5lkH*(#Z;KLpsXr!%Y|*QTecMl!vt3$vY5uFHz+O(4 zW+#yY%!lNL<_6SjW*3Xm@4MS|yvXa0vSK;bufGFBM8GRYwf8v($OrY|%eqOuJMs2k zn&Ywsn%x4?WnV&8mKIpkMgj!ZJ6bXx&?9x)_5wT@+<-94rMGtKyx%^&b^KT^*@YcP z|hig;l=n*JHFo{qgfH=;7tzLe}Hg zCLZMR_yy1?6OS2mh14V0xAu(NPm?9S@B088)b}{}NCm-UB9{aitB^+}09U!D%iB{e<@ROtOJtxt<-z%Ag#bvRw* zhzpmer%u|-*C%RZ=+cp?6QGA8kc<=QzV?4Amjpcq^La>r1HbKy2-0q}W`MWQu)5#+5v$M*FphOR6q`uR6L{zas+EW&`*%C8D+Z@E0^|Ml9mTIqC zrL#m6qoFQxMJzrjN5@8a(4+AmIR(x~mQv3`J?;1N`k}iCGJ*qL91{wEykMDLRXvJY zpk8Db-`AIphrJ2xD0rG<8RJevim>d z=e_#37vO9RH|LH>iF~oKIPOse@TQoqF4C}!>`Dfz`C-2LbJitDWv7dH2H!*`M>x|e zJvD3mpD#2Lvj0j%=Spu*Cv%^u69Gf&hCC^sEx4Nu9bTNn+8^@#!eH>K{B^`Z-~^iw z)J$hxBQ%ax7L#0k26K6p9^BRqT7wqoDR*W;)@QC$sSfxyW{US8XH-YS3Ko+yoLA?3 z2Y+#5-$T~pd0DDZ@(S6!C0-998o*j4y3igiaD=CpGdeW(-U>YMpc;Z6sZ5F^P%m#8 zSJ@ZBBMr>0&kPX@cR0g*6(?I;ZZ>~7MGJv?Q4ve?Qs7Y7H7SlqZ_%0fk~||;tBHR(S0MGCn3t6CN?st*hEj!9NSwocjOWBHi>do%XB zkoLJB(W2K*SdC~=X6SKbF|m&#kmzgt<_sf_r39ouj=bSl{UI)uuAq6vCV!XZPg^bN zlCJA}b7en!t)DhQLhA1S*UQ_(1LV_p3i*08lUz-*(vAKKxxIM1tcffpLbW!r3n3iH zH?IIStZ>1n9$D@pQZudPDM|pRtDT!P^09ZZAipcAATM|Y(1bm%78;ld7 z41dsj$;|u!wt z*Kx_Nc3XBwO?;W>#n1<&wgB_I6>+6 zI0#PPI{;5(c9b9cdF1jVb`0OC`Z7;ovw=DM;$Hoa$5I`GJTr~>kpDe{V#xDML7KJr zL?tKb;VD!##C0L}wYR6L4GE)Mv=7jwfM>LO!G3^*by$-0?*-C!u1qH1v7)%hYRH11 zG^*sS7h@*FL669Nc^Ig7>$5}D95)x*ySAOC4_d{YTH2HkVW;s|%J;t^^ChB*2M1C= z5!x9ZzoPua`GKU_FBcE5VHEndz$=z!EM_b^2J~D6(;@R~i0A9CK3RntFU}uvBVk1h z*zdYKBqTKvX?N&B#+N@vCWYTUfiN*;LsSND#1%T4oz zB7?Pd7Euz6JiEf+gYQ<^SI}ep+XvY%mBz$St6qs(nm5v`)@DN#m-3iYH-+Qv$e2-? z40zU3!^?eKCUd!aupgO@4oGEib5Sef7t2E2R-KOzziVYP^hax*(R3l zpxK$h5J&7-@b@PM$8ZArlG!xKe7pG5kkW}TvRDEqcW0=w9!=hN>`2^jPDWJ(v_Zu1 zmYXvWe1*diTZljFr#*rBsYGi#|gG=pni@g#!5^83P^hnnGv2B}Lqp z>aUQ0XcD1dY`piRi@=-*jvsU|GnYf;{UjaH`yOti;PRqJsYi9T(Oc?vJ-Z@KVOYl| z&`Ws(3z`43IuhOw8@=6XR3*boAvygldgoPhm;A}hpcM_${?)5_z44i{ccd0q|J=>) zebKovI@njc%-xubts_N*OG(lUdLRE_LavV&a_;gUO-moolFvND;|T&!-6{@-iNtPv zpfE;&e3~sW1kaimYa+#zpWLfd&x!i1QFW*C8VTF9Y>F;$M(5i>54S}s7pNCa7%Isz z5{o56RoxlUZiaZ#LynipMBiN`jg<`WmKE0sc(|kA^kz5`*f`J)r3+lE^!*Zc*wx#scTdP;7 zt#G;Yo8458#NgoaFtFKG4HEO=t(| zjY#!~?tn_^f6kLg`%KbX=TR4+>UD^eIf3HU0dVzF8=U9+x{dAFWyKiQe0$q!aEN0I z9gPU1_jaDt%*rLhphpu#(gt|Kw+27fjt~;uv^NOpq)@Ba-?I?;#vk%iJOo&l01m*o4)~}5C6>T;X z-{;J`=xlN@xrvOOYY23299$K zCgl1RHgJ`PF<$;_j%MgF6i%gPF|?km%Lqdr3$v(;7&`1HzE;U_u62B#NJJ zr>_u>vMQs1Tw~RiL&v)|Pt=h@d7$3MU|u0qRAl>7i_b1Fu}Rwn?5tMLBK$BN{~iys zIuSEIUIRUnve87~e9S(wO&WBtP<1hR6i>57zw>!z!JJBbH5oKZx(9e&GzQDc?~HFd z=;!rD-xpf3Isch}JASkGvE&#{;N4_p;RfhYo0&uQBQ5I$q|Q9&>1*>Z^M4)hR`1m~ zWUNIio5GQ}HUPXlL{CKqn>;_fqdDU_BYT*;2BC2-o`hHb9tu=x^8C<<^BeT=pt2#) z&qTp#`mdyXfaCkPz4u4j-Zg|EJP11NtUkPYVjA#xSBN`qb8X($IydZzv@m=R4n&K= zY&1_@dxm2DJ}2;UY!CF{42dD{i)0YnMIYQ`YTRrZ>#JpY>syY#=+Yxe=v^}>%mR2b zC(pCd+>Mt#=vf=DX&D2AF5pqQ{>=JJ-+fRjc-)C0IRHI3=1oX{SJUlXoy)f+>|@VG z1n(+b@^U<5#H=6cAFFYBOaQMOJJ4{9e=zi8r`uGXXM4+=^okXlG$b5oLbV8K5#LCP zL(n6pn1RfPp*5`u#%BEVM&Udn=KQU=h~(14@opr<7~M33f!hebUNM6nyU$=)J0u>;SyaP%2Nk z>X-=J$hyU})@d)GsyiLAlm5htNw7ekkFvvvrvCeE$^yOK6kDh)8i+?bjvc{#$!epE z;%BrCy`1(4dW^Emg@C8}md*br%g+qc^WBq&$dHxuAcZ#iLg@ZFdKDq2$VJ4l{ zHHlL%seVZ(?>*=#38el~p zIT594!Vk+p+xt>%{BBhr1N0Cpf*Jttmwg&~{-@ongmc?tn}^F=s4K%P^K#BcV{;>Z zz}tuO2xW%g{n1>}2BY`1#v-kbe5VBCWGk;{E+*l$K48p))2{(4%NaYzFc%irg|95>_Ws1fEY!NZXp> zo%LO?yeUhu%@9xpJkm94o+{;M2_Dn!4U&tkW29GB{#!S)$d@EXW;e6j)Z(u}55`yO z8Swrd;v;zeINP@X70587Id;4y_!s}_ZY_|9#fuJ zcI*Zsu30{WzA;Ot*yaH}hQ%sK|Jlp!#VmZvac+nHUzlc2xx8#;*!mut;I`0f{$;>} zJ%tL8?z-ogJx{=kMVv%I949^(&A!&5nDn2EK9~J=A^>`nMEqZXe8m(v33;oW+G2l7ps%6JI5U01WzC#g09ITsEtpR48r8qbkeA zP1^!_-{G3m^XFB$K_PyO@BAg|nVnhM?Lu|xS8WY^-KI#K<)&s@pa<(tme>3&3neH`_M}wUp>LEx3j(W=^KEo@6#r05aD^8 zoHB*-=yc-ZNWq^uEP3yls0Le^MbgaN?vV6W~XQ(ry3uQpu`OW&WedDAQUS(0dIn zQ4QqVbR%lqU@OYaok7Gg>P(h-^uAY*Y!YgAvTE}C_cPQ(yQMDH{vh=X(UT3!Do(7R z{0oOPKj~ zvZj*qaesGp1*@SQTC}JcK@mKDGS6ijUpTEiFBoG*Y~MpIo<966wPy(%VsH?%zq*+u zviJEvA2IAQknhiu*)vB=KK|7h^|S$j)%KUP&Q*`VB`!+*_}4(bHUq`4X1UH{dx^E@ z+g%P05d<`G!=}3U(r0BPf4YcK{rx~M?qUTQ@V--j$wIjz=&z`zG$_H9i@ZNhf%!x# z$|3en7;-;y8a_ofJ7=;SEK;g2M00#Ks`2J!X4`2;yGzp|lHFE`S}5p|YKTDto?^CI zYFSPMzn+R)F3RkKWTi+er;+*~Os?9Y4UkW@jqv{0?t$F7&C?fF*bVNisHPJixXnN) z$1ljG!CfoTk)S7q!-fEOa#Eg&e>=+kF>hR+goQ_=>(_8G3lbFJVe)w)^L3ox*I|*& zNK=2jMU%FBcweLV^wn{OD}r}DbV%LiuEG9m6zEa-tE@uu&5NzUe84_JM^MgMjft?^ z%HPOOpDeJrL-_a^$ak5}G9IZur=9G4{q}!oWx?99L*PMU3jX8Zh=pjWu z`vBhbF@{)rz+hQV5l5=LiA*}>$A7ODK2u3!HGTaR@Mh|{xm0a<|C}aPzh4nMOK^-Q zaVMF&uEHNSp6uRlJ?7#j$o)<2J9Rc=<4?V=*abDX()rR4C}Ni-MgJBkA^i=68U}wLU$%x(j#Phre%j6EZ~`_`+w98BZ}GbWln-NZk{`GD%&G^r);JokEfTQ zjauxP`+vP^_2Ynd?tUn)T5|b^UbL`|^0&-Rs(y)tC`qZQ_+Uj6;8mZS>Ff2L2>eoP zdU^zz zlHSRUF55(=5%#;b*0&*PU|5%?SmNo>A&A} z|9jxMxW4o53tjj&^`Mh$2QojdnqKGKy!?9AK211KeJ4jiA>#NEJNb_x_LPkSfhgQ%$q&$D z{e?jf@#dCo;i^g=ZpUj5nl+=FUuuw!tj>-59>DBC>J{FZVMM4R9nT0ZIW8AC&zqUe zMfZn4mtMQ1UyHBd2tBC-y_YXeCIIhmNgDbJespyaesn8Z)0s^L1ehMv7ii!t#=`>tpgVE>flN4rTNR{ zFD3__p!b$E0`h(z!q4~G7*5kU=;#Qun0%<1?6>Fh_`Y+`rDlDQ{?&VxbfsV7?3GW> z#piTX??dLAyak))c(#y^C#9R(1S~o{{VP< zKjd5CNZPx3iDkVBIo$H{gJ%g!El5H{$Gk8Bj~s#HjaIH#hJlVBsnswJl*(6!ofngy zqy0h>?s?H^E!T6P_nLu+8t`7`m>lZKbBbe~M|a46DPDHdP#J;n=j*cTn;213 zRwTkve-2Bc{*p8g$cE8#!R#CQ#m0L5R?z}#W3@DW@wEEnrD5+K6@2cEz3yk7Ezo26 z39i@bw;d9yIb06VFT9Skn;B;fZ-8zp3T%HZ;QY`ANND=Q zH$=nP^Jtv6f{N0r$|U{(^j=xJ-U0PSF(UI5P*XY&|EbiX!ho%d*QXn6VhkYnzihSx zJoJG-V<3<(Q}G^N^W>py=@zkt zHMcS7L$ju<>eZqD@x3u4Iq4@~gD22~*BTK4ywm4`)Un^+5t5Lqi+NjL>8=xt{ZV{b z;6o7^3=en}7R{^Q3WbqL5AIQIxrT@;k-W(35sdhru&B=1;4W0Cp!Fc_{R?*#$oy`n z#%H<&9;iq0k&8b%n=7+n=tWMsFkRF}glI5;_iGH7PQb}F=(nL3{GZ&T6Ajd4TKpaM zeqOk1l~chx#T^*XBU6lm^oJ;KyRL^%Qw-F5s>6ADNQC?n4bo1MleAnkpUmY8ESg0%OOm`@gY$xB?bVHVZ^;rPLB$3H?} zxQ%Y|asOlKuEU~e;y8fQNOwthcS(15mmm#_ba!`$bT=Z>sff~zbb~ZVgEYwN-oAg| z^L+06+ne2+nVs1MJ=zuV7~uGk$o~;7iM-}HIZ4Q7qDb%`rs68=p{~`uG zElgaNLezX2=&QIhL))f02P65s`ZdP;Vy7yu-r=)5m`swX4F~(?`rBEH&dNhZIrx zLJ$Fui?Av&JiW%2peIDt3YW&|!TF4vmWAr;FbxdBnqlZ14<+a^rnE8wURO1CyrrIgZ6~Oi)G_TS!~!33_k~r2qUI%~XA>(M?!AmGu6jUSoY!_P|?rcxbN2RF?pM z13IhM)S$;gpo{`|Y$GcQcAmCBnvXR&uZ+29St5JdN7@LG34Ul)0QsDfgP^{!!M;8g z2`Y1n2^Vy0lwB?+KC}O*SKJ~MeYqCG1bXx^-OPaJ@M*ay-u?hi$5V4mXozg~uv0l;JF zD^$}a*7Vr*tgrM6MK#E?EY=Pa#D*j5p3*CnUm*-OiV$h&%ctRyNS1 zO0fe$$_<*fEWDsc;x3*Cc&#hf<;Ui(u34Y^x8Te_$Vn-hX5eY(Ir2Jvg3M0_Z}f%? ztMIhdssv2M8KR|ZO^o=)EYEPhS6}4*#bEojEgST3wH{RgF9=>m!5t;MbPZNk=k{4! zQ(rLkdbQ>BWN3y8a{SDB5quMUvZYxb65Bpis^5PYXsnhNZl<-*)=^SZbnqT50zIg& zr*eR|I0s+8&FE@2VL5!6>lmf3wJ^GQ&mipcpuTbX?_;QY6d@GE$;4IN8H$LhRa$ut z5w|175+a!6mug{L4~t%IW&eA-;PV7migx={lh-)NU5%vbc+MVt+VQZgI3$!UzaY}m8<2T$L2y087~CHy>%fF9AJfOUB};M4N8Wew=D>IWVJ9vQ5R?%(c@9@PtbGYlW>ONO)~SA=IQ zEa?;969e9ZK%Mbwc6BRug|Tm`f#w1IEBQZ`Jh2aXlucz(X{nR$Gu zBQe_vJ{l1m%4xO`n_19fbZ&*Lm)B~gZsO|xMs{ufEn;@9D(AqNv~0*`ww70R`#a!u zrSYXx6lVNzKfoB|nWGiTT=?^LJA4A_#rpq zs>nKti0MH@fO;q`Wew7sT)LP?`lhQwL|9uQKZgA8| z;myXsk%JZQGl7b;#vV!_B*jzg?qjh!OTviQ_UHe6!%2|)=LtG#tsBr~@7}2hyr{*j zlG7%=?YQ5i$zYhla09$9TMp^It=nV`Qmqz^C}w>Bd7?nmqK{Je8P0oS&tg|6_n?=* zyG;({YuJ~Kb2g6o66!M+spntoPvgO2^ia0!k#@ufnZIfflCL?VtKVDxkWc=eMCrH5 zu-f313hQm}WRK|=xI7ORI?gpx_a#4PQ?> z&ULGjp0gbJuXhbpx|;Rw<$~HXHIVrd=K0$m8T)TPEY=-2y}D>-a9X2%00yU`Oh@fBz&sA%CSH`1n&s}rqsa5p24w)+I34q^yf z3G~SfiqTXdG67!Ds_`3L=Ir;h!{ z0U`Z;9_QDYTzKX`RihIYFE%OQ(`wSv6)}#jHURInXzHG?@x#l_!7WJ-3Es~qxwm9)J@aX40leJx zcJvcZTBn3Qdk1bBxFL~%ENxE(ycegVG?V1I?~^9!L64374syRNI6N!guqpFr72B(B z!=jPA^RNCFxck@Kp84tsfTx=C>bopn|0nEv{xzyqW0xmZ+cv1xy6U$z!iWK<+^5V; zp!Wjf46=UGu

K2-+TF+Hrz^Ye(2O?*#8vX259ixwS6j_b5y!QXWMhxM1Wg&`!gb z{P${?*TbQRl^s7?^PwATI_F{-LC?-cA2Od<#6HyLJgs1ume}FFPW&*I^+k)a@_l_| z1at{xz0bY&pg3};$C%-j{c#0WTRA_H`Rgcj+Z9xss^B&1H{G!8pvUNp>joS@nZvBD zC5i-&gZB(@IxmgNtIrHzg9v8^>wQ*^ZinEL=;J;Ifgv_zy;<+4>^zPx zTq}8m;Mv;m&)Lil8LpRYKRxBk9d}1iHM833>vEx{)r-sM?&ge=7*4ab;mk|f~JKqA3sb#aJyjeGHQFw zs}4GRac58NPH*(7tdayh{CH}}{SW>OqT+kM*|4shue^=tR<5%q&oQEEsS5dvm_|T8 zSLF9pv!5h>DTW=YPrew`J$yza{OB~mbi66<5-ut@YM=mmOnAwV@t|zro7kh3f6K6` zCWdQE+h?p030FTxe9KVcvCs#+@AJ`XMAlHK6mm8v&)NY6|Mti)WjJx+un3l?Y8D== zNvne%yxpNEaQtYZ>3NHG!tS%b85{k{P!s=Xs?D@Bx)607gVh0eL;Y-$)CL!WL(sN8 zI8?c@)pLJkd88^XGhs5lB@h0l&}f1l?psO7c)Eqhvp?Cx^l!P62ga?NdaCY&?9QFB zw+N1_9Av&E%;vRKz^`Pfo^|x}Q}xIegP|Rq9OH4JHcTfSjpR^e4=7Q?XGn&CmU=_yLnq{Gg1xIJ3Pth z!JR9Ky#zIZJFx4q@Z>WWb*a-n>*-bgNjUPG$Dt|c5g;5S177)4A?$`Kmkh)C{g(V_ zbEN!`wg^NfYYT>xYa+A}hGW95Ek;Vrc4AO4_V_Ptb#svF-=*HOLZ_UkU5G z!6l)w-cymWp zJzEps|Lffi(*nF%fA2ty7am8|q`oqF?g~Gw?l5B~f=SKsUKx@Dp8U&8i^rRX(|SaI z1lLHq2_{^ru+wETGJyZX32zNy@@}0?@3j z+cUD%jrHg1WjmUTkMhB*_isZN8V-6s{OPIWO9DN3BSy&cZGS5-cVULL^GN?zC;U-_ z7~A>M%6m3@M7!iS24wxgdFv{-dQINI6{DKADre8{$$F8{VgZHkZlkLyG$h1uQYrt} zYoQqq}1F&uiXX72Pj6l5{)jOrrL_=Lr zT!pDGXN!!*IX<&%&$hkW#S?+my15(nr~*A`Qlu8Z+s{Y|U?v`O)<^jF-nivO7q&VU z6r@(Wq{C7Lb-=SrPfXsGo(lHpAjp!aqZDmic#AERnw0Q6FWkEQ zJG$x>(g!FI8(kmn1)aB(d{jbh2R#uCVI;uIb*Q*SULSiiJhjlf$vrh}DIv9kpcS!| z`8&FXAG~Cmj2ZtEnYba!NX$(w=m^-%TI6 z(A?`#;#v-X9-D&hCE!uUE(BCpJnB{|N7$sFSu4^~@$RB(C=j#8YAXTx>@Ba%^s}8Z zKJxazltHaPNJ~NYRwlrQA;A`hDJmnH;2Z`$yy0F+!24yC^((wl**0o-M&IzMri3)H z4s9sKY4Haa7v%p^>vF>IJCAt8`8%;DVPU8vI$j<1?KU$JjI%EUS@6!~*5jZzRay!8 z|MiWq-h)97A5M&sbOjAtO9N#eBG1BO1)NBu6p<)D-`iq9H< z?9If2Sr>LvHvdrOIZlBd%jfAJAm6K7byvS#{c~;h6dReEni_9UqUSRnc%` z9`ydUox=d$;UoU(oojB34jki~v*A9S}HqC=PpyCiiMfR}r^l@%;s;e)9W8uy0t z);HT7<;kbY{c=YJ#|Eu$fZTow^q2&zVgb)R|3mOCaqomW(U+3u_VZLtg9TetEj+^pe2cvs@`_j z^#QNcdc`l$V~%l41oE-M{&sKLLmv>&h(-`9!G*>8*Qf^k@qQp1b*TWJ4C9s21^n*J znv-HTaqhbXviYqV9!_X4AC+d0mhO#vxlPa$R)B`||9Tj2{DcmQ#zp4KOx56q?!u%* zCZc2VduVG%A?useGcMpI7_F0;YthwY{vLRmEu)-}d%Q3(t@wrbx(Di0)^E^bG`fMz z54GQ?G`D_Q^n+)Lgj=<$v$o-{Fs;D;tIb8J|)s^tYc>5%Ro0Pm2i zP^sb-GVAk=pJfO<8Er^6Ns9}~;=9=vwVoX02dKFl(4#^*hKv`MSCsU2+S^4@Qhg!} zqpPq?k>Ks#61k$e^G)vo-jXL*r0m4j0+aW}FIjhTwE*`l9ObB=fIYxn5-x&950VPpju&oob)uwx=vCk6zgG`>?LR3v+fUn#P;7}e`X06li~P{{r*|5tLs zoOn?W4EZ#2h&7iQz3$PTpLZ)qKYt8{oNsXXyDEn?cruBlh(V9o z{(BaXZ#9I8nIb4a@9#@1YmZU9NQ4?sEOFi1I8#S0Gr(J#VVz^9Na2^2{msaQhWK3T z0G(WkmU>f!e#PL&`-PQ?7W7_(-;DwuF9)}TpkqU4qu0v*4N}Sw#(NERrRXL+=>Ag? zz~l6fo#o!4Ktm->@#$QoIC}RLi|xhHX^qHh0lNuF+>AcP|MM|$LH2{8ORqj3mHjb{ ztWGK`Cbn)m*h{qh^^Vgr5;310@EW(N42(Xf4ymQ{x+mu2|8+hU#KCOtQ}1eaS`4kY zes#nGdN?ttM?gOQbvub1&4B)lM8g6t|5vPMx5nGIGH41@o>P$fgCD$@ZLD9i&bad> zK9%i!sh9i|=4fYGVJa$ko%8n4cw3bd^zeyWA@k!|!4>tv3K^wESf-{33BD981HC>U zI^>L!h9dESd={-oHv;BGN4~S%=o&asC}^dM^{em`2!l*}f3NWD-Khls&(})`X@Ar? z!5i4=YcDiL@$!p&+B_Z{*1tAP1dX?4*ir&sN?RfZ8GLVZtDH`7UwWAO<#u}G@|@5Y`9QvInyWe^%O{M`AJ4;Nf~tkYG?RWOTmoN}nIlsO^gAr9r9qE` zw^13$=j~NQwj8{bD)CV`5!~8gA|h z{!UqPUY--1F_){t0KNcK5%g$Z(tQOyE^N`B&F+?webTzDn|QbL$K-Tv+D<06yz^>w zAYXkPshGvJU5q2lg4H)vjgy{N9O_F6d9nd2xJ(1dB?;MDphwXv*8zCvx_ZtC4=-(& z-o=>gB}dQIY?B@-2!3x&OzIapq<}B8k zw%6yWMHlk_fr9TlJKSMuHV@C7veH|bK4UrJX|#sYs$hqNoVIeKyJrA;a0y@W0Z%?g zUYSUG;e)9}$-|q8Ey0-762g3Fj{>GrSHyoGLn%TvnsQwTcXPfXO62gj=*PUV4&Fc5 zmYY6KK`xYMDmSwLJ;oiaw}4k?s3g|v5ZBt)9Q?JPy^FP4omluQk=xBA~>XDfoVKZk-h`Jd82Lz6JA< zv~p|#`I3n3JvDl6iIB(sJTY9ah7T#;3T@Aw$h7Lv3jz6pe!dkcZ*7Vdx#W_+-OMGJ zm#jpiS*q?eV9bNBhSsrt;rM^OKY|niuU;T@sFP-a_QRF_b+ho&qiuHwOqa^#M3+kS z0^oJB^74LqMj~>o^04`|!_W=Gkp7%=V5d0s;91A^I6nLFq~wkZZD5eVmo;mhEhd5<(PXZP9B9Pk))J?_^g$B5f>E0MCwzJ&XP& zrv%h`k6GzwO*@He9Tc;;>2~gzoZ?KWg+sdkJyFUo$n~%Jjq#O1zTF>5;awRY`v7{b z`Gle^77Eq&iX2FPNS*aV*<_$5k6lCNxbDxhC$}9|3FCd$X^%9P4F_|Y=5>M|HJP3e;C&%S$6rH>oq#uM z4@sSL@w%O2|0H0fk(Z&?=MUs_-wql0?4i2W=uXZ$yVFb5AAk0wGv0V+#JE=DmlEAL z*av!avs~VQ$MAyp*iB-9;M=^Q;M@YgQNw7mvV87esx|3TOu*x5o)Q$#%X3G7NgG4; z^(JDoB7eg@j>GhIK2x9I&d0HN2=t&h5gP#Sabukg%O>5{I_*8SW(BbyBfH6W2?CP` zZRU8$c-5+b?Zs@Ly8a9TO@GBb+yc>Y5hqWgEwff}>Oq+*=CkhT|K3IgS$fC=m&om-HZ)HXGF!UP8_esoN>cG;~j+RU1(KH8b@^{6M;#5OLxz`A+ z?Xe-%zgHZA9!aCO0g$hC!AN=(ndWo-SvezmVmvGKb&M&WRKeP-*d{E%8>%h%crKVR zjum;C`U=<8nC4Vflik?Z5mv(A%MgpJ+H(o?m}?m70j~m@QXOkS_iyo~g06fcQ{s>Q zj*QPJP%&dQ>S2J#ixd|Hr@hlwlAQZAwUdxfi_>7B?K=GV%V$R$wrX3qgLTlm|7i(X z&+l;jF%++z%oz3yrLS80o}Dm$GK106bA0=Ny*S|gT`;z6rc`tBIZyWPf%jtcr~X@K z!^X3!eNQeu`I(`ro4~5rrH-EP^>(rbZx@nlhQ|QP2hT_^Uvq?$I?YhWQ zgnwhpmVN*|HuUd{Kzlii{vG>BW-M18PE5}l`@{YdMYrh89&W!jLK@`yvSikt>UVvz zlJDhuCMHlJ{L1Pz6IpV|+wia(%lUD-Q`&MbE~3SU^}(`Oq0zd0RVEl()stK2hK^tgnLnVP ztbp_nlnHckb=sXfjZaYD$hI>pAP=WM@^N>!q$l9J1D;F^OCup^EA#KHe;a;RE@9XY zV+I_9VkVQmq7jYi>{^tgfgVEpm=RF#WYLNKY6J)I(#KN2s)MHJFRrp2FLBp`T_w%I!xkk7uc{va(~!%z_la1BpY{V)q^) zgHbO}%&Palr^DLjSSfZNO(TCV2J-P&$IfzIPAsO`6~;=2WWhWpKT|-z6zlojHOk%P zjlQph2YNG4P3S{Ms-f=uwWSL-uR@ z9SJSv80?yTO_ZC0CcPpSIoe*BIay9Ez<}ffcu6DggL4B8f@vo5EiH$Cu8qcE+P?^% zI2V>++&risUWuXtJzC``$bJK-3@Z$ZI(DT+$whNH?9FHEd zdm&-jlW>=v&So|IB;T7X4^reE=j_~G!QRPHRUUfKgS9<_>~~q&?;GMKGmbxxwDMX# zwco4$GnTyGvjg|2HaG_4)4=Hs7BI|GEwtG!5a4@4M;8wNtvvY3`wCkA0L#!T!-5&~ zSVQX|>l3*@bRt%JF1N{wm``NzP992~9*;<=P`7e6%xnUlJnSdVs`JDbGN)UQ`p*is zjKQLr^yKE#Yuf#boX@sfmX#|K z3sV4|D7@>tI(m}paqI6?HcFmv>hP~MEeoN_3XH5+xINZ)|MGzz0X#fp{CiT@UaruI z=593mq`awasb8Z)`a4=Sl_uQO7_#4h%S+J>laHNPx@kE$jfgZFyX;%Bt8B)i=0OdL z8^Ipu=Kmf!)oV!qeuyU7lA5@umjPWjd!}=bi4r>|-jv&Go!|>4`K zFDk#Tb}!X69%%cqaJuBTsa0JZsegytq{UKcvGGO*^eE5eWPy57VdvrZ-B>AKp!alW zRCITL?y&rv5P??1zTpkI9#jzwbaXuD9e50fA6w)H>>Y`;RB>Zb`pXIOz0MNk{P%V+ z&{MT*fc#&=^;ca+2csX$k<56}Uj_Gsjc{4X2epLwhJ>u5CJ&t(dA@kH|uhVn* z|B?!mMK1GZ*DE4Yc`<@$hefUedhp?|Xn=g0XNmrVFe55NESQ&HVxFolNu7N~1AjK8 z4O;~R^&an@Ip#6=InR3|#bnVuj7rQ54AhBQ=5&_i4D-|PhB|A49_s_#9^mQHxxk4K z@jflV{9X^c%{f*1I6QnY;iqHE!Dt)KY=+-npRkK60pY%vTeUBfT2dB;3l;vbtfi1b_W$Pmd!THjyQ2nWJ9VgG1Jm5RA1528L*o<1<1NkIg8U~*|bLEwf zh20R-;3BVO!_3#)7q?PzheO7Lwb*P*=IQgaIG3*sD~?y{93Oe?C6`Y9MD@<<9cLQP zVSGW)t>^?Yp6L>^z>;R&!K!eLgm2=36+ghAQOd;%v#&}V-~{qjV$&8c39;Jjd;jDv z#=>~Uu|T(Aw2-)IcO|P}qUHVM=?8iX3BMuzAq}L6xBImv`)ArmzQ#VdpJiMTbc@wL zr)96RL;#-E<&7W5tE0PVhkwt(DE=!1i=Bi__k;N~nrQuRWwlf)aX9EP50gXIXJ`B< zQdK~p<@3w?(1E-kqyrmSr;_8ua7Ni@2iXtdR2KN@!FSmBw${#iUhe*zvSo8wWS4rv z5ADX?2NVGYhgi^q3o@7kj$edhPVU81$G1ejoki5I=T?nT9j?8?>g%FhdL2N%W^&4E zgHcv9&*gYr3Ea1PJ>8$5!Pp+Hr2|!`F@Lv1 zb)LZ3Tt``EqV7cj4Vj;8-D>>ZJYi;4A{#R9JGNCk5@lDwV2Lac->8YX6XN|WnF4xH z40m@xzMZjyDrj-C6J%B%-7Y_pNE6?k?cin$T;50JJ0KrsPMo~W^52jW|6cu(P? zaO+9w>*1iB8^(>y(wl|C|Gg%rcaYzs&pzOKzkP=3sr5!$1u=MNkH$K>ib*?ECD#YC zzGTE51z)>3_HvpZ7K>z-qz#P|M!4F2SF2NDIqODJWv)LH%*Q%&2x)&_XP#vQ^nzOs z4ng>oB&~40d?Ye_EiQH%a~kwOzP2WWlXsWCh)WjG5rky?*{`7Yik`XpeluDfp)ZL#`M*{$b4+KNjx!F7zJHKz939(? zpWl56EAk8Q#wY#DjLDBK*oEBS5x12#L^cKD<6*OtWUpTd+AmHK3Wqa-%nh$V;Ml3L-G}>mP7y^Q-JZ~`t%$gy5=zQ z6+6_L!nDwcCFTYlx%$O7z{@)wY1!Y7XhA;T*OYb^>)+KJ5tDJ~O%i?u zdNl2I7=Ra393Dvhl7ZkX8P_>ex8C3Wa`!~OY+Z5Qorn|#WuDJ~0bj1%%r z7Vk(XE#6d}2z;b@J=L&N6`2KkKUJpS0k8abC^qai;_;ufQdR~Je{a^NA%7#f0k7I2 zHAp^$oSi*XpEZFqDC)P4iCtTXM%ZtzW(nhDWTE+95ik$@$N@bzRAb2bG0hNmsZ>3i zbDpHDkHDN?xfN7`LqxsDT4YBG=?_g^t2Y2I{5D*^F|2_0G%L z>{h<;a8Wz+dRvfL$SzgokKY_?G8u_tIp{qg*Fw&>>+;90p`^Ba-xeHH=$|4O+f5b8 z4Wp~ROW{iTfG6E6L#v&g>5O`&rpEA4b3i_SBpx7)_8X3LQ)O>gd?c^}^vFpa#({iL zaUO;XUJmmd!~;Swni@)U%}N#xEA=mTPfc`yk1JN66{@X$yz5}E-(KZ-u$);>_rlPDi+Xkts zZ;VC?Dy4`IIE0lR#*lz~G)5Gyap$m<{C=*?4agSJ!W@kz^e77h3UwblHg)V)Ra-&t z4(b}x|4XCZ!0_veGnNxMp2pWS_iwp54laBb$Y7fFg$D3y3dlq{ADMRA52Gv78%my( z>XY^wZEAY(+W8|blvdpMI{vS>YqTH8$B4j-+!toi<{mofNnk>mGM=Kgg@lVST8zvO zsTb)51;fUjn!zAPlzMC!WvUDg-^Kbs-1)BuC>-VxY3#yppoe78Qvi5GJl#btRXT(M z?87!q@Dgnye;1nmh@A$(DjP!P+lLj{kkd66%UkjO+;bpJ;n43$at_CU96{sR8pYg7xyC}qwVq*-C#A}8t&H7{nZDc-c5{??wcLc+;52R zRkYV56xBBS5`@)IxcE+*!L}>xrRzhWN2((O>HjTnhG*{T(bFS|pA5+6G8Qo83_X90 z(ym|}w1Lcz+bNcCCk8#%UNZ5PjjGWg+UE@Un=3V9DnVe(&6hN9BXFf zs3}P}TS9BEXk3ZSD#-n^VQ;f`MogQ%y7lbtDlO(Bjp;AWk4o9@?LH63T2eVHiVL8J z^Gge|J~7WfrzCXdk^fa{p#9)&X||ijC+lcK2XUFO^uIv9uQI6h7QL&1svUG8UKM-S zJ!DFhBW`~>`3sn4+%^MyWq*Ml+{Ytx;P}OD^z8raX4H@&f7wo^BhbkIODv}&RW~pM zSqZe~#;+`hS_Y9ABu0!N<&JCy(6gzvHpUDsE8KZP)}onBw=sfcMb&5r?De6g7SZmj&U|XMB2R1Q(*OP^f?h^}2;C$1Sjxkb+dqy%W1@vPbTLJ(zq)29X(N z*#dKHecF2;) zQd_CGYv_wzKs-U^UqoXU{c~Bxt!2I`$UQT5KP6huHc+;vG{ z(Hi}o{wy?mN{bbU=B1twV};GIan|69^@e5z@Zy&m;=j?Y81`b{ z&m|(~Vp;7*$iw{sJzAO9kn6$0uYmL(&Vtt=4MrQ%gjC-~I@6JEI#Rz8laNB@Ursgx zT=jPQ6o0*cKJiC7G^7gM=;-B8o?cYKb8f+rKyhg*c zPGTLFwe0CCy`+aM_StG6pOuX$p?wxvr;g`~To2V71!!gWDLP-er#pdiL}D}ke*JsU zb2x}V1nT8d#KU$qT()La4BQu*aIi(PncI}owMCL6QlA1mL5DNP6jWq`0@&NOQ{VXQ z!7o!ey#xw6T+dH1Gma`X9{+m;%vU9lNee=d-lnsU}^vA@W>l$;q6%!fcK4msb13-k&-ZSND7>dC0W&|ntGvk=H} z6+93PBXT_fPwMWHSjgwbnEqE3^BUQ>9)B@@*N`rkD_UK^&wtOWa{h`0dT_r&^?-U0 z4Ub)5QD*b5E7rb=`5WpEzfBbQHYYCnuE{A7@UY-a_@RTWZJ9;KZmw+OUA@N^)>1@| zeGZZ4xh^aIj98(99-H}97vPb0qe@6fmMS66UR&?Qb$>X?Wwz)o+yAhYDoqJ^n(+oi z@q&LeyI|!X4(4?u?}vQ85NaWN{_0VMmKWB<>A?g&3i&=kz!USK*?ATG!Q~z1@d5eZ z&F&LE&RQ;nc{OUsJ=<0*A;Au#I94_d& zrxK$89zniJ^sM$%zUZ^WbW?J*i6}8^lEs&iB${H3RKN>&HN>Lw4rFNkb_x}t&`*1y zKkZZ4<^R@CM=y}94C<+t5cG&&@j>Pjp^Q*V!V0LpjIHk^8$1e8uD&$Dqsk|x|9d!H z1>i}f>{%J``r@fL@?LOI4{jgbY1mb{s1jOb$DU_-tQD40fgbG3k6u7NArr@B`k(ag zrUc8NbO~Lges#$udr@ju^meb~170eVBt?YJlB$li-KTx4dg$_WET`0!Sz3*e#gE$2 zI@?VDd&fH9{qr}QRL6X@(0XPe<~wUgI@dYbPxRIdIGw9|t5xY~*!=Px{QgPYFmSHmA#sq(Trb#E8Fr|&np z78)3DoZx_b>U>BBFQ>yBCz{=B9jonjOr~uslkY=D*vARC`j#c`#F_p-e$pe5{dtyh z?&(#0LMc8jJBT|)=ezL=t%m-B9{BxRj7&Pz%5}z57No$owXo;-8x;3d)B;nZ=J<8Iewp+qfty9rB$t_YWsOe6!e&RKAQm^i#`{P(BaQh zFYolL(%(?$kMJ&5TtAJkM|I%BfP4cua6dInpuO^zveM_0bagSU!r)xs&G&x1omy>h zhJO1?4)kDUM~VS2$2YwCt+5Dx?R0$GK$6; zbz!qLbAP>Af*;S54w-*OGREs3Al@j?4dbNLO5;<#rpbJJM^=F$Pko|Z8sf#~Y6N-& zj-inDvOGC0BYE?l@pZwveeT5Vep{==*Zm$d9C#!;$ooSVBmy0$&c92Ck!9-4zDR~% zNiS)#iw`Y6@WL_cSYeFpe*=0rwaYR?9|Mwz$(jeobC8n(9BCD=j ztMjbnyl;Dd#6LXDOxT~9gop=B1D>Mcib}y$8;NLYDD#mpC1^sx6_`tcM%o*;0zCvXjC`P8FC{VUj~(%?n1qZAy50RJGU)Ij z$^YKaL_W$T4tOn9M;Q7n{zZlOacnSMk3$kv8Jsy}vL}N{w^xJd@>U7 z?5*$)4{8JoPcfE3!GKXe#@eS<&rbH7V1(g1;<)cVyOVs0J&?f_O@E%}V-1d?+5v#;Zq!_*puaocYs7tSwK_ zvl_*Q2I}ol-9hLPpt(_*jyFH$2_Jkns(FDe_`MZ@F%KK?l;pZo!bqMF`0c6hHqSiF z1m9SH&-4$0Z{BlvtwU7M74-$Zm^X7+fQJ$ndW^Hm4|nBc_S#D~U@%XHH}eIPw~^?z zALRUnB}X;oxl))$Wx#u+i-{B-nGqR!r{&q5HW>Ik{>i;QF%a}<7Iqo|&*Sg_P06F) zT10XO{fhwpZz&cfvQ{}gKqXb^F$f>66 zJAxO|A)p7dZCL?$j`jS|oWdy9j)5{Y?OB&rp$Yf(c4@u3<7VuJ> zI4+w=??$9Y*J?iD*mMi zj?PZb?EUy5Ap8!B&;80W5A;|Z{2}c{ugUeXaRe@dBC|?SL|moI_TZAqI zUX&A-J{J)gze)K-J!-wyHH50gYr-e|#ta&Vdgb$UhN5Z_=uvgeAOrd4^BS9WNPl(? z{xF>Fx)dsQ+@DUTUAlCjtkr>xS7BczC((wd2O=Ox@St~mW~)4GBLX)=Qk&H}NeY z^cG(lDM}0Q7(>Lod}3bQw301$I_VR8Q2d(NY;7COZ}ZZnv||l{Yx@X#)ON-2fR}D? zz5g01u0?iE*=3F-@8=hpZ!3s`_Siy$A0hMO2Fm*p=)%!SL+|b_Y4yU!3`fw-Mq*+# z-?>ml{d`7PTx|e7n9|e{z{B~>*^_8W%$QUiPI8fH=EcGhTSmbZ@&!ID05U(6RJ>`~ zdH<4azbT3koh1Bq76bb$A-d?L=+YexpYHt+m|sDUP_Q)@@Zvv4(Y`_mrRlO?7XSWW zAi^eywIC~l+JdcjA@=WMC>9QVe_pt_SV5%bh(+WJ*^d6ZTa_<8PFW(y7p8oJy`TF) z??0CAGOUUw3 zT4={7CyhO{thnPnOVt*76)!H{>^szq3D9Fzl%EGYEbk4^aZ1shu^wKWYQn)@|OUQM)wOb^?RRcdNR{_(1UkF;{iMl zXgLb#)?++ftr;O?3qNw^4%@iO`4)8fsdYBM+Yy=WY(v0-DuvPM#+bGDmGKUkk`q`e ztE8hL{#+y{^>_JSdkL0B0q-gB&*1MDr)qSKsdSS^(HN*mUF(}y^2*d-HVgpo#S09d z(y~<-SSLXZ3vcd?P{b}f0z=`PLL*x{Ay+Z-gjLWZXE%-jywGPoM->aK?$4>WtU9PZ zxqoE-FevF@%VwX;M*<#w2CE!b?=07fGu!I#y-++DPP}vOjjTcVUR}zfLKkn-ZP3Gc zE`qFwhI}QD`54m_Ec}C>+Gx`YhGIMG!fPtrRM?Qq81OVsI5ZTU0wX1Uo%v1rgAJe&B8sA|uaE-m|LLf#i=F`R42fV)_i9#3O_6~5_B zAuN(7`yPBAfXn>+mh$0e4zD4ezBHYP0Kr%GD(q%sxsG);_89`AmSzv2N54D^IiL12 zW!+-i27RVWkyh}tkjwh{shi!#^9>tx_9+_Be~Y{rcFVsm5Tf6|NjP6#>9l-^3eERk z8^G?J^SD^IjQ{uqdMsO>3qb#=GzPn@IO)S{zK>A-aaQLeb1L_X#x}zqTDj;C;GG9{ zzu;nf8Pn-%ZpKeQK&-qJmH9|@LW*QPf{uUGx9$yX38@b;>6t>V-#8+nJspf^JRsSrzVxPhwR;3c@=V(s4%6Ti)=I`Iuyv zaG)n0_XcwR44jLzd0fbiSB|CqYG}*3a+|#~HHJEe^YlCuI^ba&t`dph%H>2W?Z#2o zx-MtsB0nBU+MO959{<2k`wO3o0(!JHtdRYf=3EMq8QB$0Q#t0nd>@&nH&)=@Mo_+F zsY&yJ+#hNLYuT}?P^*xWQ8SuM{&LcYQY0St;~5tU?&sIP!qZ6Ha6u1gskjd4KOq;{ z8+`@#Xyzcj=Ytz@S9s5nAI&_2bxL&K9)Nrce3=L_1KLjSRTynA5bJOJ;q%q1rUqp@ zR*;tl*qbJf|9Q?XQgDFhV~Ww!%hs^Z@uN0oDLyy|Q}j!K7m|>UOF{+<;Jqw$5r6AR zA5wV`{xYeRAQxBCVqjH~33o_=^tBk5{O|D78Vd2;K>{ie$o2g zDpdDgP3HJ3ePC@d;C*n@fjSTUG)MHc_q)|SYx|FAg?4&P%OfB1q5aXF1`;1C(7R3P zhRipv5k|7J|Gr+U{3U#*V~MGxTkqpm>Adw_NZ2_0nq za!GX3D7pL^A5r7l_|?Uae$lxXn-bm@%FEd_UrHzqmIIhUkCHDu4Dc*JPsC>NRHQbZ z8zzWPzNosOGo0`F10CpDbO4!Or5+fpR7u<6eiqLqL~ZbnuhXV7%~>~aX(vg>i1ZxF z;N}E9hLVLVz-z)VT}CeJLrD!3EdKj7_(OLv1v;)1V+n@=v`V zLn5PJg}KtPevEB@>uv7rA~w~Hkm~!-+X^d$T)*K^TJuEjSYh@IRo_OHn10*4*)^c^ zYr6d;HMtLXi)(cePvq@oh!sfRIEi37Zq~imMp(Y$2`#cHQFaEX$NuxK1ZALre7)`v`7qEt#`cU-u$2}?yEFE2f9k6IRg2tz1mWb?0H_TDg`SaNLS&VmNF|JE20^Zsu9W;5eHnk3WFYN z`X(>nS-Uo6<@0IG_Lfww;b)*oj>4p>pq5LbyZ;S`%-6KkKHL$}KX*1I7stGG&KuvJ zD*Mb$nvgxX@fqo2PKRo1A1&dtbqm~YoBKO!1nc7QXimgAaxBP&I;2bUcZ6wq` zmKS3?)iS!V?GB1XL$oKdy}cE-Zzxw0Q~qCjN2#g+Z|YCGg-ryRHmW4;YePP(J&BmP zlCzMdN-hFTPrxIkAXlb(z_m%yxAHU0VCM0q(BZr`-&#mr*TQK=`6X7V3VOKmLi2y@S&roqIXj^3b?I^Mr;DvokE4=c6K5Y;r7QjWWY>MRPcQt#u z%AQ!ml1D_|*c{LXJ$Oy0IlybxkTpWB7HMh8VuXrlqfhfqbxk$&e+Qj|{2Q_!z~AXz z&OJn+fR9P`qV)Zf-E0)J67&ny;*|>j{lloRC@fvjOOum?T%WJ4@;oyot==U<6{x*O z3QAo)aiLeiF<R-nqzo*R0l0oXHpH5K%(Hck6cBX6Vkd$fL ztmre3i;T;et_(itFATkZMQQ?i%*nCFfami-KG$KnU57LKlWn(1h0txJ#|=YXC_i&c z3NpUsiorLxqRl;x+E_DBS);(+eQ*_yTBohBI~tB7ax9fcu>n1%%^b+}^pjx0E@dn3 zb!<@Qb%%H0zHDpLa^{m@OkQ`AE6`p=W_`q_uS_9YE?envfqf70{Cz}qxmouj;hT#F z{b|CZ_Miu2B3TXO6Ck&>Lgwyt46+KbjeFZEA>r19dtarT`g05g;Ghns9T*Q2qnkrQ zkm-c+cJmI%k<6c)H$;qG+P+M{SA9Qm0=@DhepJBAA$KvZ+7~5#;_h=lz=);@9oCvV z+$(xz2gd}NPvXx*vtA@B*_GHff5asfP@KN6KJ!`1?T zE7k{sL!!*%Dwx*IH^V=lu`n8Re8meLSeMp-d|V@gYY*12A(3S|bc!`tybntJIPZ=y z-db(8&y15_3pfOV9_`iUB#;L67(p0W$yl)IJ@ynhTTe8YgLG9M<_lmONZI zPbu^e>T#VH@Dko(B*PCeqHFX!?cDy&l=8NndD1Xk92&v+_L{b~KiuS>$Ett~sXu>s ztcnYJ=ba$X0#}AC#cdd-^G)S-G}JF?QcqjJa}4hL5gX?D?W7YgpkUR(5q}2gVg^bPG%5joPI~1;fLzm zu;^6ol5|#tC5Q0IA2LAJXOhWXIRoN;Ge3!)>=;#%N5D5Gr5VuTi=PyZDqElKtVvaY z9<7Qa#B-x?5Eyxp!LPpkiH12=ri$Nl9DPXY5clAyh#SafS4)j$);DhoUltPJ7tgeA z-rQXNf%=H*xK%S_>C6RIcUH7LSD|6+gTGpT73%yi1&LZWt*kT(S1UT^;B#=P^R|=lq72U5=I` z;E3j|eb-mOH%qml7@Yd3HZRfaA`W=LqF+OEJ1AfzNGBw(dx?;-_oi~^{l)87Vr9pl zb(Jtq8bI%FVLfC&9LyJS+~;#6MRk_@(Eh0q(|Tu_hSwU>o9t!{yMQ;}%iur;9ZVO& zq?ajPip@y_4~4R73)PQ{#%_Coj1?%?2zonbeUSQYh+W0T>ztmM&~(T5_aZnWc46HD z#be>`78Nem0dGzhSKs4}|55q_LZ7W^SIgrfY-z5wLIJ!Vr(&UIm)`Y9&|^zA(gylZ z?#v=>Fa2|$tp($&n|1s7rLM!ZV5x=mc(dEDfOm2>qWh|PKETJkS@}_YW3dp=!H%mb zkY_Fa(KdR$&1d-)5~G> zZf3KbaVI<9FwQ@SqNMy<5<7{%_%ENS<{999w=jMd8f{z;8x_`jlO5wbWs*4NZn_h` z6&MPc-#g)x@P2=X>+rXxPCfWlX}CrCRO4Yev)8T}%SVId)Myr z3XZMhvK##KKJpDgelMGa#sStF8%+N8$tFl}Uz#akh+2MedBaBFIGh09N|I{%y_FLm zHR>|5rdyk2*7f#RWO|Lug?iPIV<>I&yj?IKE&Vp+ew-3K?zoc0?OYtpfY({NXw{v1!CsW~b7}_yqKj#wXQ) z_U`NW#buvlrLz&&W%0JwR-M7TSva@-Et|l&09juRNKh|T_#Le0q!#`Axr#cHn2={xj>IF6p{Iz(O20_2k*8ehaPpu)m@pQE`M z;}!p-@_vxy|2KuflBDsn(m`9oJ^t%IRo`{M`v&{swuGDQdM>z&4};t*dqTEeob{fX z<14M(5a2all&BfaUk8v6e7nc+CEa8r#vA#u<&PZ#Il7Od zB-~xE@xf!fOgbXyMJ@h-%y-GWc&TG?`5eL)Ez7O)^aZhpF`DXcrXpyyk!OH>?zU@& zSGS#252&m5s}{2pTKP=Nv@KTi*&&t=Yd4I<4Je@3cc%auFPDF8t$%QBR{8(-e4(iMwaJZt;{#pID>Tq! z6~BS(FL^qTVPbYe7_wjLG21|W)Y>9%Nj>|ylvae1 z_;iq&0eX0W=@x+3 zNU-qPy}YFXCB6tA7qFS0FP=_1A9P;;*oVZcQIlUc97#osIx(x zt_kv9_e!d5pN=Xu=)rVM=mFkvu>w!+q4*AOWc%N9QcUYtL`r*_HYz+X!+LuGZ`9<0 zy}vl=`&-(PxGc(oBV*#hHr6DJ?oKA^xTVis z1$7j@YQ4iHZ+==7e>yYf1oOfDbcCEwe|yOHyJjOwjE{>Hzv(xV8<~r~szXVJNjU3; z9KXnjZ7z|)=vLEt>jL8xPb5_gc6NHpHa7H_e(c}9dU1CIL63%&OAcsnE87dC*Gu0u zvU45Ejwu<_VQV{OWj}1TyEkV_1Nn*(*%wY(|KA&=Qh)wjXLZCQcUXeKzD|8UgPOY2 zJC?~K3VLJ~!9M_RO~FoV3?)x@7)H&i{HaAevd|>ui&w(QFA;9Ydfs<70~bcDW;CeI z?OG@t=rPTv9}k+7bCveKMF}Jgf2!2QL680LO%UKMY=5n&8Si(2Kew?Jc>$}_R9OD; zh&w@}Ff;)V$Y(~B<2j+9Rcyy;sx+wcQv1oZ#>*BiZ~2IjG40oDZ(dDV(BnGjg6w}m zzo(c|F-4-@v7q;fs3+X~+g3o5JHQxi*!@}_@S?`&NBe|TUN+DkviKLxbMJlcc}F)6 zy-Z>sl;yh>Z>pgPdIbCPPC!0hyfMPP4ynCtjQiaFwsgM4%sdX6TxckPUPSyfq#nUTW@1js+AvS@a?8HY zol`#hnr?YLCP2Gx@oodihkL{yYyJfFE91kK$wTBL&V9t2{A8#3vm*uK18W^!gOBQ< zM_8Cc1>_U##GM#5@1%TKlAge_Q7=N+?FjDGYHPSx{;dLdi})FZOMPjw-06ri9ZE7$ zNrLE2t(l8PDsk^AzDPwxaR2jC;us+F4OE{#v*?^0Y1BXJcJDG$a@5)>juLug)+lSk zCIPQank##y8ZFKlT7UX^PblPqi}~AN0kTosWI^Hyf&W&RCYa9}4;+8BlHMt7p-q1s6#vfXmvzGq;C*+{+A4Wl7c$VNkjv$dWV!F9H^8lR^;1X;IhGq5 zuc=WR^hjYJe1Y~Fi)@YLLN^TCatW3DHE%q7aL=PD)T~KQ{$*zbJoqsv>bY;^Z!=EY z6{{L*P{mGu;mu~g9=>x~K~DOJBKArj^l-izWC32TEZq$(e|1GyK#GT&F5h-E(Q8e@ zw!hu+TLr9uci8XBALYmPyyHM%BdA*O*{$*E`02HI2@7Ea!tAGx`~fr2<46kZ0lWx} z^S(@(2o+NGk+4m61dYRuWwJtOu<;+MEYuMTKA;T)%3bEUw!aXbp$<1&00u3doB9mu-Q(3RD>0K|BIuw z?PN{g$-T#c*htDAaqlT?2I>by0a(pMIP?N4-=_)l0d$Sv8zgyzBkDz3!<rmI6`{QtG2j`F7X#-VjM(|MoW zAnUcJ)J$3x-A&Hc*7fv!B{Gq&shdaKEa*wBB_{|u1quB)9-zk(b7%_mU%aAOoxubi zF>WFmzJF`-MsuT3yyk{Lw`=wKD3I^W+7gD5H0c9g-^;o(l|qrHNHn4rC+DjL4usI? zz}6)#KhR?}e-Z;cA8j_ySXy?Y+r@w?%O+lrtqY?+efmA$#tZ4>Q{uaWUT&s{MAGJc2=NmlpRRHLem|Ij~AS39asVNuX9 z_fj8&Ie@I6E5*&)pO5CbL8)~*+^}M9I0!6vURCdV|Hjj9w?l&>oecx?!M2uA1Nqo9 zu-xtjD;6)eBgnT=a;Y5k<0*79<6l)XM|A=Df?j>hwe^dqH83vk5F^CxuSYIx8iA>Z zq_`79eJ`cZ-WvgW2#NcSfEQIe+^*0fnFDtumOn^B-gBdhQp@ba!^3+c8(dxshAeN4AQ zqV%T3ND|Y7<2uK@z5||QVn&>x>iafAx=981oJ&I1j1^fsi+A3&@n&jBfxA!6iJ-^8 zN!$l`Hq*wzi>`NEUp}ypD|0(Lj1&1#1hZxwH!dbZzK<*wkMgyLz8&o|XFpnRm6s`2 zsqK{>Q>nr?ZDaaq=uTA$|Gd5&$a)I*UkQ}(z%Cgy6-$ltB>zoi(wz_)UTamIav@nD zAGzRHdzEbM_YDFI&Eoj75wxji#_D}`~qeM-WUbJVQ}CU_H8DI{Te-=6l(x;_D>`)=IBI) zrr1KzBiNmX?0;TReo<;=tSUMDYEqW-oc^;q@*V;ivD& zl-1Wv>{QEt459C^;d|F-D?vH8&zFH7M_o$=(0|2l=ZOehM;BH)7{rux*&#Tu`(C*= zZ{Rz$oH+pPWl3Iir#UrxJ?|*?Qm5tmdut534^^O@K8(cfw;It9wwoHzBcnsO0K7?h zs=X?yUwDj`V;x(>)WERmG@CmAB(`4ns@{GkCu;YU}t! z5^{&0qKu@g)e3raGaZoi0CTEpb!=w=#@>xv?+1o7R@wW=3FFHk4#Zi>3BY@)VmiH# z8^nSU>!M>Vt*)`}M#|wXsVd!OxtjHZz^Qey9rSRX?;!hMI$wmH9>0E*jj+;~ymPS7Kv z#P|iYw?g$~d(|IP=c|uFa8t^NkdAO^_q)SD0tfA7$ocu(p4byzP1}o%`y|i6=8QEi zC4?8B_>hp&xFw?|bWiltIzaDjB?{#HcVXuPO3MW-R5M3#SSBusEo`>HRX&J#{^y?$NjvUhJ)p+`#pMp<>yv4Fnm{V$ z#F*4^oZAxW{0aAiLz0XA@{Jv9G2o3zisN^`Wt%Upq_xd$ELlZgUn~^x`lGjCkWX^g z{~`@x2=tKXm?7)&r2?X)I>B?;24Lc0dMdKe(X}5u%S;|J%-8v zG011sF1I%m$JTsczZ>u_sF8;!q)KX=P#1a)dkuU3oK5x|zRZ%u`skT|j@d7qxdD0z zKX`Kh@2T^tg@Nj%zCg?vp4e`xVa}>b;mEE=LJNuJ6X5+e9x;B%D>s%H`?6bm;%eTF zE7lT=YcnFOeL?m;`2G6L7U(fOQq>>NSIRKYY@sp>eOar-?J+Xo(RX_s6jnBSB89xB#E zlG?|hM=u3m1muHxRHJ_I-n0Jyss25M0zP{xa~!cxXO}7kq^Ai$d;3<;O5xZGDJUFB z5nTgJ(&0mNM{r|2G5h!s7BAw~qphr=DS_^ocnu&}CSso3Tb;NipOo~jHm}+$? zgi0f@=IO(L_kvU-*0!FSTtA?W`o-rIJmea&IXJS4-35y#IrJ>3tDkqEN4k^)IbV4< z{W4P#rrg1CR`4z3mfp#&9wSog8>>B+Dux^%73m-MX%heM5frYJpSqWfe6$~0iA#&} zqpa1S1#J;i`~QL-vo)(Cknf7Vxc)VZg6s}4wphCslwgv;Y{8Mq=13a)r52Dc+WT64 zdsYUs)HH``JiPF;8kDO%ij&r&!Rf-1K!ew1_XFr%_pKrT-Vzfx2h!^U=}6PL$u1iM zas1R-=3r-seXCt|$bO6I`g8x)j_{8K@w1-V^{5XM`L&j!*S;`vFa#Q6pG4(lV5}ka zCfd;@9Ka*`IeZ@UGckHJD%8EXL zBOSn7GZP7@ltn?>HE)d-&(Ip9wAN=7g7TnPtt!eCQC(7gfCoMD27*z*+tQWu!!^qM z>Euq4Z7xxN$o+INiuB^;@K=7V-+(6|y@cd9UOFcUv!DI=iKa;E3+wc$b=cRvuRK3` zay&29kwFjs$JIUHalOG;iF#}ppY5oa6<|6Pi-r!(Su4BDzp*&51ibv|>F=3=(G2Q% zHv~Te*e4>Pj&m9&&JK%u+BR{o$>j4;Ko5?UpbqfTpf~e}SbaPH3daU@adE_dt28&W zc__c}3H?w8c&Mn-)1xzUWo`r?e2o+JzTC)v!`#kc=nKd_j?EYy$Nc*O^e``CAmhie zqM*4|ZLLncc*$oKr`}&gc=FxfQ7o!A5m_PgjneGR+F4`+G6di(&|dtf~I z{37L*$qv9-hiBGEjcN1y8C4|rQa zvb!x9)j0(wa?`$0Nw~1C9R@Nw3<9Bnj*$CZ)NQem(9^#zu`}hTvd@$2_`T?;!NJ^f zU_v~p6*9&0=MezCeqkd5za!1%=kGDtn^!_-oLRdTdSc&)N5ww(rtOlht;pZqB znYk|hJ=U%!SFL%bk(?&LBmCMb*d(nX*MB_VQHIJy{W4pXZZmmC;15x8h2hyNSRYZ) z!;`v*2l5$AEs&Pxu6Fa{cCn^W_YS*$!x1+5A)!BV(h8|Z2vyd-zFv~Zeu(vCmF2fO zFp1N}yU>sFj>a>BDiGH!cM$` zpAX0vR;hw>DX0?kms-5?SZ9z;8Oe*`!7kCK5j%*m&E1|sO%n9Z(G$^ue8Hr_6V3wy z?hdQDidkJFN=7iqx9!}My3BF}DS(H2R5viwDU!2Tb%k5$x*G?jOr=4{JN)2AeM@+v zqbCzC1A0&!hhu=3UNT2wxg|~7=Qe81jhWtb^gPzwDZDdznF_xRc%eSsb=5vZXrtq6 z=&ue+`RnJVN3Cm%j|A{M6#t}Ixb`W49{#@R7T|?gZd`{DN;RCqjju+o6TgLR>>kE+ zyjvEBH8uvkH}s|6(d_@!xZ2uFe`%|BC=yI;4NBx z7ptuH9KslRniV{MgXH5jYS4!DT9kj{+7s}&bUp{)+UXCgZKL9sbgz7ne#!H@&I`Mw zHXIozx2!+y`k!}n_z4d1jE1cj=+OxhNOlh%`Fx$AgiM}IVbxR1Pa}sQ*9)=RGH<36 zjtLu6kp_r)?aRmpn#dN6iT%s_yr_0}-p9ZT$4J)6uZ+b%c}?sKkK;)YS9c#{>p zwM{^D`Tt`m1L5z^I*QZ9Sko>TLedVPSmrH)qZ`m3(j`mg_hQ~lfo$G*ypO2Bw& z8z23+%pPrbU_9u(nOTB-zfz}98B5bAlPF|C&?OY_3rolZ{(s!P&f*kn78&4`p_Bz> ztxJko2=_d#$8=1_rQaEHq4=l6`cc^54BkX@B>n5Z-v9Ty{r~qT%@KJOOP$QPLlb{@ zCxeTqC!CCG%|3^=UQR)-_if3o)VngCB$|<3@#hdWJ8Gb{c(M%|kfScts#DL7NjI(q)vPsAU`8qK3bh22F zxx|>Bb$kz8B28Sby)ylG{PP%>zCr4V z{WXKUt|``H1zylY%`y~%Wl$a-GUG;vT?g3~Kzqkpt3pBqmCRjYrBiK<7b2R6qW3+qKly zyNWM}Vw;gy6;o7vxjQ9}fQP$mZ3h*BhVYyZ`;|>*IsNtQtvqIS3MnnjPrmhme7}iS z(90q@!Ua6nx=71>^JsX|xh>O*^*P`q%Ow zqp%HS$Y1jcu%!npOw#`hqu@YsSi zW3vT#46#=jHb_fa;}T`~P39^es2!T~g!Rb;+mkW`5aA}?=gSGTrZNfjCJ*b`uc!;JgT>>w!{d; zXo~EdPP=##yGkoYgexv5FJXp~xH#pWr-wj~xQb{4@H)e=mkO3m@N_XL$ zTxw9$`J$C#e1KJG8uUo|-$Cjx!BYHABonz=T&V~zziYr8X)ri{(CA)C7GQzuZSpkR%(5TV z#Ym0}(RafzbyMIuoY)}Ckx;v60Tumkjc^faY~|VVv~G5l-hMsEh&CJ@Fcc4jH@5t> z1bQ&(*O2{iiR(2thJK8{hT|lZau>1-rAy^3QX+e&^60v&fqaxGI7dsfh{L)v3Q?u* z-L~etf>x4J?8-Ad>!GOoh)hvypvPAA-3sVGiGzg@^NU9j3WXiBg>KFRN;PI?Fc0s%Q&K2|GXj$2f#at+Yx3I z$N$-CY`&1QDX^jY&?NcvyA!(fx5Wz}U$CXbnVXCs_I0XE-EJ?#k~G_Wd9Y~$?BJ!i zZs`~us`~-xQDZTF20Y`|dMryGIFuJySu5!Vl`MMKdD|&7Gc+};?l^#F%3(T+JRE-Y zZc|%bF-QRIbSkk?x(90B=hMa{G-++Y%^B#Cwbq0IUWLOKqb}UwjE}}*DMp`u44mI> zd0o!6-f;)-=>nb_LP_8u z0Ptp&>bl)tg`aIQ-dYiNvD5wxQsd;-xHVkpAxZ;0t>3Y+c5LW+x+LD8UXQuoS*1RT zSkMipoO?*#VYKHRGT?w7{A4*~J!MLxvPAK4F-1Wl4Fj2mKAkLv169i&%DE0{#SZWs zPD5AOu~W-8@yWkKm&%DUJ$3|k1pJ^c$UY->^pvDs#{)f9ty#$W`M!>OlC2v2!0)jv z;Z?te%q^G_==Q>QCRjeJTYy(Im>Vc9L&=lURUUuai>3W@p`<7=N`*f~p2dV9hF#u} z_+P&6*>Iq}JW;Jo!$h5Zp}Cchm^^>0{6mKr==sf6+nCNE=lcuS;E30c-XF<4$8trT zP8+~B`ZMGZfnGiPC&>JOjQHxC#35q!cw5Le4EeKbnAIltSTnQt zvNsK6|L)Ci1Z8Q3L`sj*Si!OZ3oioO2>c>0oq=d6V}lMDq_B~H`99!_L&o0_X8XIy z+}80-XU}h;Keg!nLBMzcowM#DkSF37?R)nKCly$T zLRz;;*7q!uGM^Rz&*rL2n0_~TwYuxA-dTwBaZS%3gYP`NFdXVp&KnL_M2D21$Fdt& z0p$B!c3_-UU2SsZzofUE@gec0|1iIH0P_HmoH68jAxZNJiBUHQV*)xYSdb5&K&9dq zv7Pg?d#I*j@C~+8Wj!ShI`C@j?Y?6Iq1OZYhCs06 zl@}N2QJ)z@jyEBckJR%hBA4_*CEv=RUi&YVt(FDN!Rh~A!!HE9Uyt7!bbrgCiK-Q+ z>ec-fhQ5h-2sp?l=q7oUxJ~vKL)2^D{K54KXJVho-}@5cylc$ZPY?w?Dr^l~z)Mvp z+*O``>~ZpXn;)TjL&QE=N_^+y)$=yLz76mSMneBIXfP-|bhYKXOW9_XTBy{BcTk{U zk(+i-io<$&ZAH0GgTLO>R^pRlxI?7Vcr% z*)kbQ9-qL_?S2y2Ma-kpVVAu(bm0zE>~4;g@mp#7=EKs4Rf4Bo2igHe01 z?XPl}Sd+KS5sA%^^RvBg8MfXt@xcoN?7s!=fBZQm6{2gUM7b@Pr!X_iZ)DR|L5~?> z2r?fEBjF*B8WJ268jct+ACi*{puapck%n?czJY@rzxCg=no3euCm2k<_Nh9?PCmc7 zI-2S^XUtPo@0Y76S=i9}*WL)q??ArH8P&3a0^|buY`DgbGZHxc=Td63A#}?bo9`z; zdl@D^-`A{sWsc+t+6(EKSu&*NcQI z=$#ShK`X__0r?hD3`LnHKEmKu;VX7um!+gfuokNo7@KPT$%gFD>5*ZobU%*ZUF#vr z!(%_2B)a27<78_QsSvy?+%?Xo;ZwO zg)?M-XU>3pRh?R?&YGP;3Ocd{HU#Wijf{Lq$F%=%Fp#L@B0T5m7_tIAw~=kg_u(FQ zTH$QvbMn#BiFaT)fw=zPzC%+oGj&qkVAHwxi^?jpR*RAa3}Cs zntHn{3LE>R?LZIqq8^fuHd$rAt+8NraBpkt%NNJ?^B>ODZ=px?Q;zvM0j~_#DH08H zK(RF1VXo!PpX{-%a_TW73<5JK)elB=chI>Gpoie<1bP2L#4@7WcE}hHv6t@t@3Pl_ zWAZhfOvm23MSnr}2E4NxG6rQ&sG=SHPH%o33O$^=)xju{-);GgF(`gMTcQ{Cp!X%? z4l;f?&hP~Ii=A>7W{TWO^vvr!ayqF!?S8*IE#;vFyi5E~*CW_`$*qTV=Mv9;8u!1% zlCvj&W7uTl6hyzQbi;WIdS(0I{RU*@CvM2JzXWAq5BWG?8D*{YYM*#+#_TiQ>KFho z-FSltl_>VAzN#mm|CqmSOYs3_A>ifLAy22BYLPmeO*hcnL*Ikc*PwX~&e_qTpZ-65 z^z(cuhl&i?n}ZH|=jl5pMgZ@YIVBZMb$TokS&(d7&$X&ek+rco7TaXnke8w*oY7${6$NIQkNqJ_)3hK5Kqf~ zwZ*0bl31H)Fz68-dPCNGS~8!HsbGUy^y9Fx?NBNWomA@hQ1-au>AN<+0PQ6}c52F| zH`W|w*e@|?C}`~?sndyfGD^lME~(SwR8e>>TL75@X%9S{>|PZx|2I*9548 z7=QeUo2;}XZc!NE0z74_`()*-WTG_mX>!irV(pTHSS@MEQd*lQec0|0E_4!O(jJvOpWkotJ;sGhzQY=G#GZ-L(W#jp_rP(8?w zGXoeG@tY8DgJcNV_p~Dzh3npWt9Aa$9(J;&d6G_5J9|(SuOrW5a|!fdPISj-E)#0D`Q_pf-F+IqS87H-#0#k?B_tU!BXPE)jr z?z&f-=A+g^pvQ9Azj;d5Rjh<>?JAP#9E7sj{{THCnRs}>d&Oc3KhOMo0o9yImoqW{ zYG5$sm35iEFI=G~*H ztC|5XS5Zg)9jlx}TZkgx9}&Ea5gohx=}=J%dg-bN&U zn=W16QR)vmI0OpVo!hAFgC677Oeo-uu1|*7G@chUN6?9*J7?Ofl5p>`FOV1d?<@rX zUK?JEr(6LYod0y})6Tvs1A5mtvz)!qh&J;31Dn?kV-|;?*8*n)ng40Dk#W#d4b+>^ zXhB)cBIpcO3c=Wac)lwCd<8T?tS##aP#rlh1*C<1yoU!6 zLV}t*`?rQf7Q33Q*W$<25UFQrlW#$f9m9zd@ZL>B6&cm4XNVt|WG}Jm7LGsZKB>J+ zB6fw_fUE~xm7F=yFARv;p_8N3mIUUUjZRv(>spGzmMfA@A`MpzLD@pC2a#a}A?H(R z-wWN0c_Ot&lQ}ufS7bj84RTq=RyY&BL~eWo@+szw$lTin;dJ4BW*z*)K~Wq#y^luiXnT_#^X z1Nlx}kSS?7=3cDIu2KJJjyi#tEmg%y?H@2HxUH%=hFe&~20hx&X-NGb4K+{RQAy(6 zyLpTQPPw-`DH!R<>!^NF&t?IT`+IOTWN!$mT@dL<@N&`9%nq6GkKZG>iN9ghI_L`OP>;y-s-DOz6rugl8Ilsu!k|=C2Yu{^z|_>34z$!G;HvZfRCzpa<7t2Wjs- z(k)axli8A*n{sfT+lMey^2wBWY7~^*8faLc|K2B7Oj+*gHB24O;kI=@kg-P@_+E7w z_nG(mD6o^d`V>-vo{{|pq&}YdU70%5>X+lX#mIRSZKI!Kro=@%bKt<6;fZ{}3t#uw z3Gtaa@1R1aEI6#(x5)gnsWDFI5l$q^&-`8GmW>AV=*Pb#1K;nnVFk;l0qu1D7?U=X zmi#%lTvh+4L!sXfW+?}N7y9G!AVDr_*t4pW&^uo*h_*VBsK=n zV~_NK)SC>&${Q@9v9=fHtt`ayFN1wC)%nNG?8-&gV<7b*Oa0eA(Ux27SvCEQHqcgG zpBOgd(%)i-yQ+Cg5ASkBedGi^M)%x&Am6Bq9nlEW{QPx#BFDb%n@(`P+YD!qf@OD)`wQj%_)d%hn&@&g_Y<(O`!Dov#C zZ)F9zBG-=ydF+;G4^DpfY6K&H{T=Fig+Pxg!51(o&MrNF&|Sjg*w6w4^jhH;5qJ&G*jC=ihT(x6huLGqd(y zdk&CChoA_~&r{Ro55>zL8@j(Lzzb*m2n};eP~$5n!G(Dz4L;AEP--G#<_F0tef=MC zg!Tn1I~tN3*K#KN`v1nxkGm7$$wD4;8k-C-UQ#D>yuG+Fi+>L(j4UXx(8K*6DQ-go z^XEQ%B?a>x5FnX5s8tZPWwpf?9>4cwP}|;2vej`;H+}X8p}Q);Q?Xi!G|l2cH?3%YkhA@mo<8ZJ zAeB}X+k$<_C;7hg!QKS&P~ije0B?=cv)oiQ-sAc`32)FM38xxze2XfJBZi;YwoNJAPc+_fmQl74Z`czb)hu=B9x6dsP<~!KO&*L;EF4 zH5NG6^K9AY1>)$7U#WV>!1~2mIE3=$#lIZmpi|ph1naAMUeu3`L(krwo6xOl zJ&dGDcyY~gG9^5;6QICOG+5}pbb>s1wST{X@m`DLQ7212kgL|q{=q`j@J-EiBxLFx z%>VL_5u6VaFVR#ph{hi>);T?eFCxE%xv|L$@AN%A8mR2j#AI;%=l=hE&40lCT!bY5 zex)paMp}@v%BHE{)pJty5Q}5U!?c^&#q$JJ}hGzT39)hW&mCTwqFlya+gG72OE-%*`j|E z{>=uuzks_t{l%K*nJ#TuDCDuiCd>n#GC{iGta`@=9rNz8^Ond-?_2pArsK+7d`2U0 zz>^Aose!FzAS={L>3F@~$(N`dZ&7O!k1Im)lt3v8R z5rY`WgFWAV2jrt9ly`cixr$KHO>QhDx}w@U{NgCGWTdA^qyb!i_7WE+Xc!7WTVvlr z3aJ;2=3F*996GNW?7)0X<#;nvuoMq@a1n{%dX5gkKNXvjwZSR;tG9SGUNl}z5AImr>pQM7kT+>*bzp}H5Ia5x2t553fo*?1iAnlE_DLrVJ}>Q^;%re zKd#}ZJ1p`^X9L1^)bmC`Z8DK3`qewO3|hdGr|?OJ6CjBf2}BnvmRO^z?cB1##ET|> zFH(>xT6iF%mk4<*{>tF~jr->z7asd1w3-1GTXHlsdLR7lrf*tz(_X6{g6q4>1NM?H z_ojIiw4Qfr@a3*v3IEH7xxbK(Vt6}?Tnoz{rE%146LTCGHpJ(qK5l;L!m-Vr4ckZwMy1z0_7QE+~_0c00B|J>ky8;!Z7_smdXN$k*BhLM7uoD974QGqif|IX)iFfMxRny(iKg*;I#<5YYdVjb`j;{RUL!LDUpRUE!Wr$+rf z3VF?ijbOj$S>1s7uATPOtUFY3A9FU{(@BS!3^a_1AX60;N#i0tU{xA#a+{#xV|6#BM(uM;qssVdq+Re!1c*Y#pg-} zFjJz>zCPbDHg`(Or$wM|;6l^kHFE>|0n40zDs7rQ#`arZJ@M1RSLPBUMk^*X{`*6o zL+>NnTRSGEp?ow$A>e+|rq}QmtSEVW8u$%-f#ZkdsJI%i zQ>@F=wC2)mC$~X93+UoAexMPvqr_23oaHtiR8DNXxyu6k zp|>@XtC_Cjl>F&fTlQ6EGLXTxq*B~~JVKX!@cVICw%b2S_ldqO z1YJ5)VC%UqXO|+vl~WUDIk+7iW)~fg?qu@$yM2 zAKhO3evb9?yW}+dl9GsdEM9x`^5Zt-RkXo91Fk;~UiY06|IL}-IfH@Qn7-a_?`;lG z$!XmuTj$$=<3}}N+;mhwX>D`2F1|q*aPVjyJ$isZarhxaH_vI$tBq|B@=%I?fb+|? zRkbGugg7F#$kS})qUY$0>IVO$?6+sjp;UZNGA?`2p^^~BSk*Q$L+ zgE1kGFQA9-$xY|yx(9eLSIICYtJk_xF6OGtqGw8)ziE=zlHP|IJXVkY>iB$GaRhk; z4&m6q@w=&FTSeU5i+vx9m*d?oa#Ycokk1nAXQa3+ z(k$l0>Mdb9ssw$sDYj}wLiaw0NGtdxb0z5Fb! zT0OrpNvv~+&;R!_v-!aK>Y%7xJHi-siqb?UbypH;cZ`U(oOdT8^tWQC7I1#&^CSHx zsSTdqbzAri<)zo5#Ra3^xewSjecZ$_P_ukZ0SD!SWwQd$FKhAxDw+S=u2Cc$mvFC= zG8dZAd6WvTq#M=GzX5NDb(QPCL1M-;VY{C1>3QSzVoZV+u zoo-8ms0>@y>;2p@dWu+CIH5K0ea;sFu=st-ny19_Q$e-bx0a zhPmfqLmms0WejjV<5|h)uV&9(9L<-ZM_j_r6Yq_`q28dRzG?9W`-9u&J@upA%}Uh+ z$ksJ25kVH&>m*DL?qg`#ZNbHvuap$=A&=OOJ&E#!Ia_r9Kzcizz-KsI1avXoA?w=G04x7tN>kzDv&0+@gR4^62m=E`fY; z)J% z)IUCwd&Zb@MYSK3*L+_G@}bCHkU+7)N^p zdCY~9(tsDoX~<8&WK|dRPCqNT@HYZHJBMz$G3)>fPrm2LFFR{ZGCv`c5t2{}EOuJktRemWZTJNJlFB){ z>n`YTg$d*#X-IqkJeGEJwP*UjQ8d-@X`OTboR@RbYGw{s;GAEQtO4G4c=@Qic+K9} z;%jF-o$Uk;QCk1EBUw=n{7R_nY*hQFmXJrYrv<*h#lIAYt~{ES!AYRe3MfiW49(%&eS-?9>>!b^?EgInFp1XMt zE6La_ieLQKEo%B*MFTirD366%MzNt(`+R6Nd{aL+^g21)P^2oo+Tky|qaDMmZkRC0 zqu8#?2E0&7yy{H@^%DNIZy&S-7CSyE_Ph&hX1P217yK{Z&Rh; z`p%_m5LZQ;$vvBJCm)*vc6|ioVLGUT`=9$TD=3muOzyqie57?xXM7(fa>Y6ZWxGOW zLz@2k?_kv5?N7V+v3w>zZ70pH5-N*^-N8*Wa`LxbbtSX;5a`tr3wg9s-<5!TD<_F? zBj-sy<<-B7n!*Dld4zxcHU3y7m+AgR7w{NflZSmUu?tVGZ7F@f6e1GzqgOAUKntT> zoh+J8kZ3e80rE2Aq_F@`)(C$gIsEb1<@o!5kA|)HJwo328nXoN1kBI}0Pif0xmyC2 zdxEz8!=KN@BS;+_A+o98HLzq6CCS|M;pZ|EAulq{4eXy!Zac(D`?%+N8|JUC(IDi= z7ow%S+?I-XSBkd`c)QZ&+@_Si-$UR|PAh+JP**0Z^I8cPf8~OQul;&Y7h#?bc{Fy% zj6gopM7vs|Lpbg~0U;L`nbt`U`x%I&3^X;%+Rfne9A4lyS8A!|)%0Ac(CQ=SHupuN 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

s@*@Y>AVie_joPzOxh-# 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 z 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 hakIyzqg#ezh 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 None: self.stack = stack diff --git a/torba/server/coins.py b/torba/server/coins.py index af1829842..c83b7522a 100644 --- a/torba/server/coins.py +++ b/torba/server/coins.py @@ -45,6 +45,7 @@ from torba.server.hash import HASHX_LEN, hex_str_to_hash from torba.server.script import ScriptPubKey, OpCodes import torba.server.tx as lib_tx import torba.server.block_processor as block_proc +from torba.server.db import DB import torba.server.daemon as daemon from torba.server.session import ElectrumX, DashElectrumX @@ -71,6 +72,7 @@ class Coin(object): DESERIALIZER = lib_tx.Deserializer DAEMON = daemon.Daemon BLOCK_PROCESSOR = block_proc.BlockProcessor + DB = DB HEADER_VALUES = [ 'version', 'prev_block_hash', 'merkle_root', 'timestamp', 'bits', 'nonce' ] diff --git a/torba/server/env.py b/torba/server/env.py index 83b1125a5..28dd266e2 100644 --- a/torba/server/env.py +++ b/torba/server/env.py @@ -5,33 +5,35 @@ # See the file "LICENCE" for information about the copyright # and warranty status of this software. -'''Class for handling environment configuration and defaults.''' - import re import resource +from os import environ from collections import namedtuple from ipaddress import ip_address +from torba.server.util import class_logger from torba.server.coins import Coin -from torba.server.env_base import EnvBase import torba.server.util as lib_util NetIdentity = namedtuple('NetIdentity', 'host tcp_port ssl_port nick_suffix') -class Env(EnvBase): - '''Wraps environment configuration. Optionally, accepts a Coin class - as first argument to have ElectrumX serve custom coins not part of - the standard distribution. - ''' +class Env: # Peer discovery PD_OFF, PD_SELF, PD_ON = range(3) + class Error(Exception): + pass + def __init__(self, coin=None): - super().__init__() + self.logger = class_logger(__name__, self.__class__.__name__) + self.allow_root = self.boolean('ALLOW_ROOT', False) + self.host = self.default('HOST', 'localhost') + self.rpc_host = self.default('RPC_HOST', 'localhost') + self.loop_policy = self.event_loop_policy() self.obsolete(['UTXO_MB', 'HIST_MB', 'NETWORK']) self.db_dir = self.required('DB_DIRECTORY') self.db_engine = self.default('DB_ENGINE', 'leveldb') @@ -55,8 +57,7 @@ class Env(EnvBase): self.rpc_port = self.integer('RPC_PORT', 8000) self.max_subscriptions = self.integer('MAX_SUBSCRIPTIONS', 10000) self.banner_file = self.default('BANNER_FILE', None) - self.tor_banner_file = self.default('TOR_BANNER_FILE', - self.banner_file) + self.tor_banner_file = self.default('TOR_BANNER_FILE', self.banner_file) self.anon_logs = self.boolean('ANON_LOGS', False) self.log_sessions = self.integer('LOG_SESSIONS', 3600) # Peer discovery @@ -83,6 +84,78 @@ class Env(EnvBase): for identity in (clearnet_identity, tor_identity) if identity is not None] + @classmethod + def default(cls, envvar, default): + return environ.get(envvar, default) + + @classmethod + def boolean(cls, envvar, default): + default = 'Yes' if default else '' + return bool(cls.default(envvar, default).strip()) + + @classmethod + def required(cls, envvar): + value = environ.get(envvar) + if value is None: + raise cls.Error('required envvar {} not set'.format(envvar)) + return value + + @classmethod + def integer(cls, envvar, default): + value = environ.get(envvar) + if value is None: + return default + try: + return int(value) + except Exception: + raise cls.Error('cannot convert envvar {} value {} to an integer' + .format(envvar, value)) + + @classmethod + def custom(cls, envvar, default, parse): + value = environ.get(envvar) + if value is None: + return default + try: + return parse(value) + except Exception as e: + raise cls.Error('cannot parse envvar {} value {}' + .format(envvar, value)) from e + + @classmethod + def obsolete(cls, envvars): + bad = [envvar for envvar in envvars if environ.get(envvar)] + if bad: + raise cls.Error('remove obsolete environment variables {}' + .format(bad)) + + def event_loop_policy(self): + policy = self.default('EVENT_LOOP_POLICY', None) + if policy is None: + return None + if policy == 'uvloop': + import uvloop + return uvloop.EventLoopPolicy() + raise self.Error('unknown event loop policy "{}"'.format(policy)) + + def cs_host(self, *, for_rpc): + '''Returns the 'host' argument to pass to asyncio's create_server + call. The result can be a single host name string, a list of + host name strings, or an empty string to bind to all interfaces. + + If rpc is True the host to use for the RPC server is returned. + Otherwise the host to use for SSL/TCP servers is returned. + ''' + host = self.rpc_host if for_rpc else self.host + result = [part.strip() for part in host.split(',')] + if len(result) == 1: + result = result[0] + # An empty result indicates all interfaces, which we do not + # permitted for an RPC server. + if for_rpc and not result: + result = 'localhost' + return result + def sane_max_sessions(self): '''Return the maximum number of sessions to permit. Normally this is MAX_SESSIONS. However, to prevent open file exhaustion, ajdust diff --git a/torba/server/env_base.py b/torba/server/env_base.py deleted file mode 100644 index 8366e815c..000000000 --- a/torba/server/env_base.py +++ /dev/null @@ -1,99 +0,0 @@ -# Copyright (c) 2017, Neil Booth -# -# All rights reserved. -# -# See the file "LICENCE" for information about the copyright -# and warranty status of this software. - -'''Class for server environment configuration and defaults.''' - - -from os import environ - -from torba.server.util import class_logger - - -class EnvBase(object): - '''Wraps environment configuration.''' - - class Error(Exception): - pass - - def __init__(self): - self.logger = class_logger(__name__, self.__class__.__name__) - self.allow_root = self.boolean('ALLOW_ROOT', False) - self.host = self.default('HOST', 'localhost') - self.rpc_host = self.default('RPC_HOST', 'localhost') - self.loop_policy = self.event_loop_policy() - - @classmethod - def default(cls, envvar, default): - return environ.get(envvar, default) - - @classmethod - def boolean(cls, envvar, default): - default = 'Yes' if default else '' - return bool(cls.default(envvar, default).strip()) - - @classmethod - def required(cls, envvar): - value = environ.get(envvar) - if value is None: - raise cls.Error('required envvar {} not set'.format(envvar)) - return value - - @classmethod - def integer(cls, envvar, default): - value = environ.get(envvar) - if value is None: - return default - try: - return int(value) - except Exception: - raise cls.Error('cannot convert envvar {} value {} to an integer' - .format(envvar, value)) - - @classmethod - def custom(cls, envvar, default, parse): - value = environ.get(envvar) - if value is None: - return default - try: - return parse(value) - except Exception as e: - raise cls.Error('cannot parse envvar {} value {}' - .format(envvar, value)) from e - - @classmethod - def obsolete(cls, envvars): - bad = [envvar for envvar in envvars if environ.get(envvar)] - if bad: - raise cls.Error('remove obsolete environment variables {}' - .format(bad)) - - def event_loop_policy(self): - policy = self.default('EVENT_LOOP_POLICY', None) - if policy is None: - return None - if policy == 'uvloop': - import uvloop - return uvloop.EventLoopPolicy() - raise self.Error('unknown event loop policy "{}"'.format(policy)) - - def cs_host(self, *, for_rpc): - '''Returns the 'host' argument to pass to asyncio's create_server - call. The result can be a single host name string, a list of - host name strings, or an empty string to bind to all interfaces. - - If rpc is True the host to use for the RPC server is returned. - Otherwise the host to use for SSL/TCP servers is returned. - ''' - host = self.rpc_host if for_rpc else self.host - result = [part.strip() for part in host.split(',')] - if len(result) == 1: - result = result[0] - # An empty result indicates all interfaces, which we do not - # permitted for an RPC server. - if for_rpc and not result: - result = 'localhost' - return result diff --git a/torba/server/server.py b/torba/server/server.py index 5b22e6b7e..dee96f634 100644 --- a/torba/server/server.py +++ b/torba/server/server.py @@ -1,11 +1,8 @@ import signal -import time import logging -from functools import partial import asyncio import torba -from torba.server.db import DB from torba.server.mempool import MemPool, MemPoolAPI from torba.server.session import SessionManager @@ -73,21 +70,10 @@ class Server: self.shutdown_event = asyncio.Event() self.cancellable_tasks = [] - async def start(self): - env = self.env - min_str, max_str = env.coin.SESSIONCLS.protocol_min_max_strings() - self.log.info(f'software version: {torba.__version__}') - self.log.info(f'supported protocol versions: {min_str}-{max_str}') - self.log.info(f'event loop policy: {env.loop_policy}') - self.log.info(f'reorg limit is {env.reorg_limit:,d} blocks') - - notifications = Notifications() - Daemon = env.coin.DAEMON - BlockProcessor = env.coin.BLOCK_PROCESSOR - - daemon = Daemon(env.coin, env.daemon_url) - db = DB(env) - bp = BlockProcessor(env, db, daemon, notifications) + self.notifications = notifications = Notifications() + self.daemon = daemon = env.coin.DAEMON(env.coin, env.daemon_url) + self.db = db = env.coin.DB(env) + self.bp = bp = env.coin.BLOCK_PROCESSOR(env, db, daemon, notifications) # Set notifications up to implement the MemPoolAPI notifications.height = daemon.height @@ -96,23 +82,31 @@ class Server: notifications.raw_transactions = daemon.getrawtransactions notifications.lookup_utxos = db.lookup_utxos MemPoolAPI.register(Notifications) - mempool = MemPool(env.coin, notifications) + self.mempool = mempool = MemPool(env.coin, notifications) - session_mgr = SessionManager( + self.session_mgr = SessionManager( env, db, bp, daemon, mempool, self.shutdown_event ) - await daemon.height() + async def start(self): + env = self.env + min_str, max_str = env.coin.SESSIONCLS.protocol_min_max_strings() + self.log.info(f'software version: {torba.__version__}') + self.log.info(f'supported protocol versions: {min_str}-{max_str}') + self.log.info(f'event loop policy: {env.loop_policy}') + self.log.info(f'reorg limit is {env.reorg_limit:,d} blocks') + + await self.daemon.height() def _start_cancellable(run, *args): _flag = asyncio.Event() self.cancellable_tasks.append(asyncio.ensure_future(run(*args, _flag))) return _flag.wait() - await _start_cancellable(bp.fetch_and_process_blocks) - await db.populate_header_merkle_cache() - await _start_cancellable(mempool.keep_synchronized) - await _start_cancellable(session_mgr.serve, notifications) + await _start_cancellable(self.bp.fetch_and_process_blocks) + await self.db.populate_header_merkle_cache() + await _start_cancellable(self.mempool.keep_synchronized) + await _start_cancellable(self.session_mgr.serve, self.notifications) def stop(self): for task in reversed(self.cancellable_tasks): diff --git a/torba/testing/testcase.py b/torba/testcase.py similarity index 92% rename from torba/testing/testcase.py rename to torba/testcase.py index 277cdf47a..988ab1eaf 100644 --- a/torba/testing/testcase.py +++ b/torba/testcase.py @@ -1,7 +1,8 @@ +import sys import logging import unittest from unittest.case import _Outcome -from .node import Conductor +from torba.orchstr8 import Conductor try: @@ -14,6 +15,12 @@ except ImportError: def _cancel_all_tasks(loop): pass +HANDLER = logging.StreamHandler(sys.stdout) +HANDLER.setFormatter( + logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') +) +logging.getLogger().addHandler(HANDLER) + class AsyncioTestCase(unittest.TestCase): # Implementation inspired by discussion: @@ -119,12 +126,13 @@ class IntegrationTestCase(AsyncioTestCase): LEDGER = None MANAGER = None - VERBOSITY = logging.WARNING + VERBOSITY = logging.WARN def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.conductor = None self.blockchain = None + self.wallet_node = None self.manager = None self.ledger = None self.wallet = None @@ -136,10 +144,11 @@ class IntegrationTestCase(AsyncioTestCase): ) await self.conductor.start() self.blockchain = self.conductor.blockchain_node - self.manager = self.conductor.wallet_node.manager - self.ledger = self.conductor.wallet_node.ledger - self.wallet = self.conductor.wallet_node.wallet - self.account = self.conductor.wallet_node.wallet.default_account + self.wallet_node = self.conductor.wallet_node + self.manager = self.wallet_node.manager + self.ledger = self.wallet_node.ledger + self.wallet = self.wallet_node.wallet + self.account = self.wallet_node.wallet.default_account async def asyncTearDown(self): await self.conductor.stop() diff --git a/torba/testing/__init__.py b/torba/testing/__init__.py deleted file mode 100644 index 7f73aff48..000000000 --- a/torba/testing/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from .testcase import IntegrationTestCase, AsyncioTestCase diff --git a/torba/ui/__init__.py b/torba/ui/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tox.ini b/tox.ini index 733138e04..4f74e730f 100644 --- a/tox.ini +++ b/tox.ini @@ -14,9 +14,9 @@ changedir = {toxinidir}/tests setenv = integration: TORBA_LEDGER={envname} commands = - unit: coverage run -p --source={envsitepackagesdir}/torba -m unittest discover -t . unit + unit: coverage run -p --source={envsitepackagesdir}/torba -m unittest discover -t . client_tests.unit integration: torba download - integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest integration.test_transactions - integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest integration.test_reconnect + integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest client_tests.integration.test_transactions + integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest client_tests.integration.test_reconnect # Too slow on Travis # integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_blockchain_reorganization From 37468cad595b1d18e8ef6dd3e16560c4bfeb92f2 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 4 Nov 2018 01:01:03 -0500 Subject: [PATCH 222/383] fix pylint --- torba/client/cli.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torba/client/cli.py b/torba/client/cli.py index 7304a0929..917dffc5f 100644 --- a/torba/client/cli.py +++ b/torba/client/cli.py @@ -4,7 +4,7 @@ import asyncio import aiohttp from torba.orchstr8.node import Conductor, get_ledger_from_environment, get_blockchain_node_from_ledger -from torba.orchstr8.service import TestingServiceAPI +from torba.orchstr8.service import ConductorService def get_argument_parser(): @@ -67,7 +67,7 @@ def main(): if getattr(args, 'wallet', False): loop.run_until_complete(conductor.start_wallet()) - service = TestingServiceAPI(conductor, loop) + service = ConductorService(conductor, loop) loop.run_until_complete(service.start()) try: From c497385bc758ece38b2107b0d82150c34f38e379 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 4 Nov 2018 01:04:14 -0500 Subject: [PATCH 223/383] setup.py fixes --- setup.py | 8 ++++---- torba/__init__.py | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/setup.py b/setup.py index 5e3565417..10567a3b1 100644 --- a/setup.py +++ b/setup.py @@ -18,7 +18,7 @@ setup( long_description=long_description, long_description_content_type="text/markdown", keywords='wallet,crypto,currency,money,bitcoin,electrum,electrumx', - classifiers=( + classifiers=[ 'Framework :: AsyncIO', 'Intended Audience :: Developers', 'Intended Audience :: System Administrators', @@ -31,7 +31,7 @@ setup( 'Topic :: System :: Benchmark', 'Topic :: System :: Distributed Computing', 'Topic :: Utilities', - ), + ], packages=find_packages(exclude=('tests',)), python_requires='>=3.6', install_requires=( @@ -62,8 +62,8 @@ setup( 'orchstr8=torba.orchstr8.cli:main [server]', ], 'gui_scripts': [ - 'torba=torba.ui:main [ui]' - 'torba-workbench=torba.workbench:main [ui]' + 'torba=torba.ui:main [ui]', + 'torba-workbench=torba.workbench:main [ui]', ] } ) diff --git a/torba/__init__.py b/torba/__init__.py index 6768085ce..d26400441 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.1.6' +__version__ = '0.2.0' From c91c69540b4f93ac4c0ae79403db330e5a276d6b Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 4 Nov 2018 01:09:16 -0500 Subject: [PATCH 224/383] orchstr8 command for orchestration --- tox.ini | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tox.ini b/tox.ini index 4f74e730f..f6b874966 100644 --- a/tox.ini +++ b/tox.ini @@ -15,7 +15,7 @@ setenv = integration: TORBA_LEDGER={envname} commands = unit: coverage run -p --source={envsitepackagesdir}/torba -m unittest discover -t . client_tests.unit - integration: torba download + integration: orchstr8 download integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest client_tests.integration.test_transactions integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest client_tests.integration.test_reconnect # Too slow on Travis From ae8fece9bb1193c09275e3cd322da5e7aa04cd58 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 4 Nov 2018 01:42:27 -0500 Subject: [PATCH 225/383] python3.6 tests pass again --- .travis.yml | 2 ++ torba/server/db.py | 2 +- torba/server/history.py | 2 +- torba/server/peer.py | 2 +- torba/server/session.py | 5 ++--- torba/server/storage.py | 2 +- torba/server/text.py | 2 +- tox.ini | 2 +- 8 files changed, 10 insertions(+), 9 deletions(-) diff --git a/.travis.yml b/.travis.yml index 65521a142..105b20b43 100644 --- a/.travis.yml +++ b/.travis.yml @@ -23,6 +23,8 @@ jobs: install: - pip install tox-travis script: tox + - <<: *tests + python: "3.6" - <<: *tests env: TESTTYPE=integration diff --git a/torba/server/db.py b/torba/server/db.py index d594cbff0..0d0001abd 100644 --- a/torba/server/db.py +++ b/torba/server/db.py @@ -21,7 +21,7 @@ from struct import pack, unpack import attr from aiorpcx import run_in_thread, sleep -import torba.server.util as util +from torba.server import util from torba.server.hash import hash_to_hex_str, HASHX_LEN from torba.server.merkle import Merkle, MerkleCache from torba.server.util import formatted_time diff --git a/torba/server/history.py b/torba/server/history.py index 5554c3dd1..00d746baf 100644 --- a/torba/server/history.py +++ b/torba/server/history.py @@ -15,7 +15,7 @@ import time from collections import defaultdict from functools import partial -import torba.server.util as util +from torba.server import util from torba.server.util import pack_be_uint16, unpack_be_uint16_from from torba.server.hash import hash_to_hex_str, HASHX_LEN diff --git a/torba/server/peer.py b/torba/server/peer.py index 7b392acbe..850e6bf75 100644 --- a/torba/server/peer.py +++ b/torba/server/peer.py @@ -27,8 +27,8 @@ from ipaddress import ip_address +from torba.server import util from torba.server.util import cachedproperty -import torba.server.util as util from typing import Dict diff --git a/torba/server/session.py b/torba/server/session.py index 787302075..b8e84881e 100644 --- a/torba/server/session.py +++ b/torba/server/session.py @@ -26,11 +26,10 @@ from aiorpcx import ( ) import torba -import torba.server.text as text -import torba.server.util as util +from torba.server import text +from torba.server import util from torba.server.hash import (sha256, hash_to_hex_str, hex_str_to_hash, HASHX_LEN, Base58Error) -from torba.server.peer import Peer from torba.server.daemon import DaemonError from torba.server.peers import PeerManager diff --git a/torba/server/storage.py b/torba/server/storage.py index 859b26ffd..4cb8edde9 100644 --- a/torba/server/storage.py +++ b/torba/server/storage.py @@ -10,7 +10,7 @@ import os from functools import partial -import torba.server.util as util +from torba.server import util def db_class(name): diff --git a/torba/server/text.py b/torba/server/text.py index 409276f8e..7677353ca 100644 --- a/torba/server/text.py +++ b/torba/server/text.py @@ -1,6 +1,6 @@ import time -import torba.server.util as util +from torba.server import util def sessions_lines(data): diff --git a/tox.ini b/tox.ini index f6b874966..3dad60de0 100644 --- a/tox.ini +++ b/tox.ini @@ -1,6 +1,6 @@ [tox] #envlist = unit,integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} -envlist = py37-unit,py37-integration-torba.coin.bitcoinsegwit +envlist = py{37,36}-unit,py37-integration-torba.coin.bitcoinsegwit [travis:env] TESTTYPE = From 268e5994235752a5c0674e8f79ca0a8239bfcfb7 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 6 Nov 2018 19:16:27 -0500 Subject: [PATCH 226/383] handle creating transactions where input is consumed by fees and there is no output by creating an additional input which will require some change output --- torba/client/basetransaction.py | 47 ++++++++++++++++++++++----------- 1 file changed, 31 insertions(+), 16 deletions(-) diff --git a/torba/client/basetransaction.py b/torba/client/basetransaction.py index 85dda469f..cd46a33ad 100644 --- a/torba/client/basetransaction.py +++ b/torba/client/basetransaction.py @@ -444,27 +444,42 @@ class BaseTransaction: try: - if payment < cost: - deficit = cost - payment - spendables = await ledger.get_spendable_utxos(deficit, funding_accounts) - if not spendables: - raise ValueError('Not enough funds to cover this transaction.') - payment += sum(s.effective_amount for s in spendables) - tx.add_inputs(s.txi for s in spendables) + for _ in range(2): + + if payment < cost: + deficit = cost - payment + spendables = await ledger.get_spendable_utxos(deficit, funding_accounts) + if not spendables: + raise ValueError('Not enough funds to cover this transaction.') + payment += sum(s.effective_amount for s in spendables) + tx.add_inputs(s.txi for s in spendables) - if payment > cost: cost_of_change = ( tx.get_base_fee(ledger) + cls.output_class.pay_pubkey_hash(COIN, NULL_HASH32).get_fee(ledger) ) - change = payment - cost - if change > cost_of_change: - change_address = await change_account.change.get_or_create_usable_address() - change_hash160 = change_account.ledger.address_to_hash160(change_address) - change_amount = change - cost_of_change - change_output = cls.output_class.pay_pubkey_hash(change_amount, change_hash160) - change_output.is_change = True - tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) + if payment > cost: + change = payment - cost + if change > cost_of_change: + change_address = await change_account.change.get_or_create_usable_address() + change_hash160 = change_account.ledger.address_to_hash160(change_address) + change_amount = change - cost_of_change + change_output = cls.output_class.pay_pubkey_hash(change_amount, change_hash160) + change_output.is_change = True + tx.add_outputs([cls.output_class.pay_pubkey_hash(change_amount, change_hash160)]) + + if tx._outputs: + break + else: + # this condition and the outer range(2) loop cover an edge case + # whereby a single input is just enough to cover the fee and + # has some change left over, but the change left over is less + # than the cost_of_change: thus the input is completely + # consumed and no output is added, which is an invalid tx. + # to be able to spend this input we must increase the cost + # of the TX and run through the balance algorithm a second time + # adding an extra input and change output, making tx valid. + cost = cost + cost_of_change + 1 await tx.sign(funding_accounts) From 8fcbf48bdfe3bcdd3b1f80a05e5aca0f804988e7 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 6 Nov 2018 19:27:48 -0500 Subject: [PATCH 227/383] attempt UTXO check 5 times when UTXOs are less than the fee --- torba/client/basetransaction.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/torba/client/basetransaction.py b/torba/client/basetransaction.py index cd46a33ad..e0b63fce9 100644 --- a/torba/client/basetransaction.py +++ b/torba/client/basetransaction.py @@ -444,7 +444,7 @@ class BaseTransaction: try: - for _ in range(2): + for _ in range(5): if payment < cost: deficit = cost - payment @@ -471,7 +471,7 @@ class BaseTransaction: if tx._outputs: break else: - # this condition and the outer range(2) loop cover an edge case + # this condition and the outer range(5) loop cover an edge case # whereby a single input is just enough to cover the fee and # has some change left over, but the change left over is less # than the cost_of_change: thus the input is completely @@ -479,7 +479,9 @@ class BaseTransaction: # to be able to spend this input we must increase the cost # of the TX and run through the balance algorithm a second time # adding an extra input and change output, making tx valid. - cost = cost + cost_of_change + 1 + # we do this 5 times in case the other UTXOs added are also + # less than the fee, after 5 attempts we give up and go home + cost += cost_of_change + 1 await tx.sign(funding_accounts) From fdf479241a1b4f1f9983b28be344a471f21d3aed Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 7 Nov 2018 14:42:17 -0500 Subject: [PATCH 228/383] added ledger.wait(tx) to support reliably waiting for TX to be in ledger --- .../integration/test_transactions.py | 8 ++--- torba/client/baseledger.py | 19 ++++++++++ torba/testcase.py | 36 +++++++------------ 3 files changed, 36 insertions(+), 27 deletions(-) diff --git a/tests/client_tests/integration/test_transactions.py b/tests/client_tests/integration/test_transactions.py index 30fb12d52..572a2f000 100644 --- a/tests/client_tests/integration/test_transactions.py +++ b/tests/client_tests/integration/test_transactions.py @@ -37,9 +37,9 @@ class BasicTransactionTests(IntegrationTestCase): [account1], account1 ) await self.broadcast(tx) - await self.on_transaction(tx) # mempool + await self.ledger.wait(tx) # mempool await self.blockchain.generate(1) - await self.on_transaction(tx) # confirmed + await self.ledger.wait(tx) # confirmed self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 3.5) self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) @@ -51,9 +51,9 @@ class BasicTransactionTests(IntegrationTestCase): [account1], account1 ) await self.broadcast(tx) - await self.on_transaction(tx) # mempool + await self.ledger.wait(tx) # mempool await self.blockchain.generate(1) - await self.on_transaction(tx) # confirmed + await self.ledger.wait(tx) # confirmed txs = await account1.get_transactions() tx = txs[1] diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index 79c458b33..11a603802 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -1,6 +1,7 @@ import os import asyncio import logging +from functools import partial from binascii import hexlify, unhexlify from io import StringIO @@ -384,3 +385,21 @@ class BaseLedger(metaclass=LedgerRegistry): def broadcast(self, tx): return self.network.broadcast(hexlify(tx.raw).decode()) + + async def wait(self, tx: basetransaction.BaseTransaction, height=0): + addresses = set() + for txi in tx.inputs: + if txi.txo_ref.txo is not None: + addresses.add( + self.hash160_to_address(txi.txo_ref.txo.script.values['pubkey_hash']) + ) + for txo in tx.outputs: + addresses.add( + self.hash160_to_address(txo.script.values['pubkey_hash']) + ) + records = await self.db.get_addresses(cols=('address',), address__in=addresses) + await asyncio.wait([ + self.on_transaction.where(partial( + lambda a, e: a == e.address and e.tx.height >= height, address_record['address'] + )) for address_record in records + ]) diff --git a/torba/testcase.py b/torba/testcase.py index 988ab1eaf..2c8cc84d1 100644 --- a/torba/testcase.py +++ b/torba/testcase.py @@ -3,6 +3,12 @@ import logging import unittest from unittest.case import _Outcome from torba.orchstr8 import Conductor +from torba.orchstr8.node import BlockchainNode, WalletNode +from torba.client.baseledger import BaseLedger +from torba.client.baseaccount import BaseAccount +from torba.client.basemanager import BaseWalletManager +from torba.client.wallet import Wallet +from typing import Optional try: @@ -130,13 +136,13 @@ class IntegrationTestCase(AsyncioTestCase): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) - self.conductor = None - self.blockchain = None - self.wallet_node = None - self.manager = None - self.ledger = None - self.wallet = None - self.account = None + self.conductor: Optional[Conductor] = None + self.blockchain: Optional[BlockchainNode] = None + self.wallet_node: Optional[WalletNode] = None + self.manager: Optional[BaseWalletManager] = None + self.ledger: Optional[BaseLedger] = None + self.wallet: Optional[Wallet] = None + self.account: Optional[BaseAccount] = None async def asyncSetUp(self): self.conductor = Conductor( @@ -178,19 +184,3 @@ class IntegrationTestCase(AsyncioTestCase): return self.ledger.on_transaction.where( lambda e: e.tx.id == tx.id and e.address == address ) - - async def on_transaction(self, tx): - addresses = await self.get_tx_addresses(tx, self.ledger) - await asyncio.wait([ - self.ledger.on_transaction.where(lambda e: e.address == address) # pylint: disable=W0640 - for address in addresses - ]) - - async def get_tx_addresses(self, tx, ledger): - addresses = set() - for txo in tx.outputs: - address = ledger.hash160_to_address(txo.script.values['pubkey_hash']) - record = await ledger.db.get_address(address=address) - if record is not None: - addresses.add(address) - return list(addresses) From 78b84ba698ff6c7f1302dfb0ae062a7ebde917f4 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 7 Nov 2018 15:07:36 -0500 Subject: [PATCH 229/383] moved import to make pylint happy --- torba/testcase.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/testcase.py b/torba/testcase.py index 2c8cc84d1..22e343891 100644 --- a/torba/testcase.py +++ b/torba/testcase.py @@ -1,6 +1,7 @@ import sys import logging import unittest +from typing import Optional from unittest.case import _Outcome from torba.orchstr8 import Conductor from torba.orchstr8.node import BlockchainNode, WalletNode @@ -8,7 +9,6 @@ from torba.client.baseledger import BaseLedger from torba.client.baseaccount import BaseAccount from torba.client.basemanager import BaseWalletManager from torba.client.wallet import Wallet -from typing import Optional try: From b8a3b62f0f057348498f56c86ccf2505d931570f Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 7 Nov 2018 15:10:27 -0500 Subject: [PATCH 230/383] moved import to make pylint happy, take 2 --- torba/testcase.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/testcase.py b/torba/testcase.py index 22e343891..d8f1f9ef0 100644 --- a/torba/testcase.py +++ b/torba/testcase.py @@ -1,8 +1,8 @@ import sys import logging import unittest -from typing import Optional from unittest.case import _Outcome +from typing import Optional from torba.orchstr8 import Conductor from torba.orchstr8.node import BlockchainNode, WalletNode from torba.client.baseledger import BaseLedger From fb6a7442a65af68f54203e4002cf582e59bad640 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 7 Nov 2018 16:54:27 -0300 Subject: [PATCH 231/383] fix wallet server shutdown for tests --- torba/orchstr8/node.py | 2 +- torba/server/db.py | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index 683ba58e8..7ebd2f879 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -175,7 +175,7 @@ class SPVNode: async def stop(self, cleanup=True): try: - await self.controller.shutdown() + self.server.db.shutdown() finally: cleanup and self.cleanup() diff --git a/torba/server/db.py b/torba/server/db.py index 0d0001abd..a72093610 100644 --- a/torba/server/db.py +++ b/torba/server/db.py @@ -133,6 +133,10 @@ class DB(object): # Read TX counts (requires meta directory) await self._read_tx_counts() + def shutdown(self): + self.utxo_db.close() + self.history.close_db() + async def open_for_compacting(self): await self._open_dbs(True, True) From 700f73e8e99d38670223fb0d833f04f7a61314a1 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 7 Nov 2018 16:54:38 -0300 Subject: [PATCH 232/383] make tox run it all together --- tox.ini | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tox.ini b/tox.ini index 3dad60de0..4b48d4eef 100644 --- a/tox.ini +++ b/tox.ini @@ -16,7 +16,6 @@ setenv = commands = unit: coverage run -p --source={envsitepackagesdir}/torba -m unittest discover -t . client_tests.unit integration: orchstr8 download - integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest client_tests.integration.test_transactions - integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest client_tests.integration.test_reconnect + integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest discover -t . client_tests.integration # Too slow on Travis # integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_blockchain_reorganization From ee57af8e994f4282a492b60ab810807776815878 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 7 Nov 2018 17:20:00 -0300 Subject: [PATCH 233/383] restore skips for Travis --- .../client_tests/integration/test_blockchain_reorganization.py | 2 ++ tox.ini | 2 -- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/client_tests/integration/test_blockchain_reorganization.py b/tests/client_tests/integration/test_blockchain_reorganization.py index 0dce99368..f2bbb7930 100644 --- a/tests/client_tests/integration/test_blockchain_reorganization.py +++ b/tests/client_tests/integration/test_blockchain_reorganization.py @@ -1,4 +1,5 @@ import logging +from unittest import skip from torba.testcase import IntegrationTestCase @@ -6,6 +7,7 @@ class BlockchainReorganizationTests(IntegrationTestCase): VERBOSITY = logging.WARN + @skip("too slow on Travis CI") async def test_reorg(self): self.assertEqual(self.ledger.headers.height, 200) diff --git a/tox.ini b/tox.ini index 4b48d4eef..853b9a3d7 100644 --- a/tox.ini +++ b/tox.ini @@ -17,5 +17,3 @@ commands = unit: coverage run -p --source={envsitepackagesdir}/torba -m unittest discover -t . client_tests.unit integration: orchstr8 download integration: coverage run -p --source={envsitepackagesdir}/torba -m unittest discover -t . client_tests.integration - # Too slow on Travis - # integration: coverage run -p --source={envsitepackagesdir}/torba -m twisted.trial --reactor=asyncio integration.test_blockchain_reorganization From e745b6c16e7b33f28b69ebf869c80ffa6b605984 Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Mon, 19 Nov 2018 13:51:25 -0500 Subject: [PATCH 234/383] fix wallet encryption fixes https://github.com/lbryio/lbry/issues/1623 --- tests/client_tests/unit/test_account.py | 17 +++++++++++------ tests/client_tests/unit/test_hash.py | 6 +++++- torba/client/baseaccount.py | 23 +++++++++++++++-------- torba/client/hash.py | 5 +++-- 4 files changed, 34 insertions(+), 17 deletions(-) diff --git a/tests/client_tests/unit/test_account.py b/tests/client_tests/unit/test_account.py index 29d9690b8..8c50cea1c 100644 --- a/tests/client_tests/unit/test_account.py +++ b/tests/client_tests/unit/test_account.py @@ -369,7 +369,8 @@ class AccountEncryptionTests(AsyncioTestCase): def test_encrypt_wallet(self): account = self.ledger.account_class.from_dict(self.ledger, Wallet(), self.unencrypted_account) - account.encryption_init_vector = self.init_vector + account.private_key_encryption_init_vector = self.init_vector + account.seed_encryption_init_vector = self.init_vector self.assertFalse(account.serialize_encrypted) self.assertFalse(account.encrypted) @@ -386,6 +387,8 @@ class AccountEncryptionTests(AsyncioTestCase): account.serialize_encrypted = True account.decrypt(self.password) + self.assertEqual(account.private_key_encryption_init_vector, self.init_vector) + self.assertEqual(account.seed_encryption_init_vector, self.init_vector) self.assertEqual(account.seed, self.unencrypted_account['seed']) self.assertEqual(account.private_key.extended_key_string(), self.unencrypted_account['private_key']) @@ -393,20 +396,22 @@ class AccountEncryptionTests(AsyncioTestCase): self.assertEqual(account.to_dict()['seed'], self.encrypted_account['seed']) self.assertEqual(account.to_dict()['private_key'], self.encrypted_account['private_key']) - account.encryption_init_vector = None - self.assertNotEqual(account.to_dict()['seed'], self.encrypted_account['seed']) - self.assertNotEqual(account.to_dict()['private_key'], self.encrypted_account['private_key']) - self.assertFalse(account.encrypted) self.assertTrue(account.serialize_encrypted) + account.serialize_encrypted = False + self.assertEqual(account.to_dict()['seed'], self.unencrypted_account['seed']) + self.assertEqual(account.to_dict()['private_key'], self.unencrypted_account['private_key']) + def test_decrypt_wallet(self): account = self.ledger.account_class.from_dict(self.ledger, Wallet(), self.encrypted_account) - account.encryption_init_vector = self.init_vector self.assertTrue(account.encrypted) self.assertTrue(account.serialize_encrypted) account.decrypt(self.password) + self.assertEqual(account.private_key_encryption_init_vector, self.init_vector) + self.assertEqual(account.seed_encryption_init_vector, self.init_vector) + self.assertFalse(account.encrypted) self.assertTrue(account.serialize_encrypted) diff --git a/tests/client_tests/unit/test_hash.py b/tests/client_tests/unit/test_hash.py index 7c2fba63e..4b3a8de5c 100644 --- a/tests/client_tests/unit/test_hash.py +++ b/tests/client_tests/unit/test_hash.py @@ -23,9 +23,13 @@ class TestAESEncryptDecrypt(TestCase): 'ZmZmZmZmZmZmZmZmZmZmZjlrKptoKD+MFwDxcg3XtCD9qz8UWhEhq/TVJT5+Mtp2a8sE' 'CaO6WQj7fYsWGu2Hvbc0qYqxdN0HeTsiO+cZRo3eJISgr3F+rXFYi5oSBlD2' ) + self.assertEqual( + aes_decrypt(self.password, self.expected), + (self.message, b'f' * 16) + ) def test_encrypt_decrypt(self): self.assertEqual( - aes_decrypt('bubblegum', aes_encrypt('bubblegum', self.message)), + aes_decrypt('bubblegum', aes_encrypt('bubblegum', self.message))[0], self.message ) diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index 066d3bc9d..9e9cf8d05 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -201,7 +201,9 @@ class BaseAccount: self.seed = seed self.private_key_string = private_key_string self.password: Optional[str] = None - self.encryption_init_vector = None + self.private_key_encryption_init_vector: Optional[bytes] = None + self.seed_encryption_init_vector: Optional[bytes] = None + self.encrypted = encrypted self.serialize_encrypted = encrypted self.private_key = private_key @@ -264,13 +266,16 @@ class BaseAccount: if not self.encrypted and self.private_key: private_key_string = self.private_key.extended_key_string() if not self.encrypted and self.serialize_encrypted: - private_key_string = aes_encrypt(self.password, private_key_string, self.encryption_init_vector) - seed = aes_encrypt(self.password, self.seed, self.encryption_init_vector) + assert None not in [self.seed_encryption_init_vector, self.private_key_encryption_init_vector] + private_key_string = aes_encrypt( + self.password, private_key_string, self.private_key_encryption_init_vector + ) + seed = aes_encrypt(self.password, self.seed, self.seed_encryption_init_vector) return { 'ledger': self.ledger.get_id(), 'name': self.name, 'seed': seed, - 'encrypted': self.encrypted, + 'encrypted': self.serialize_encrypted, 'private_key': private_key_string, 'public_key': self.public_key.extended_key_string(), 'address_generator': self.address_generator.to_dict(self.receiving, self.change) @@ -293,9 +298,10 @@ class BaseAccount: def decrypt(self, password: str) -> None: assert self.encrypted, "Key is not encrypted." - self.seed = aes_decrypt(password, self.seed) + self.seed, self.seed_encryption_init_vector = aes_decrypt(password, self.seed) + pk_string, self.private_key_encryption_init_vector = aes_decrypt(password, self.private_key_string) self.private_key = from_extended_key_string( - self.ledger, aes_decrypt(password, self.private_key_string) + self.ledger, pk_string ) self.password = password self.encrypted = False @@ -303,9 +309,10 @@ class BaseAccount: def encrypt(self, password: str) -> None: assert not self.encrypted, "Key is already encrypted." assert isinstance(self.private_key, PrivateKey) - self.seed = aes_encrypt(password, self.seed, self.encryption_init_vector) + + self.seed = aes_encrypt(password, self.seed, self.seed_encryption_init_vector) self.private_key_string = aes_encrypt( - password, self.private_key.extended_key_string(), self.encryption_init_vector + password, self.private_key.extended_key_string(), self.private_key_encryption_init_vector ) self.private_key = None self.password = None diff --git a/torba/client/hash.py b/torba/client/hash.py index bee4ba8c7..dcd61a080 100644 --- a/torba/client/hash.py +++ b/torba/client/hash.py @@ -12,6 +12,7 @@ import os import base64 import hashlib import hmac +import typing from binascii import hexlify, unhexlify from cryptography.hazmat.primitives.ciphers import Cipher, modes from cryptography.hazmat.primitives.ciphers.algorithms import AES @@ -133,14 +134,14 @@ def aes_encrypt(secret: str, value: str, init_vector: bytes = None) -> str: return base64.b64encode(init_vector + encrypted_data).decode() -def aes_decrypt(secret: str, value: str) -> str: +def aes_decrypt(secret: str, value: str) -> typing.Tuple[str, bytes]: data = base64.b64decode(value.encode()) key = double_sha256(secret.encode()) init_vector, data = data[:16], data[16:] decryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).decryptor() unpadder = PKCS7(AES.block_size).unpadder() result = unpadder.update(decryptor.update(data)) + unpadder.finalize() - return result.decode() + return result.decode(), init_vector class Base58Error(Exception): From 345d4f8ab1cc2633003905f876f5cca542a58c35 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 18 Nov 2018 22:54:00 -0500 Subject: [PATCH 235/383] refactored tx sync --- .../integration/test_transactions.py | 14 +- tests/client_tests/unit/test_account.py | 10 +- tests/client_tests/unit/test_database.py | 11 +- tests/client_tests/unit/test_ledger.py | 22 +- tests/client_tests/unit/test_transaction.py | 6 +- tests/client_tests/unit/test_utils.py | 35 +++ torba/client/baseaccount.py | 104 ++++--- torba/client/basedatabase.py | 78 +++-- torba/client/baseledger.py | 294 ++++++++++++------ torba/client/util.py | 20 ++ torba/orchstr8/node.py | 13 +- torba/stream.py | 37 ++- torba/testcase.py | 15 +- 13 files changed, 425 insertions(+), 234 deletions(-) diff --git a/tests/client_tests/integration/test_transactions.py b/tests/client_tests/integration/test_transactions.py index 572a2f000..93f49a0d7 100644 --- a/tests/client_tests/integration/test_transactions.py +++ b/tests/client_tests/integration/test_transactions.py @@ -10,10 +10,10 @@ class BasicTransactionTests(IntegrationTestCase): async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) - await self.ledger.update_account(account2) + await self.ledger.subscribe_account(account2) - self.assertEqual(await self.get_balance(account1), 0) - self.assertEqual(await self.get_balance(account2), 0) + await self.assertBalance(account1, '0.0') + await self.assertBalance(account2, '0.0') sendtxids = [] for i in range(5): @@ -26,8 +26,8 @@ class BasicTransactionTests(IntegrationTestCase): self.on_transaction_id(txid) for txid in sendtxids ]) - self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 5.5) - self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 0) + await self.assertBalance(account1, '5.5') + await self.assertBalance(account2, '0.0') address2 = await account2.receiving.get_or_create_usable_address() hash2 = self.ledger.address_to_hash160(address2) @@ -41,8 +41,8 @@ class BasicTransactionTests(IntegrationTestCase): await self.blockchain.generate(1) await self.ledger.wait(tx) # confirmed - self.assertEqual(round(await self.get_balance(account1)/COIN, 1), 3.5) - self.assertEqual(round(await self.get_balance(account2)/COIN, 1), 2.0) + await self.assertBalance(account1, '3.499802') + await self.assertBalance(account2, '2.0') utxos = await self.account.get_utxos() tx = await self.ledger.transaction_class.create( diff --git a/tests/client_tests/unit/test_account.py b/tests/client_tests/unit/test_account.py index 8c50cea1c..b6a6d6895 100644 --- a/tests/client_tests/unit/test_account.py +++ b/tests/client_tests/unit/test_account.py @@ -44,7 +44,8 @@ class TestHierarchicalDeterministicAccount(AsyncioTestCase): self.assertEqual(len(addresses), 26) async def test_generate_keys_over_batch_threshold_saves_it_properly(self): - await self.account.receiving.generate_keys(0, 200) + async with self.account.receiving.address_generator_lock: + await self.account.receiving._generate_keys(0, 200) records = await self.account.receiving.get_address_records() self.assertEqual(201, len(records)) @@ -53,9 +54,10 @@ class TestHierarchicalDeterministicAccount(AsyncioTestCase): self.assertIsInstance(account.receiving, HierarchicalDeterministic) - await account.receiving.generate_keys(4, 7) - await account.receiving.generate_keys(0, 3) - await account.receiving.generate_keys(8, 11) + async with account.receiving.address_generator_lock: + await account.receiving._generate_keys(4, 7) + await account.receiving._generate_keys(0, 3) + await account.receiving._generate_keys(8, 11) records = await account.receiving.get_address_records() self.assertEqual( [r['position'] for r in records], diff --git a/tests/client_tests/unit/test_database.py b/tests/client_tests/unit/test_database.py index dcd241539..374280d52 100644 --- a/tests/client_tests/unit/test_database.py +++ b/tests/client_tests/unit/test_database.py @@ -128,7 +128,8 @@ class TestQueries(AsyncioTestCase): tx = ledger_class.transaction_class(height=height, is_verified=True) \ .add_inputs([self.txi(self.txo(1, NULL_HASH))]) \ .add_outputs([self.txo(1, to_hash)]) - await self.ledger.db.save_transaction_io('insert', tx, to_address, to_hash, '') + await self.ledger.db.insert_transaction(tx) + await self.ledger.db.save_transaction_io(tx, to_address, to_hash, '') return tx async def create_tx_from_txo(self, txo, to_account, height): @@ -139,8 +140,9 @@ class TestQueries(AsyncioTestCase): tx = ledger_class.transaction_class(height=height, is_verified=True) \ .add_inputs([self.txi(txo)]) \ .add_outputs([self.txo(1, to_hash)]) - await self.ledger.db.save_transaction_io('insert', tx, from_address, from_hash, '') - await self.ledger.db.save_transaction_io('', tx, to_address, to_hash, '') + await self.ledger.db.insert_transaction(tx) + await self.ledger.db.save_transaction_io(tx, from_address, from_hash, '') + await self.ledger.db.save_transaction_io(tx, to_address, to_hash, '') return tx async def create_tx_to_nowhere(self, txo, height): @@ -150,7 +152,8 @@ class TestQueries(AsyncioTestCase): tx = ledger_class.transaction_class(height=height, is_verified=True) \ .add_inputs([self.txi(txo)]) \ .add_outputs([self.txo(1, to_hash)]) - await self.ledger.db.save_transaction_io('insert', tx, from_address, from_hash, '') + await self.ledger.db.insert_transaction(tx) + await self.ledger.db.save_transaction_io(tx, from_address, from_hash, '') return tx def txo(self, amount, address): diff --git a/tests/client_tests/unit/test_ledger.py b/tests/client_tests/unit/test_ledger.py index caa5b990c..0e077b441 100644 --- a/tests/client_tests/unit/test_ledger.py +++ b/tests/client_tests/unit/test_ledger.py @@ -16,6 +16,7 @@ class MockNetwork: self.address = None self.get_history_called = [] self.get_transaction_called = [] + self.is_connected = False async def get_history(self, address): self.get_history_called.append(address) @@ -85,16 +86,21 @@ class TestSynchronization(LedgerTestCase): 'abcd02': hexlify(get_transaction(get_output(2)).raw), 'abcd03': hexlify(get_transaction(get_output(3)).raw), }) - await self.ledger.update_history(address) + await self.ledger.update_history(address, '') self.assertEqual(self.ledger.network.get_history_called, [address]) self.assertEqual(self.ledger.network.get_transaction_called, ['abcd01', 'abcd02', 'abcd03']) address_details = await self.ledger.db.get_address(address=address) - self.assertEqual(address_details['history'], 'abcd01:0:abcd02:1:abcd03:2:') + self.assertEqual( + address_details['history'], + '252bda9b22cc902ca2aa2de3548ee8baf06b8501ff7bfb3b0b7d980dbd1bf792:0:' + 'ab9c0654dd484ac20437030f2034e25dcb29fc507e84b91138f80adc3af738f9:1:' + 'a2ae3d1db3c727e7d696122cab39ee20a7f81856dab7019056dd539f38c548a0:2:' + ) self.ledger.network.get_history_called = [] self.ledger.network.get_transaction_called = [] - await self.ledger.update_history(address) + await self.ledger.update_history(address, '') self.assertEqual(self.ledger.network.get_history_called, [address]) self.assertEqual(self.ledger.network.get_transaction_called, []) @@ -102,11 +108,17 @@ class TestSynchronization(LedgerTestCase): self.ledger.network.transaction['abcd04'] = hexlify(get_transaction(get_output(4)).raw) self.ledger.network.get_history_called = [] self.ledger.network.get_transaction_called = [] - await self.ledger.update_history(address) + await self.ledger.update_history(address, '') self.assertEqual(self.ledger.network.get_history_called, [address]) self.assertEqual(self.ledger.network.get_transaction_called, ['abcd04']) address_details = await self.ledger.db.get_address(address=address) - self.assertEqual(address_details['history'], 'abcd01:0:abcd02:1:abcd03:2:abcd04:3:') + self.assertEqual( + address_details['history'], + '252bda9b22cc902ca2aa2de3548ee8baf06b8501ff7bfb3b0b7d980dbd1bf792:0:' + 'ab9c0654dd484ac20437030f2034e25dcb29fc507e84b91138f80adc3af738f9:1:' + 'a2ae3d1db3c727e7d696122cab39ee20a7f81856dab7019056dd539f38c548a0:2:' + '047cf1d53ef68f0fd586d46f90c09ff8e57a4180f67e7f4b8dd0135c3741e828:3:' + ) class MocHeaderNetwork: diff --git a/tests/client_tests/unit/test_transaction.py b/tests/client_tests/unit/test_transaction.py index 8532f95fc..800c05322 100644 --- a/tests/client_tests/unit/test_transaction.py +++ b/tests/client_tests/unit/test_transaction.py @@ -261,14 +261,14 @@ class TransactionIOBalancing(AsyncioTestCase): .add_inputs([self.txi(self.txo(sum(amounts)+0.1))]) \ .add_outputs(utxos) - save_tx = 'insert' + await self.ledger.db.insert_transaction(self.funding_tx) + for utxo in utxos: await self.ledger.db.save_transaction_io( - save_tx, self.funding_tx, + self.funding_tx, self.ledger.hash160_to_address(utxo.script.values['pubkey_hash']), utxo.script.values['pubkey_hash'], '' ) - save_tx = 'update' return utxos diff --git a/tests/client_tests/unit/test_utils.py b/tests/client_tests/unit/test_utils.py index 8bc368302..3d9e19d0a 100644 --- a/tests/client_tests/unit/test_utils.py +++ b/tests/client_tests/unit/test_utils.py @@ -1,6 +1,41 @@ import unittest from torba.client.util import ArithUint256 +from torba.client.util import coins_to_satoshis as c2s, satoshis_to_coins as s2c + + +class TestCoinValueParsing(unittest.TestCase): + + def test_good_output(self): + self.assertEqual(s2c(1), "0.00000001") + self.assertEqual(s2c(10**7), "0.1") + self.assertEqual(s2c(2*10**8), "2.0") + self.assertEqual(s2c(2*10**17), "2000000000.0") + + def test_good_input(self): + self.assertEqual(c2s("0.00000001"), 1) + self.assertEqual(c2s("0.1"), 10**7) + self.assertEqual(c2s("1.0"), 10**8) + self.assertEqual(c2s("2.00000000"), 2*10**8) + self.assertEqual(c2s("2000000000.0"), 2*10**17) + + def test_bad_input(self): + with self.assertRaises(ValueError): + c2s("1") + with self.assertRaises(ValueError): + c2s("-1.0") + with self.assertRaises(ValueError): + c2s("10000000000.0") + with self.assertRaises(ValueError): + c2s("1.000000000") + with self.assertRaises(ValueError): + c2s("-0") + with self.assertRaises(ValueError): + c2s("1") + with self.assertRaises(ValueError): + c2s(".1") + with self.assertRaises(ValueError): + c2s("1e-7") class TestArithUint256(unittest.TestCase): diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index 9e9cf8d05..ad173f197 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -1,6 +1,7 @@ +import asyncio import random import typing -from typing import Dict, Tuple, Type, Optional, Any +from typing import Dict, Tuple, Type, Optional, Any, List from torba.client.mnemonic import Mnemonic from torba.client.bip32 import PrivateKey, PubKey, from_extended_key_string @@ -15,12 +16,13 @@ class AddressManager: name: str - __slots__ = 'account', 'public_key', 'chain_number' + __slots__ = 'account', 'public_key', 'chain_number', 'address_generator_lock' def __init__(self, account, public_key, chain_number): self.account = account self.public_key = public_key self.chain_number = chain_number + self.address_generator_lock = asyncio.Lock() @classmethod def from_dict(cls, account: 'BaseAccount', d: dict) \ @@ -60,11 +62,11 @@ class AddressManager: def get_address_records(self, only_usable: bool = False, **constraints): raise NotImplementedError - async def get_addresses(self, only_usable: bool = False, **constraints): + async def get_addresses(self, only_usable: bool = False, **constraints) -> List[str]: records = await self.get_address_records(only_usable=only_usable, **constraints) return [r['address'] for r in records] - async def get_or_create_usable_address(self): + async def get_or_create_usable_address(self) -> str: addresses = await self.get_addresses(only_usable=True, limit=10) if addresses: return random.choice(addresses) @@ -87,8 +89,8 @@ class HierarchicalDeterministic(AddressManager): @classmethod def from_dict(cls, account: 'BaseAccount', d: dict) -> Tuple[AddressManager, AddressManager]: return ( - cls(account, 0, **d.get('receiving', {'gap': 20, 'maximum_uses_per_address': 2})), - cls(account, 1, **d.get('change', {'gap': 6, 'maximum_uses_per_address': 2})) + cls(account, 0, **d.get('receiving', {'gap': 20, 'maximum_uses_per_address': 1})), + cls(account, 1, **d.get('change', {'gap': 6, 'maximum_uses_per_address': 1})) ) def to_dict_instance(self): @@ -97,19 +99,7 @@ class HierarchicalDeterministic(AddressManager): def get_private_key(self, index: int) -> PrivateKey: return self.account.private_key.child(self.chain_number).child(index) - async def generate_keys(self, start: int, end: int): - keys_batch, final_keys = [], [] - for index in range(start, end+1): - keys_batch.append((index, self.public_key.child(index))) - if index % 180 == 0 or index == end: - await self.account.ledger.db.add_keys( - self.account, self.chain_number, keys_batch - ) - final_keys.extend(keys_batch) - keys_batch.clear() - return [key[1].address for key in final_keys] - - async def get_max_gap(self): + async def get_max_gap(self) -> int: addresses = await self._query_addresses(order_by="position ASC") max_gap = 0 current_gap = 0 @@ -121,27 +111,43 @@ class HierarchicalDeterministic(AddressManager): current_gap = 0 return max_gap - async def ensure_address_gap(self): - addresses = await self._query_addresses(limit=self.gap, order_by="position DESC") + async def ensure_address_gap(self) -> List[str]: + async with self.address_generator_lock: + addresses = await self._query_addresses(limit=self.gap, order_by="position DESC") - existing_gap = 0 - for address in addresses: - if address['used_times'] == 0: - existing_gap += 1 - else: - break + existing_gap = 0 + for address in addresses: + if address['used_times'] == 0: + existing_gap += 1 + else: + break - if existing_gap == self.gap: - return [] + if existing_gap == self.gap: + return [] - start = addresses[0]['position']+1 if addresses else 0 - end = start + (self.gap - existing_gap) - new_keys = await self.generate_keys(start, end-1) - return new_keys + start = addresses[0]['position']+1 if addresses else 0 + end = start + (self.gap - existing_gap) + new_keys = await self._generate_keys(start, end-1) + await self.account.ledger.subscribe_addresses(self, new_keys) + return new_keys + + async def _generate_keys(self, start: int, end: int) -> List[str]: + if not self.address_generator_lock.locked(): + raise RuntimeError('Should not be called outside of address_generator_lock.') + keys_batch, final_keys = [], [] + for index in range(start, end+1): + keys_batch.append((index, self.public_key.child(index))) + if index % 180 == 0 or index == end: + await self.account.ledger.db.add_keys( + self.account, self.chain_number, keys_batch + ) + final_keys.extend(keys_batch) + keys_batch.clear() + return [key[1].address for key in final_keys] def get_address_records(self, only_usable: bool = False, **constraints): if only_usable: - constraints['used_times__lte'] = self.maximum_uses_per_address + constraints['used_times__lt'] = self.maximum_uses_per_address return self._query_addresses(order_by="used_times ASC, position ASC", **constraints) @@ -164,17 +170,20 @@ class SingleKey(AddressManager): def get_private_key(self, index: int) -> PrivateKey: return self.account.private_key - async def get_max_gap(self): + async def get_max_gap(self) -> int: return 0 - async def ensure_address_gap(self): - exists = await self.get_address_records() - if not exists: - await self.account.ledger.db.add_keys( - self.account, self.chain_number, [(0, self.public_key)] - ) - return [self.public_key.address] - return [] + async def ensure_address_gap(self) -> List[str]: + async with self.address_generator_lock: + exists = await self.get_address_records() + if not exists: + await self.account.ledger.db.add_keys( + self.account, self.chain_number, [(0, self.public_key)] + ) + new_keys = [self.public_key.address] + await self.account.ledger.subscribe_addresses(self, new_keys) + return new_keys + return [] def get_address_records(self, only_usable: bool = False, **constraints): return self._query_addresses(**constraints) @@ -211,7 +220,7 @@ class BaseAccount: generator_name = address_generator.get('name', HierarchicalDeterministic.name) self.address_generator = self.address_generators[generator_name] self.receiving, self.change = self.address_generator.from_dict(self, address_generator) - self.address_managers = {self.receiving, self.change} + self.address_managers = {am.chain_number: am for am in {self.receiving, self.change}} ledger.add_account(self) wallet.add_account(self) @@ -320,12 +329,12 @@ class BaseAccount: async def ensure_address_gap(self): addresses = [] - for address_manager in self.address_managers: + for address_manager in self.address_managers.values(): new_addresses = await address_manager.ensure_address_gap() addresses.extend(new_addresses) return addresses - async def get_addresses(self, **constraints): + async def get_addresses(self, **constraints) -> List[str]: rows = await self.ledger.db.select_addresses('address', account=self, **constraints) return [r[0] for r in rows] @@ -337,8 +346,7 @@ class BaseAccount: def get_private_key(self, chain: int, index: int) -> PrivateKey: assert not self.encrypted, "Cannot get private key on encrypted wallet account." - address_manager = {0: self.receiving, 1: self.change}[chain] - return address_manager.get_private_key(index) + return self.address_managers[chain].get_private_key(index) def get_balance(self, confirmations: int = 0, **constraints): if confirmations > 0: diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index c64fedff6..dc5a1d93f 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -169,13 +169,16 @@ class SQLiteMixin: await self.db.close() @staticmethod - def _insert_sql(table: str, data: dict) -> Tuple[str, List]: + def _insert_sql(table: str, data: dict, ignore_duplicate: bool = False) -> Tuple[str, List]: columns, values = [], [] for column, value in data.items(): columns.append(column) values.append(value) - sql = "INSERT INTO {} ({}) VALUES ({})".format( - table, ', '.join(columns), ', '.join(['?'] * len(values)) + or_ignore = "" + if ignore_duplicate: + or_ignore = " OR IGNORE" + sql = "INSERT{} INTO {} ({}) VALUES ({})".format( + or_ignore, table, ', '.join(columns), ', '.join(['?'] * len(values)) ) return sql, values @@ -273,60 +276,49 @@ class BaseDatabase(SQLiteMixin): 'script': sqlite3.Binary(txo.script.source) } - def save_transaction_io(self, save_tx, tx: BaseTransaction, address, txhash, history): + async def insert_transaction(self, tx): + await self.db.execute(*self._insert_sql('tx', { + 'txid': tx.id, + 'raw': sqlite3.Binary(tx.raw), + 'height': tx.height, + 'position': tx.position, + 'is_verified': tx.is_verified + })) - def _transaction(conn: sqlite3.Connection, save_tx, tx: BaseTransaction, address, txhash, history): - if save_tx == 'insert': - conn.execute(*self._insert_sql('tx', { - 'txid': tx.id, - 'raw': sqlite3.Binary(tx.raw), - 'height': tx.height, - 'position': tx.position, - 'is_verified': tx.is_verified - })) - elif save_tx == 'update': - conn.execute(*self._update_sql("tx", { - 'height': tx.height, 'position': tx.position, 'is_verified': tx.is_verified - }, 'txid = ?', (tx.id,))) + async def update_transaction(self, tx): + await self.db.execute(*self._update_sql("tx", { + 'height': tx.height, 'position': tx.position, 'is_verified': tx.is_verified + }, 'txid = ?', (tx.id,))) - existing_txos = set(map(itemgetter(0), conn.execute(*query( - "SELECT position FROM txo", txid=tx.id - )))) + def save_transaction_io(self, tx: BaseTransaction, address, txhash, history): + + def _transaction(conn: sqlite3.Connection, tx: BaseTransaction, address, txhash, history): for txo in tx.outputs: - if txo.position in existing_txos: - continue if txo.script.is_pay_pubkey_hash and txo.script.values['pubkey_hash'] == txhash: - conn.execute(*self._insert_sql("txo", self.txo_to_row(tx, address, txo))) + conn.execute(*self._insert_sql( + "txo", self.txo_to_row(tx, address, txo), ignore_duplicate=True + )) elif txo.script.is_pay_script_hash: # TODO: implement script hash payments log.warning('Database.save_transaction_io: pay script hash is not implemented!') - # lookup the address associated with each TXI (via its TXO) - txoid_to_address = {r[0]: r[1] for r in conn.execute(*query( - "SELECT txoid, address FROM txo", txoid__in=[txi.txo_ref.id for txi in tx.inputs] - ))} - - # list of TXIs that have already been added - existing_txis = {r[0] for r in conn.execute(*query( - "SELECT txoid FROM txi", txid=tx.id - ))} - for txi in tx.inputs: - txoid = txi.txo_ref.id - new_txi = txoid not in existing_txis - address_matches = txoid_to_address.get(txoid) == address - if new_txi and address_matches: - conn.execute(*self._insert_sql("txi", { - 'txid': tx.id, - 'txoid': txoid, - 'address': address, - })) + if txi.txo_ref.txo is not None: + txo = txi.txo_ref.txo + if txo.get_address(self.ledger) == address: + conn.execute(*self._insert_sql("txi", { + 'txid': tx.id, + 'txoid': txo.id, + 'address': address, + }, ignore_duplicate=True)) + conn.execute( "UPDATE pubkey_address SET history = ?, used_times = ? WHERE address = ?", (history, history.count(':')//2, address) ) - return self.db.run(_transaction, save_tx, tx, address, txhash, history) + + return self.db.run(_transaction, tx, address, txhash, history) async def reserve_outputs(self, txos, is_reserved=True): txoids = [txo.id for txo in txos] diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index 11a603802..6fd86b008 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -5,7 +5,7 @@ from functools import partial from binascii import hexlify, unhexlify from io import StringIO -from typing import Dict, Type, Iterable +from typing import Dict, Type, Iterable, List, Optional from operator import itemgetter from collections import namedtuple @@ -48,6 +48,51 @@ class BlockHeightEvent(namedtuple('BlockHeightEvent', ('height', 'change'))): pass +class TransactionCacheItem: + __slots__ = '_tx', 'lock', 'has_tx' + + def __init__(self, + tx: Optional[basetransaction.BaseTransaction] = None, + lock: Optional[asyncio.Lock] = None): + self.has_tx = asyncio.Event() + self.lock = lock or asyncio.Lock() + self.tx = tx + + @property + def tx(self): + return self._tx + + @tx.setter + def tx(self, tx): + self._tx = tx + if tx is not None: + self.has_tx.set() + + +class SynchronizationMonitor: + + def __init__(self): + self.done = asyncio.Event() + self.tasks = [] + + def add(self, coro): + len(self.tasks) < 1 and self.done.clear() + asyncio.ensure_future(self._monitor(coro)) + + def cancel(self): + for task in self.tasks: + task.cancel() + + async def _monitor(self, coro): + task = asyncio.ensure_future(coro) + self.tasks.append(task) + try: + await task + finally: + self.tasks.remove(task) + len(self.tasks) < 1 and self.done.set() + + class BaseLedger(metaclass=LedgerRegistry): name: str @@ -79,7 +124,8 @@ class BaseLedger(metaclass=LedgerRegistry): ) self.network = self.config.get('network') or self.network_class(self) self.network.on_header.listen(self.receive_header) - self.network.on_status.listen(self.receive_status) + self.network.on_status.listen(self.process_status_update) + self.accounts = [] self.fee_per_byte: int = self.config.get('fee_per_byte', self.default_fee_per_byte) @@ -101,7 +147,8 @@ class BaseLedger(metaclass=LedgerRegistry): ) ) - self._transaction_processing_locks = {} + self._tx_cache = {} + self.sync = SynchronizationMonitor() self._utxo_reservation_lock = asyncio.Lock() self._header_processing_lock = asyncio.Lock() @@ -166,16 +213,14 @@ class BaseLedger(metaclass=LedgerRegistry): def release_outputs(self, txos): return self.db.release_outputs(txos) - async def get_local_status(self, address): - address_details = await self.db.get_address(address=address) - history = address_details['history'] - return hexlify(sha256(history.encode())).decode() if history else None - - async def get_local_history(self, address): + async def get_local_status_and_history(self, address): address_details = await self.db.get_address(address=address) history = address_details['history'] or '' parts = history.split(':')[:-1] - return list(zip(parts[0::2], map(int, parts[1::2]))) + return ( + hexlify(sha256(history.encode())).decode() if history else None, + list(zip(parts[0::2], map(int, parts[1::2]))) + ) @staticmethod def get_root_of_merkle_tree(branches, branch_positions, working_branch): @@ -189,21 +234,13 @@ class BaseLedger(metaclass=LedgerRegistry): working_branch = double_sha256(combined) return hexlify(working_branch[::-1]) - async def validate_transaction_and_set_position(self, tx, height, merkle): - if not height <= len(self.headers): - return False - merkle_root = self.get_root_of_merkle_tree(merkle['merkle'], merkle['pos'], tx.hash) - header = self.headers[height] - tx.position = merkle['pos'] - tx.is_verified = merkle_root == header['merkle_root'] - async def start(self): if not os.path.exists(self.path): os.mkdir(self.path) - await asyncio.gather( + await asyncio.wait([ self.db.open(), self.headers.open() - ) + ]) first_connection = self.network.on_connected.first asyncio.ensure_future(self.network.start()) await first_connection @@ -214,9 +251,15 @@ class BaseLedger(metaclass=LedgerRegistry): log.info("Subscribing and updating accounts.") await self.update_headers() await self.network.subscribe_headers() - await self.update_accounts() + import time + start = time.time() + await self.subscribe_accounts() + await self.sync.done.wait() + log.info(f'elapsed: {time.time()-start}') async def stop(self): + self.sync.cancel() + await self.sync.done.wait() await self.network.stop() await self.db.close() await self.headers.close() @@ -299,89 +342,144 @@ class BaseLedger(metaclass=LedgerRegistry): height=header['height'], headers=header['hex'], subscription_update=True ) - async def update_accounts(self): - return await asyncio.gather(*( - self.update_account(a) for a in self.accounts - )) + async def subscribe_accounts(self): + if self.network.is_connected and self.accounts: + await asyncio.wait([ + self.subscribe_account(a) for a in self.accounts + ]) - async def update_account(self, account: baseaccount.BaseAccount): + async def subscribe_account(self, account: baseaccount.BaseAccount): + for address_manager in account.address_managers.values(): + await self.subscribe_addresses(address_manager, await address_manager.get_addresses()) await account.ensure_address_gap() - addresses = await account.get_addresses() - while addresses: - await asyncio.gather(*(self.subscribe_history(a) for a in addresses)) - addresses = await account.ensure_address_gap() - def _prefetch_history(self, remote_history, local_history): - proofs, network_txs = {}, {} - for i, (hex_id, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): - if i < len(local_history) and local_history[i] == (hex_id, remote_height): - continue - if remote_height > 0: - proofs[hex_id] = asyncio.ensure_future(self.network.get_merkle(hex_id, remote_height)) - network_txs[hex_id] = asyncio.ensure_future(self.network.get_transaction(hex_id)) - return proofs, network_txs + async def subscribe_addresses(self, address_manager: baseaccount.AddressManager, addresses: List[str]): + if self.network.is_connected and addresses: + await asyncio.wait([ + self.subscribe_address(address_manager, address) for address in addresses + ]) - async def update_history(self, address): - remote_history = await self.network.get_history(address) - local_history = await self.get_local_history(address) - proofs, network_txs = self._prefetch_history(remote_history, local_history) - - synced_history = StringIO() - for i, (hex_id, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): - - synced_history.write('{}:{}:'.format(hex_id, remote_height)) - - if i < len(local_history) and local_history[i] == (hex_id, remote_height): - continue - - lock = self._transaction_processing_locks.setdefault(hex_id, asyncio.Lock()) - - await lock.acquire() - - try: - - # see if we have a local copy of transaction, otherwise fetch it from server - tx = await self.db.get_transaction(txid=hex_id) - save_tx = None - if tx is None: - _raw = await network_txs[hex_id] - tx = self.transaction_class(unhexlify(_raw)) - save_tx = 'insert' - - tx.height = remote_height - - if remote_height > 0 and (not tx.is_verified or tx.position == -1): - await self.validate_transaction_and_set_position(tx, remote_height, await proofs[hex_id]) - if save_tx is None: - save_tx = 'update' - - await self.db.save_transaction_io( - save_tx, tx, address, self.address_to_hash160(address), synced_history.getvalue() - ) - - log.debug( - "%s: sync'ed tx %s for address: %s, height: %s, verified: %s", - self.get_id(), hex_id, address, tx.height, tx.is_verified - ) - - self._on_transaction_controller.add(TransactionEvent(address, tx)) - - finally: - lock.release() - if not lock.locked() and hex_id in self._transaction_processing_locks: - del self._transaction_processing_locks[hex_id] - - async def subscribe_history(self, address): + async def subscribe_address(self, address_manager: baseaccount.AddressManager, address: str): remote_status = await self.network.subscribe_address(address) - local_status = await self.get_local_status(address) - if local_status != remote_status: - await self.update_history(address) + self.sync.add(self.update_history(address, remote_status, address_manager)) - async def receive_status(self, response): - address, remote_status = response - local_status = await self.get_local_status(address) - if local_status != remote_status: - await self.update_history(address) + def process_status_update(self, update): + address, remote_status = update + self.sync.add(self.update_history(address, remote_status)) + + async def update_history(self, address, remote_status, + address_manager: baseaccount.AddressManager = None): + local_status, local_history = await self.get_local_status_and_history(address) + + if local_status == remote_status: + return + + remote_history = await self.network.get_history(address) + + cache_tasks = [] + synced_history = StringIO() + for i, (txid, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): + if i < len(local_history) and local_history[i] == (txid, remote_height): + synced_history.write(f'{txid}:{remote_height}:') + else: + cache_tasks.append(asyncio.ensure_future( + self.cache_transaction(txid, remote_height) + )) + + for task in cache_tasks: + tx = await task + + check_db_for_txos = [] + for txi in tx.inputs: + if txi.txo_ref.txo is not None: + continue + cache_item = self._tx_cache.get(txi.txo_ref.tx_ref.id) + if cache_item is not None: + if cache_item.tx is None: + await cache_item.has_tx.wait() + txi.txo_ref = cache_item.tx.outputs[txi.txo_ref.position].ref + else: + check_db_for_txos.append(txi.txo_ref.tx_ref.id) + + referenced_txos = { + txo.id: txo for txo in await self.db.get_txos(txoid__in=check_db_for_txos) + } + + for txi in tx.inputs: + if txi.txo_ref.txo is not None: + continue + referenced_txo = referenced_txos.get(txi.txo_ref.tx_ref.id) + if referenced_txos: + txi.txo_ref = referenced_txo.ref + + synced_history.write(f'{tx.id}:{tx.height}:') + + await self.db.save_transaction_io( + tx, address, self.address_to_hash160(address), synced_history.getvalue() + ) + + self._on_transaction_controller.add(TransactionEvent(address, tx)) + + if address_manager is None: + address_manager = await self.get_address_manager_for_address(address) + + await address_manager.ensure_address_gap() + + async def cache_transaction(self, txid, remote_height): + cache_item = self._tx_cache.get(txid) + if cache_item is None: + cache_item = self._tx_cache[txid] = TransactionCacheItem() + elif cache_item.tx is not None and \ + cache_item.tx.height >= remote_height and \ + (cache_item.tx.is_verified or remote_height < 1): + return cache_item.tx # cached tx is already up-to-date + + await cache_item.lock.acquire() + + try: + tx = cache_item.tx + + if tx is None: + # check local db + tx = cache_item.tx = await self.db.get_transaction(txid=txid) + + if tx is None: + # fetch from network + _raw = await self.network.get_transaction(txid) + if _raw: + tx = self.transaction_class(unhexlify(_raw)) + await self.maybe_verify_transaction(tx, remote_height) + await self.db.insert_transaction(tx) + cache_item.tx = tx # make sure it's saved before caching it + return tx + + if tx is None: + raise ValueError(f'Transaction {txid} was not in database and not on network.') + + if 0 < remote_height and not tx.is_verified: + # tx from cache / db is not up-to-date + await self.maybe_verify_transaction(tx, remote_height) + await self.db.update_transaction(tx) + + return tx + + finally: + cache_item.lock.release() + + async def maybe_verify_transaction(self, tx, remote_height): + tx.height = remote_height + if 0 < remote_height <= len(self.headers): + merkle = await self.network.get_merkle(tx.id, remote_height) + merkle_root = self.get_root_of_merkle_tree(merkle['merkle'], merkle['pos'], tx.hash) + header = self.headers[remote_height] + tx.position = merkle['pos'] + tx.is_verified = merkle_root == header['merkle_root'] + + async def get_address_manager_for_address(self, address) -> baseaccount.AddressManager: + details = await self.db.get_address(address=address) + for account in self.accounts: + if account.id == details['account']: + return account.address_managers[details['chain']] def broadcast(self, tx): return self.network.broadcast(hexlify(tx.raw).decode()) diff --git a/torba/client/util.py b/torba/client/util.py index 8ae838027..f57963a89 100644 --- a/torba/client/util.py +++ b/torba/client/util.py @@ -1,5 +1,25 @@ +import re from binascii import unhexlify, hexlify from typing import TypeVar, Sequence, Optional +from torba.client.constants import COIN + + +def coins_to_satoshis(coins): + if not isinstance(coins, str): + raise ValueError("{coins} must be a string") + result = re.search(r'^(\d{1,10})\.(\d{1,8})$', coins) + if result is not None: + whole, fractional = result.groups() + return int(whole+fractional.ljust(8, "0")) + raise ValueError("'{lbc}' is not a valid coin decimal") + + +def satoshis_to_coins(satoshis): + coins = '{:.8f}'.format(satoshis / COIN).rstrip('0') + if coins.endswith('.'): + return coins+'0' + else: + return coins T = TypeVar('T') diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index 7ebd2f879..46c9b9bb1 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -112,7 +112,7 @@ class Conductor: class WalletNode: def __init__(self, manager_class: Type[BaseWalletManager], ledger_class: Type[BaseLedger], - verbose: bool = False) -> None: + verbose: bool = False, api_port: int = 5279) -> None: self.manager_class = manager_class self.ledger_class = ledger_class self.verbose = verbose @@ -121,8 +121,9 @@ class WalletNode: self.wallet: Optional[Wallet] = None self.account: Optional[BaseAccount] = None self.data_path: Optional[str] = None + self.api_port = api_port - async def start(self): + async def start(self, seed=None): self.data_path = tempfile.mkdtemp() wallet_file_name = os.path.join(self.data_path, 'my_wallet.json') with open(wallet_file_name, 'w') as wallet_file: @@ -130,6 +131,7 @@ class WalletNode: self.manager = self.manager_class.from_config({ 'ledgers': { self.ledger_class.get_id(): { + 'api_port': self.api_port, 'default_servers': [('localhost', 1984)], 'data_path': self.data_path } @@ -138,7 +140,12 @@ class WalletNode: }) self.ledger = self.manager.ledgers[self.ledger_class] self.wallet = self.manager.default_wallet - self.wallet.generate_account(self.ledger) + if seed is None: + self.wallet.generate_account(self.ledger) + else: + self.ledger.account_class.from_dict( + self.ledger, self.wallet, {'seed': seed} + ) self.account = self.wallet.default_account await self.manager.start() diff --git a/torba/stream.py b/torba/stream.py index 64c1f5e10..40589ade0 100644 --- a/torba/stream.py +++ b/torba/stream.py @@ -29,18 +29,18 @@ class BroadcastSubscription: def _add(self, data): if self.can_fire and self._on_data is not None: - maybe_coroutine = self._on_data(data) - if asyncio.iscoroutine(maybe_coroutine): - asyncio.ensure_future(maybe_coroutine) + return self._on_data(data) def _add_error(self, exception): if self.can_fire and self._on_error is not None: - self._on_error(exception) + return self._on_error(exception) def _close(self): - if self.can_fire and self._on_done is not None: - self._on_done() - self.is_closed = True + try: + if self.can_fire and self._on_done is not None: + return self._on_done() + finally: + self.is_closed = True class StreamController: @@ -62,13 +62,28 @@ class StreamController: next_sub = next_sub._next yield subscription - def add(self, event): + def _notify_and_ensure_future(self, notify): + tasks = [] for subscription in self._iterate_subscriptions: - subscription._add(event) + maybe_coroutine = notify(subscription) + if asyncio.iscoroutine(maybe_coroutine): + tasks.append(maybe_coroutine) + if tasks: + return asyncio.ensure_future(asyncio.wait(tasks)) + else: + f = asyncio.get_event_loop().create_future() + f.set_result(None) + return f + + def add(self, event): + return self._notify_and_ensure_future( + lambda subscription: subscription._add(event) + ) def add_error(self, exception): - for subscription in self._iterate_subscriptions: - subscription._add_error(exception) + return self._notify_and_ensure_future( + lambda subscription: subscription._add_error(exception) + ) def close(self): for subscription in self._iterate_subscriptions: diff --git a/torba/testcase.py b/torba/testcase.py index d8f1f9ef0..30c2f3526 100644 --- a/torba/testcase.py +++ b/torba/testcase.py @@ -9,6 +9,7 @@ from torba.client.baseledger import BaseLedger from torba.client.baseaccount import BaseAccount from torba.client.basemanager import BaseWalletManager from torba.client.wallet import Wallet +from torba.client.util import satoshis_to_coins try: @@ -159,15 +160,13 @@ class IntegrationTestCase(AsyncioTestCase): async def asyncTearDown(self): await self.conductor.stop() + async def assertBalance(self, account, expected_balance: str): + balance = await account.get_balance() + self.assertEqual(satoshis_to_coins(balance), expected_balance) + def broadcast(self, tx): return self.ledger.broadcast(tx) - def get_balance(self, account=None, confirmations=0): - if account is None: - return self.manager.get_balance(confirmations=confirmations) - else: - return account.get_balance(confirmations=confirmations) - async def on_header(self, height): if self.ledger.headers.height < height: await self.ledger.on_header.where( @@ -175,8 +174,8 @@ class IntegrationTestCase(AsyncioTestCase): ) return True - def on_transaction_id(self, txid): - return self.ledger.on_transaction.where( + def on_transaction_id(self, txid, ledger=None): + return (ledger or self.ledger).on_transaction.where( lambda e: e.tx.id == txid ) From ee28bbc19bcb4e0612a11f866170f222c6be4325 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 18 Nov 2018 23:07:54 -0500 Subject: [PATCH 236/383] pylint and mypy fixes --- torba/client/basedatabase.py | 1 - torba/client/baseledger.py | 24 ++++++++++++------------ torba/testcase.py | 2 +- 3 files changed, 13 insertions(+), 14 deletions(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index dc5a1d93f..824e1fa21 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -2,7 +2,6 @@ import logging import asyncio from asyncio import wrap_future from concurrent.futures.thread import ThreadPoolExecutor -from operator import itemgetter from typing import Tuple, List, Union, Callable, Any, Awaitable, Iterable diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index 6fd86b008..aec78034a 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -52,18 +52,18 @@ class TransactionCacheItem: __slots__ = '_tx', 'lock', 'has_tx' def __init__(self, - tx: Optional[basetransaction.BaseTransaction] = None, - lock: Optional[asyncio.Lock] = None): + tx: Optional[basetransaction.BaseTransaction] = None, + lock: Optional[asyncio.Lock] = None): self.has_tx = asyncio.Event() self.lock = lock or asyncio.Lock() - self.tx = tx + self._tx = self.tx = tx @property - def tx(self): + def tx(self) -> Optional[basetransaction.BaseTransaction]: return self._tx @tx.setter - def tx(self, tx): + def tx(self, tx: basetransaction.BaseTransaction): self._tx = tx if tx is not None: self.has_tx.set() @@ -251,11 +251,8 @@ class BaseLedger(metaclass=LedgerRegistry): log.info("Subscribing and updating accounts.") await self.update_headers() await self.network.subscribe_headers() - import time - start = time.time() await self.subscribe_accounts() await self.sync.done.wait() - log.info(f'elapsed: {time.time()-start}') async def stop(self): self.sync.cancel() @@ -397,6 +394,7 @@ class BaseLedger(metaclass=LedgerRegistry): if cache_item is not None: if cache_item.tx is None: await cache_item.has_tx.wait() + assert cache_item.tx is not None txi.txo_ref = cache_item.tx.outputs[txi.txo_ref.position].ref else: check_db_for_txos.append(txi.txo_ref.tx_ref.id) @@ -409,7 +407,7 @@ class BaseLedger(metaclass=LedgerRegistry): if txi.txo_ref.txo is not None: continue referenced_txo = referenced_txos.get(txi.txo_ref.tx_ref.id) - if referenced_txos: + if referenced_txo is not None: txi.txo_ref = referenced_txo.ref synced_history.write(f'{tx.id}:{tx.height}:') @@ -423,7 +421,8 @@ class BaseLedger(metaclass=LedgerRegistry): if address_manager is None: address_manager = await self.get_address_manager_for_address(address) - await address_manager.ensure_address_gap() + if address_manager is not None: + await address_manager.ensure_address_gap() async def cache_transaction(self, txid, remote_height): cache_item = self._tx_cache.get(txid) @@ -456,7 +455,7 @@ class BaseLedger(metaclass=LedgerRegistry): if tx is None: raise ValueError(f'Transaction {txid} was not in database and not on network.') - if 0 < remote_height and not tx.is_verified: + if remote_height > 0 and not tx.is_verified: # tx from cache / db is not up-to-date await self.maybe_verify_transaction(tx, remote_height) await self.db.update_transaction(tx) @@ -475,11 +474,12 @@ class BaseLedger(metaclass=LedgerRegistry): tx.position = merkle['pos'] tx.is_verified = merkle_root == header['merkle_root'] - async def get_address_manager_for_address(self, address) -> baseaccount.AddressManager: + async def get_address_manager_for_address(self, address) -> Optional[baseaccount.AddressManager]: details = await self.db.get_address(address=address) for account in self.accounts: if account.id == details['account']: return account.address_managers[details['chain']] + return None def broadcast(self, tx): return self.network.broadcast(hexlify(tx.raw).decode()) diff --git a/torba/testcase.py b/torba/testcase.py index 30c2f3526..a7eabab4d 100644 --- a/torba/testcase.py +++ b/torba/testcase.py @@ -160,7 +160,7 @@ class IntegrationTestCase(AsyncioTestCase): async def asyncTearDown(self): await self.conductor.stop() - async def assertBalance(self, account, expected_balance: str): + async def assertBalance(self, account, expected_balance: str): # pylint: disable=C0103 balance = await account.get_balance() self.assertEqual(satoshis_to_coins(balance), expected_balance) From 1732167af15d7653fc70cd6cf4525aa255ae5790 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 18 Nov 2018 23:17:39 -0500 Subject: [PATCH 237/383] use assertBalance in reconnect tests --- tests/client_tests/integration/test_reconnect.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tests/client_tests/integration/test_reconnect.py b/tests/client_tests/integration/test_reconnect.py index 779b45e77..857954889 100644 --- a/tests/client_tests/integration/test_reconnect.py +++ b/tests/client_tests/integration/test_reconnect.py @@ -2,7 +2,6 @@ import logging from asyncio import CancelledError from torba.testcase import IntegrationTestCase -from torba.client.constants import COIN class ReconnectTests(IntegrationTestCase): @@ -17,7 +16,7 @@ class ReconnectTests(IntegrationTestCase): await self.blockchain.generate(1) await self.on_transaction_id(sendtxid) # confirmed - self.assertEqual(round(await self.get_balance(self.account)/COIN, 4), 1.1337) + await self.assertBalance(self.account, '1.1337') # is it real? are we rich!? let me see this tx... d = self.ledger.network.get_transaction(sendtxid) # what's that smoke on my ethernet cable? oh no! From e5714dc1fca8052059bfa241f2ddbaf33686496c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 19 Nov 2018 18:04:07 -0500 Subject: [PATCH 238/383] test sync integration test and other fixes --- tests/client_tests/integration/test_sync.py | 97 +++++++++++++++++++++ tests/client_tests/unit/test_database.py | 9 ++ torba/client/baseaccount.py | 8 +- torba/client/basedatabase.py | 4 +- torba/client/baseledger.py | 16 ++++ 5 files changed, 130 insertions(+), 4 deletions(-) create mode 100644 tests/client_tests/integration/test_sync.py diff --git a/tests/client_tests/integration/test_sync.py b/tests/client_tests/integration/test_sync.py new file mode 100644 index 000000000..9ce75d917 --- /dev/null +++ b/tests/client_tests/integration/test_sync.py @@ -0,0 +1,97 @@ +import asyncio +import logging +from torba.testcase import IntegrationTestCase, WalletNode +from torba.client.constants import CENT + + +class SyncTests(IntegrationTestCase): + + VERBOSITY = logging.INFO + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.api_port = 5280 + self.started_nodes = [] + + async def asyncTearDown(self): + for node in self.started_nodes: + try: + await node.stop(cleanup=True) + except Exception as e: + print(e) + await super().asyncTearDown() + + async def make_wallet_node(self, seed=None): + self.api_port += 1 + wallet_node = WalletNode( + self.wallet_node.manager_class, + self.wallet_node.ledger_class, + api_port=self.api_port + ) + await wallet_node.start(seed) + self.started_nodes.append(wallet_node) + return wallet_node + + async def test_nodes_with_same_account_stay_in_sync(self): + # destination node/account for receiving TXs + node0 = await self.make_wallet_node() + account0 = node0.account + # main node/account creating TXs + node1 = self.wallet_node + account1 = self.wallet_node.account + # mirror node/account, expected to reflect everything in main node as it happens + node2 = await self.make_wallet_node(account1.seed) + account2 = node2.account + + self.assertNotEqual(account0.id, account1.id) + self.assertEqual(account1.id, account2.id) + await self.assertBalance(account0, '0.0') + await self.assertBalance(account1, '0.0') + await self.assertBalance(account2, '0.0') + self.assertEqual(await account0.get_address_count(chain=0), 20) + self.assertEqual(await account1.get_address_count(chain=0), 20) + self.assertEqual(await account2.get_address_count(chain=0), 20) + self.assertEqual(await account1.get_address_count(chain=1), 6) + self.assertEqual(await account2.get_address_count(chain=1), 6) + + # check that main node and mirror node generate 5 address to fill gap + fifth_address = (await account1.receiving.get_addresses())[4] + await self.blockchain.send_to_address(fifth_address, 1.00) + await asyncio.wait([ + account1.ledger.on_address.first, + account2.ledger.on_address.first + ]) + self.assertEqual(await account1.get_address_count(chain=0), 25) + self.assertEqual(await account2.get_address_count(chain=0), 25) + await self.assertBalance(account1, '1.0') + await self.assertBalance(account2, '1.0') + + await self.blockchain.generate(1) + + # pay 0.01 from main node to receiving node, would have increased change addresses + address0 = (await account0.receiving.get_addresses())[0] + hash0 = self.ledger.address_to_hash160(address0) + tx = await account1.ledger.transaction_class.create( + [], + [self.ledger.transaction_class.output_class.pay_pubkey_hash(CENT, hash0)], + [account1], account1 + ) + await self.broadcast(tx) + await asyncio.wait([ + account0.ledger.wait(tx), + account1.ledger.wait(tx), + account2.ledger.wait(tx), + ]) + self.assertEqual(await account0.get_address_count(chain=0), 21) + self.assertGreater(await account1.get_address_count(chain=1), 6) + self.assertGreater(await account2.get_address_count(chain=1), 6) + await self.assertBalance(account0, '0.01') + await self.assertBalance(account1, '0.989876') + await self.assertBalance(account2, '0.989876') + + await self.blockchain.generate(1) + + # create a new mirror node and see if it syncs to same balance from scratch + node3 = await self.make_wallet_node(account1.seed) + account3 = node3.account + await self.assertBalance(account3, '0.989876') diff --git a/tests/client_tests/unit/test_database.py b/tests/client_tests/unit/test_database.py index 374280d52..e9d873d77 100644 --- a/tests/client_tests/unit/test_database.py +++ b/tests/client_tests/unit/test_database.py @@ -238,3 +238,12 @@ class TestQueries(AsyncioTestCase): tx = await self.ledger.db.get_transaction(txid=tx2.id, account=account2) self.assertEqual(tx.inputs[0].is_my_account, False) self.assertEqual(tx.outputs[0].is_my_account, True) + + # height 0 sorted to the top with the rest in descending order + tx4 = await self.create_tx_from_nothing(account1, 0) + txos = await self.ledger.db.get_txos() + self.assertEqual([0, 2, 1], [txo.tx_ref.height for txo in txos]) + self.assertEqual([tx4.id, tx2.id, tx1.id], [txo.tx_ref.id for txo in txos]) + txs = await self.ledger.db.get_transactions() + self.assertEqual([0, 3, 2, 1], [tx.height for tx in txs]) + self.assertEqual([tx4.id, tx3.id, tx2.id, tx1.id], [tx.id for tx in txs]) diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index ad173f197..c3665111c 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -128,7 +128,7 @@ class HierarchicalDeterministic(AddressManager): start = addresses[0]['position']+1 if addresses else 0 end = start + (self.gap - existing_gap) new_keys = await self._generate_keys(start, end-1) - await self.account.ledger.subscribe_addresses(self, new_keys) + await self.account.ledger.announce_addresses(self, new_keys) return new_keys async def _generate_keys(self, start: int, end: int) -> List[str]: @@ -148,7 +148,9 @@ class HierarchicalDeterministic(AddressManager): def get_address_records(self, only_usable: bool = False, **constraints): if only_usable: constraints['used_times__lt'] = self.maximum_uses_per_address - return self._query_addresses(order_by="used_times ASC, position ASC", **constraints) + if 'order_by' not in constraints: + constraints['order_by'] = "used_times ASC, position ASC" + return self._query_addresses(**constraints) class SingleKey(AddressManager): @@ -181,7 +183,7 @@ class SingleKey(AddressManager): self.account, self.chain_number, [(0, self.public_key)] ) new_keys = [self.public_key.address] - await self.account.ledger.subscribe_addresses(self, new_keys) + await self.account.ledger.announce_addresses(self, new_keys) return new_keys return [] diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 824e1fa21..b6ead4aea 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -355,7 +355,7 @@ class BaseDatabase(SQLiteMixin): tx_rows = await self.select_transactions( 'txid, raw, height, position, is_verified', - order_by=["height DESC", "position DESC"], + order_by=["height=0 DESC", "height DESC", "position DESC"], **constraints ) @@ -422,6 +422,8 @@ class BaseDatabase(SQLiteMixin): my_account = my_account or constraints.get('account', None) if isinstance(my_account, BaseAccount): my_account = my_account.public_key.address + if 'order_by' not in constraints: + constraints['order_by'] = ["tx.height=0 DESC", "tx.height DESC", "tx.position DESC"] rows = await self.select_txos( "amount, script, txid, tx.height, txo.position, chain, account", **constraints ) diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index aec78034a..0cf147f52 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -44,6 +44,10 @@ class TransactionEvent(namedtuple('TransactionEvent', ('address', 'tx'))): pass +class AddressesGeneratedEvent(namedtuple('AddressesGeneratedEvent', ('address_manager', 'addresses'))): + pass + + class BlockHeightEvent(namedtuple('BlockHeightEvent', ('height', 'change'))): pass @@ -138,6 +142,12 @@ class BaseLedger(metaclass=LedgerRegistry): ) ) + self._on_address_controller = StreamController() + self.on_address = self._on_address_controller.stream + self.on_address.listen( + lambda e: log.info('(%s) on_address: %s', self.get_id(), e.addresses) + ) + self._on_header_controller = StreamController() self.on_header = self._on_header_controller.stream self.on_header.listen( @@ -350,6 +360,12 @@ class BaseLedger(metaclass=LedgerRegistry): await self.subscribe_addresses(address_manager, await address_manager.get_addresses()) await account.ensure_address_gap() + async def announce_addresses(self, address_manager: baseaccount.AddressManager, addresses: List[str]): + await self.subscribe_addresses(address_manager, addresses) + await self._on_address_controller.add( + AddressesGeneratedEvent(address_manager, addresses) + ) + async def subscribe_addresses(self, address_manager: baseaccount.AddressManager, addresses: List[str]): if self.network.is_connected and addresses: await asyncio.wait([ From ed880be3e5c5bee0f33c3404103a2e9822f98880 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 19 Nov 2018 19:27:07 -0500 Subject: [PATCH 239/383] 0.2.1 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index d26400441..8926851ad 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.2.0' +__version__ = '0.2.1' From 10c1f8e1cf99b89c70f895cf1a345f312464c5dc Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 20 Nov 2018 22:57:59 -0500 Subject: [PATCH 240/383] drop requirements: mock, requests. merge [server] into the main requirement section --- setup.py | 24 +++++++++--------------- tests/client_tests/unit/bitcoin_headers | Bin 2580800 -> 0 bytes torba/orchstr8/node.py | 9 ++++----- 3 files changed, 13 insertions(+), 20 deletions(-) delete mode 100644 tests/client_tests/unit/bitcoin_headers diff --git a/setup.py b/setup.py index 10567a3b1..de5d748d8 100644 --- a/setup.py +++ b/setup.py @@ -39,31 +39,25 @@ setup( 'aiorpcx==0.9.0', 'coincurve', 'pbkdf2', - 'cryptography' + 'cryptography', + 'attrs', + 'plyvel', + 'pylru' ), extras_require={ - 'test': ( - 'mock', - 'requests', - ), - 'server': ( - 'attrs', - 'plyvel', - 'pylru' - ), - 'ui': ( + 'gui': ( 'pyside2', ) }, entry_points={ 'console_scripts': [ 'torba-client=torba.client.cli:main', - 'torba-server=torba.server.cli:main [server]', - 'orchstr8=torba.orchstr8.cli:main [server]', + 'torba-server=torba.server.cli:main', + 'orchstr8=torba.orchstr8.cli:main', ], 'gui_scripts': [ - 'torba=torba.ui:main [ui]', - 'torba-workbench=torba.workbench:main [ui]', + 'torba=torba.ui:main [gui]', + 'torba-workbench=torba.workbench:main [gui]', ] } ) diff --git a/tests/client_tests/unit/bitcoin_headers b/tests/client_tests/unit/bitcoin_headers deleted file mode 100644 index 5cb342901aace97f1d3300ec88fc05b6a462d5f7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2580800 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 bnvDonVING%(2EzEdUSQa1W#8Xk80Vn4){Ds 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%0D+vDSeXRHUehX)P*hrKE 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�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%0D=820Y>G;yK%nKU(M=Q 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�X2LE;K9F4wNe`=N91;}%HludxJ@Zp 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

E*CyKLWR7WWNi3}o`*s~ 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Ξ_tp~flw3^Vu>OLu}u?xhIi>1k7g( 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 z

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%0Ac(CQ=SHupuN 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

s@*@Y>AVie_joPzOxh-# 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 z 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 hakIyzqg#ezh zc`xTmf$t%%POA_TMgaofmqV1E?Y=dGt<}@0zk6vcK9Gk%^idh8-$=oZrkM?r%xSxs zwbuqcPEGWyYy^~z1r|DKKLGEGYQiFg?S0Y`)3ak6NoTe)B8@j+{@lJ6{ZeKX{hLKH z!yocy2I9c+ytEU=(y8m0t4E~49F~FGS39;eyc)vA!U7Ur@Vu06rICrMJAZckWFT*A z|5Gc?RxNrRFI>kLE0O!RLl;ZffsjY6kGT)T_fDiv;EnIxIG0xyLv%KetNt&>rvOvQ z!TqbN4j?{Mk^vpeZa5hX_Qhu*`vr81A>Ildje)BxaBxZ)s5wD~k&s8A^o9-aF5q|> zncvUuS5oS?ai1Vi2ni6MG(@W}2C$210bbiNcGsIW_K&z?o^1#mPU(uag$Je!xdhe; z=>cawHQ~rHkk^DK3EtOG-`t((oW5Hf@Sm~L;Nm?bK$9w0K7=FKLif)ByvyQuGLp=3 ze>@^83`{qlxc+@R!QiiHwC9~wF)SXG44)KL4Nay@tV6VcU?wui@7HQm5%Z*dCorR3#~<=pg;l=*+j@Ag0)Hp z$~zSQL~qdme~s(>G)fnaN#B-pnQbfx|MM6hlNyN6&nu%Gro@v}^{wF1wvybRCWJ5# z)JZ2P?MY=ts*v@tjugm?iHauxy!xuCgAziVXN;VgSG>5=dWMJ{Z_0^enz6_Jf%`q_ zFXilI{?J<~K5YeUIn|c`d*|X`WiP{{uldny9F^~kJs0v|9e8^IPlDjYJ8o>Q{__%R zl23FHZgT0bv*@|SfSA;oH$Z&5YYF>@DIXD(DR67g`z#hrl@Ns^3X&4g1H_)WIxN$E zuKa&_$ta5fuWBiLy`lT%`_1c6U4fSuClX#xAGNo5baYW8$^p-~UU%N2$@aprbdT1r z+exoC5>~Rpit=>%=7wwQFJ&QBE##@wlz{tGbx4>kpYt){q+4+lW``4qkboR&XgK*3>@DtpT%wnMFW+Qr!Z$j zvrMZ6+-C7US0#TrhyU+s)Pv)BJa6w@Kk{Oy;k8?aHb!IWCw-*`=EtRBDaF(0fG2Jh zjcX8ar|$w&q-Wcgf>X}fIjSki$Y7_|G2*j@;_o{OdFA4<;QWfrI$cn%345^d*X?HM zp*O}+L-Rie*de~+^TH~?8zm|T8dnK*&_*^FE@a}X7sMl`F-iaQt8iUb`))IHDfbuT zq3|E80OjQzeNK*GoZ_Dv(GT;)Jyt50{`=;eXre@0ANqH|8+PFz_NTDQo&P@ZT5FxG zzGF(%CmDh1%Py$|CeBR^4$Bzi#iIm(>kr11Su>^d5;QF7&)pHDigs)Gd2CUvqc<$! z@!)<>mb2`1@IntZ?2tL)sqpROd=BzA8ax&BxchpVnt^hw)^W%)%K8lUFJZgNsSd=e zNmgqf=^F2UCgD?&v1Pw7=6pBW1il}$o^c}Zw1s?vsOC;e-bGJx1xu zx)i#yOhF#O3ny?qCkw*U?VXreXd=x*lhQ#xQ?q7?iyVAzwjjLn9w=`h#hUF4Y)0xXQGDXCcon=M=18 z*@{in?hb#RKYE{DqwY%SvGKp=+kQ`PZCe-%=3nB@W}ZKwa971VsO1;cNyIAS&3LJL zWiz9GD{sV-QTpUE4|xa?*GEA8ewOw)ev`<2E>L9`Q$u+C)J;1gnf*Sy%HYu!EN>nz z+(Hq#f;7_;?cZU)Rzg4o*J&TF_g0eCKn zv6IaoMhdEP#``eb@CY)*5pjZF9BWj|3wEIRYN!;z_FNw?q>gWiPMZXmh4ov=-%V8Z zk)^7VuV?428#Cas9On!PB)>h*`jLFcow057!s;j5IRSfhJZs$9k%>){*DmCd7`uS^ zb~Q6|nBdY*@p^od_rG*meQV5>Q(?mxl9>lpW&m$~N%8KjsAdESZ!bki=wrOq))U2= za#i76h2a6W`d3(;W5{!zss`^zb%*U^hMANc)xu=dOKqj$^KF&LN0tT!U>fwQ0bUwk z0C#8rhalxu|KR)3W1c@l3BJ?@hVcrdg35jps)+lB zFB6K2s7s{&Skqnq@qD2?3wWtKdmG=eLr9EneweaKy04A|vtSw)7epqaAwR_HQ~Wx* zgFHf3_HMvKo3ka7rS4WL^}3tcKirG5?N&1<^N{&(MU&eCc$q}waZQ4z*S$xtaVv`Z zoVP5cr!Bo@=#pHeO3Eo2UM(X%g85F;Kgr;H4es5mrDpM~k0)P=$B^{cbJDsoXq#JkRKSxA!&`CINW}JWnn4Kx|i#i#T^$7(vC$6Uuv(SrPLaLASGS z8&L~EIJt5B8RWr-Nr2-K2f|tyj_1vM>6O`eS)CklfO(c0UKFOOH;FfR-b_V2IRsy_ z0;`Pk5s|`lYyRwHlvFTvegb11@m+;+Sfc<52jMiwhuOo6-~x2;s%H!Fi%MK`h->RgwVk zytqE$Imi)?#LLn3*&??xU~<3`QLvS;iF156pS81CFeHII60?dasMg3v5qpo2lTEe^O zROQ}G=C9diMqPS2Lt%Qs=Odx{2EpXJdB#5&{D1+;_>+b{ z?QqAMO`yCny2h^lEICtZN|lw5^~-;@2-nK(7p)fpjF_(Zn5)Q2DIgEkL{$+eZ>TrX zJOTa&`Dcmv%surx1A_gD53APOpDo3H`~^IVt9oKv1M}0oJ963_@|N|8#QWk8ovtuu zVMOV>uQZW@X&{f_^4E93%gAMmu?argQB}G}&s4@V-MY#mmA%>t8_iw>^H-=`DbL@z z!*ht54Y&*uN^1M||o};K1ZL2q?KclUEUG?*Av9KU0{#tG&O>4S6c- z58(U8vw)J+`swMb#A$#t`|LYW?ONg~eU##fv8zJxeRCf){z%AM$?PN^#?*#*=bjdq zS1}bIr1+rC;8$hLGUmnyd3^oFIIL z-HOvT!z3}Vt2sS!AW?hvVG(!FvPcHt9yo5x*S2`X-Yq9p)m^dWJOYTuVIR zl%rju{!1Xfg*)=c>W$JW{v-o*!lHlniH69rh&PMyTpB2^W@3%9zbZjq)0Gq*5Z?lp z!%?tA!L@YS<<47?8uqa#QPhh;p7wr&M{xZXbaP~yydWF%+XmGfA-~d_@9N6DyX(m_ zVnVeC{m-N)sW#-r@*#uY2mUxz(BLTD?+o9jWYRx_y+80+1m}Cvpn=Fc11@& z`Tk>^c1Xz@Lg7y&!UoDqTHt9|og2X!`NouFP~_zd*WkF()^I+??Cf)-Oe6bQ^tX_g z)anHGf3i1Iay(ZQS7T>2}bL`VKRJdd;w2O3r=yT+0C6)pS`1TAX$dw z-9Cl--~r)SzC?SW2Q^oV9^`q}uYvQ^Yh$LyYm?S7hOXnv16|5z9BB0Y@PahM@n@;v zeC@Qgm4b18u%HQb1s=8wD;-7lOXI!nk8UILZ^naHpN66>A&*OSb%I055Gx>J!db73>$K zm7lsd_PejPnjbjIh8cyrdYC>=9^YO&LSAt11lZrNTM!YDembYOZTV!eZc=jEE`L+@ zFM0>l#K{5+@NivZ3kcVv>RM5QX$kk7jq*u?xi?;3=4I&Z1{C8XbIgB)Ji%mXaQ$(j zVCsu|_TP^@56dyJcRg#_N|{-XrVqb*u(|ICyyuBMF#lueuH(99;y8fQ-QB5#bcuv? zH-gegcSx6jNOyOa2nYz$-JJr`(v5(Ggv9e~(|>)v-h6KN+wFGu-8NUqh{i|5X+R)B z+Vt`jn~+l9%hxOHP16LM$e&DHAkUMF8JwRci!Dsj2d*H+!{>`+;@L(QX~56Dt2z1G z3{!dtcq}+kzdoLpM*c9i`2TC~T2ksILP@{c^9#>9kd3)+y(9zvd9VWCTY>&?WKhzU zsm-?{rfiVobFO?LVEcwxpbNE%s<*WV@c!<*;CavwO#8opdHCTPhZZl?C5}vtnrHML zbv3>Cnd_k|lrPO&3mpFlRvJ_8mi447B&rngZw4G?pVagXnKaSkB#K%Co=ClMw+&@n zLrO$_WHhP-r8betNKWq(9;M8ECc85o+nF2Wg}iwV{+>(ZT?-ryKK5v9VajgveTwee zK`~w_-ZE#^;SvM9Mhvet3gT0&F|;_i@O!jYrrTXJyWMxYX^cqH?z3`mrXL{>VSc9z zXfOOjioUMW{e!Z6dqa4N-sbdnj&$qci%b#h8+pKMK8H@KS9A4mLXDVh><(%x^EKqN^au0VwF{fD?hR`(E#3@ zww~})7M{oJoSzrtoum5-HHUMI?qA1-GuwL-?xeFF!XXc?Kpd{<9LLPpE?gnuDniBt@Utql88Gvi0uH_bR3*=nGm{ z-Vd3Mw{&vFkQX*-3BG^r>KQNnpq%w|uH*6j+a&O2x)mOd8%Ocj;1I>_E_X-1?PwLu=JxWmCjL!+L zD{;y1R}gjn?v5hXye8Y72J7WTRFgvRxOjwTkK?a=FG{UNfg9lXS=LJ=VPq>)2N#XW#uZGKe%~P-X7hx9!tYg3CmA|#hA?%~}Lf+x4e6T+IiG>xb z8(Gf%>1cr2s-JO7jN@U~imLUB>i^H>0^WzpS2IS2s?|}X(Mx!YZCIuXbJ7=yW)v1r zD_A6VIutGkAg|i{0o*UE-5WGpz8}hLKeON8fB4?UZ`3srh=S&r`*J@N@I+qelwtPQ z{o+sDvR7qGnt>0oe$_KGzV9L?OS4aPIzc@Id74ez;P|&d(b2VYFu7!T^})7pUExEG z=+gz4sOI{ZJsq%KfTz(dub##(XXia_0Rx*6Px{z1Sw1+Jt0~u_AQ3E=8Tv8EBR%y5 z=aX|E2$85S$qQa!p%T$c_eLL5#>)GpOn6#ruY>hw6LuIrj*6s3M5=}wb@VIb;=RgY zbLOe|SyG>cwceF%(@#R4t|BqGUW`#EiAr|?DD5M{ppQ>0IpAdNjWZ{sfnz(9OvDV2vVr!vHp-(R493iK2*M%z}(zc|Rist(Jl0AA2R*@UX$86uGwlKRdN8vg4 z$B-6I$$mnLZN@A-QFx+@E>@)OOZ`6&ak@DS@C*~r8c*S+(JA`3joHK}?IZ#ZN01R| zua0A|H~`PQxZZH*$m@FkEBfKX>Qzob=C@~Zo7_i!UYA~Br~;n8mr3=E=T=VvoEH4YuN7wZc;Qkh&u5zH zipD7`e&6h(Z9pFK96dN5;MIN)TXI!R=BM0zMs^&5*aj0jhON$nx}C{<40z?NG43xB zbVx6!OI*w7thWu&&PXh+)=E9=Qw=gS1+3Dx|Mkb&L=Mp25}cT7%(}qa^?8IT#h(QH z!4|Z^?o49uMdNCx0nf_t1U1=!Qt%@xbC~*DS5`;DrZC$2NV839KU$umKkKDCkeAqN z3$Fit|N8T(&DVTRewT$AF0#R*4n~4e zB8Le@%3*4dP{0>eSNe(7U0m?^5u2nk^h8J?sahJp{hI&c96=vZJd^hB>I=yuA8||x zTK6x=Bde4Y2996fub#|h`O}X6jh=LJo}K)?(Z$+hLf*sBgp%-TpMTYNxU8)kDSk>8t^QV z9hPMtvK*0dTV>^(oG!n!=T%6 zZ*<85tcPpP6*P19U`7nFiZm*#POL|vjqlC179tO2v%3e{Tlb+_MVD$3tEH;thvRWu zOIbZnqFRdR1nvs``bEXPv*`aXqy)ZKNq*)DuE##Aw6iHS7g3dae;8V;IIdL673NZd zLnLUak^`?tr@Gssg@@KQ-Dg%63Qj(C_vBVHjPKU7Vb`1`3Q|ief1yC$CaMy+zuI!+ z>>oazWpmHx8I}c`;Yy+*PCjocG=njT0j?+7?^J#NqMhoH<#AQk#1v$0vUth%16N7u zn)&<_tIor^A|~X)HjRVV%l4boJ3R`OuI6cH)3OqAybznPfs-=PU=&jibD+I%E~9!I z9CVMxP5WQ0zAe#gxmuo+?`Q_I#`zCtwlDu-r zjby>>kV!$_*tcW{Tz_8s*>{w@iGZ;KQ^^)5uwj8*T>|^zG&cP$&;C1h-#<1nM3Cpz z0t2>}oT$9WX~$Ff;RC&Iq1 z#ouM?4)z|nZ(j6iJKDDqL*7KwXYhJS*^yjjGCt#reoC04av~t%W1Gv(>fn+<-cU#<*uOET;k$h7^(Tn& z=6}tS+}Y7-?;ZxED`T^&jAyP!=RzKoSS*y)WkjQi8G zg%6K%cm9C)5k<#|>js{_5lYBtY^_=6d%`kk92pvi6^+?@9umAD%@I zhk~Y$$E!4|Q623F(%x$`U#p0&h<>0MWdWY|Nn-uzdBVw!E}jsKHpxYn-IB~wu)0c! zUgugreoOGTCs4km9ddG@z4E(RXEmASGgASfOH`R~gxFt2FWN(Rr+1X5!SRo({@g-& zqCZ50*?vTvl_WXJt1b)uwcy3WbrK=X=m17B1LToEkIDeN8fTKl5^cR>ZO=Y3EIpfc z8;*LBrDI-rr!n8}Kt2Z3ZPf(vtKkwX_*Z0`oJYqRZcgMM4{1^0;#b1)y$nVKAy1Nt z9o)Z6_fcA$#!A&Wyoe&Yqj>+$6U8dr9(VEQukJ$?z(cv5H}Su9W%OqoNGzZ%fWLA< z+Z0apF3pYwP7zMm%qd89m~-atM~`w2U=-LBZTwpDaK=A7t4@=v-3r#_%toov1W zyxCjFUr{PHr>QR`iyo8v12|g;kSn*aB2|lUL%j@&304&TwYQ-PTp!{TWrI=rR(~dl z@S|VZA^UE`MYy24SX3=|cIYkO`7)f3G{eWT9%Amsq3Z7Hinw#mHdDw;fRHQTwTH4_yJDR zk^jxui;YaWaqNrT*r2a=u?x(vtN(chjFjN{;jGp~^H5fWq&v{voDjVm%4>frJ8qP? z$FFaI40sjQWwr7sY4s|nhp$rX_rD*0HN3Y%QmfvJtU}*j?Vp*^f%4U^^nl~N0(l3r zxxvtZi{+5NdDK7`@`Pb?!1>VV)%TdJXr^g2z4EinZSVJDobuwB81Ir`m$txq@7;`Dd^w!( zQ9kbjH-E3{JU#em&!tk7>yc5FaxKT4aCbAvBNX4+0s7a`>ptS^gA*-n&R_nhsZy6U z+^y_eB3Jo%@msJy@sx5;lPU1)q8m!nTtZ5FuKkZG9fQ}=TU*~|v_Ef=QN6c>JX*_a z@cf-D*8P@m!5FObAktVi$;;%H?j*lSrHexN+anG*e)Dj}x#F97?iNP#3g-3ASi%@t zubA*Mzny&lsg6fF&C>hN%T}WY`{QSJ+nN<=K?hSu*#qp?=tk$J%$bG)&HLYfOTm2n zSZqg+nN7lBcuU`0d_x3!9$d#uTS56Kgk`|_mEhWIZNr1wca@w< zX8J)V;T_q#|GWdjR=JGqlX)aQkBNj&KmDy-hBP)_}A6e=OXn-fAM2<`{$R4UWG4uaE z$p25Hm!9_~w3&GOe#aP;S%I7RVGDVv?`Woh{wSugv5zOex06_EGm7AOCJH+``@@G= zLLaGNWe@OP8F87jwo2LRImDm`f7z*hV*O|OgW(zh$(OR4rSup5B+ig`TZ%vrc)whQ zf1N2QEh2C;J?1B0#Gn1({kp%jq3e$I1$^GVaHTj&bm==u06CA(Sd_Zf{=UUsvHvtO z{|-!y)P*f{LNgRYEk@5pZXM}d4H<(qlO znEd5YSB=54&$ZLWkS5nPx7tk!E8f6wJdt~g?FM;|0UyBqH;0!KSR09LF@2M`ubpKm zOrN^Eg;NQITO!)q1^3^c)Z3c*pM2TThq>tI_KWzafb{=&k3OBjQ9bx>swWIa$ zya)6?L3u9nHt%1N)spJ#DA-O+nvKXJ;z9oOp9>UkHi3Mx<0`1H=j|dCz$?Pcfm$k)UFs zaKL+%$5cHho;Pk)X%TenX0%!GGQJgzIjuvW65pc0e2H4;3wabKw-G>pV3V3pA$;md zdzsOI`+zgbUPUJDF+h`s(HSM53wXxAmW5PwT^X4Y1@j(mu|_Q_ym;05KGU}-$jo7s z#CT2p^Y||1!Rs4B@3+jN(b4{)$dQ*KWzs>8iWgNwrTN>}8vlQ`@&A8{JPK9X1Z6Bg zj1mRc5^-5%I`VR*b;x~JHTuvIWo+tu{r?@mGmlarpO#C-fw1kb->wALPRfKc=7W|a za+&L!)5w0Ve1ON7zK!a(wTo_!?j%(``T9kAs{?g6Zg|L8mwXUj(;eE*2guV>O#y!| zUaq?WRJRf^lET&$H&T;)i^Z@yaOlVg;UE8`16~@#ej(diSr|Jq{Pg3uLp4trf=O?* zEfm9S>24=8(>mimLY@KoD!Bekr!!*}CQ133eHD|?d+PHcv(gBk0&m|0_m&YV;JuoD zGyVw={(jeZnq_DK%W3^KgzcHko!LWyiux`=4?K4i3DIQkvhMGM~^nB#y!oJSlKv60)x}z2`Z|7$qv)wf78MGad?f&`u=33qequI_{L%( zp9@{nQOzQ!N?zH1k3_t-!MtS1BhmcOBPtyT<7-UO zX$02uk4JnCcl-#Sxq6W9e86boofep@MVDj++cErf<;Q6Y%}$y%%O(T9Y$aM(Zh^H>=t65y=6f8eU0%T3dRf zHg(D!xU(UzU|kCA-xlJLvq;Q7`WROE7ibNyf1LkZJigC}3Q9~<(*pWqE3bBrn0-QP z<~PQ(wb#{^8F~VCi!@cwqYa3VetYz8)&KK!m@>fYo2(98ddCp6HCp`A;guU|fNOg8 zu8DK{55vsrV!)$)K>iu!e$d3RAF#F%Nue&lgx_yz_jwJ`yy=_70nw;X4wMgn_ABUh zGg_Vw@8iTzl{;N$G$`rgzC1pAEuhTQc99F#>t#1aVztxtnH-eX4I6vWr|wq=>%TdB zQYG`#is$T_y$r1Y@>E{%f%WZhyDh|R7_M@-`E^6RzAkVdcn&T{-*nC<38;YcKWqCL zoJEHiG*I3j=8HE~7Gj#Ot60q?aZ^&&Ho%&U@4CQf816jGd^|iKQaHRw;z? zkvnWl0l&YSv{FvVT{Fzds#xy$#?7bNL_w^m6z=%U*TJ}e7x^vyLL`u|pZiT!-TANF zlo}k3rj$d!u-G`B08dkRhVVMbL%?8}1w8ET&D}UWn$?o_vGyzzE7!cEwl2IAu1N#J zI8ne$9#rMQSaBzRp4ra6@ADCMlBQ8p#++CTgY?usXGa%y@Slh4-VKgd@?Q`Wr{l^8 zIr?~?{=&dx8-Kfv_&SDRH{a;y3h;WF%zN`1;(}+tu}`eev%oa0tEkOz!CkAIdHTYZ zbZ9)ZLiwsck$~$PvRs5XEKw)Mh%3^>>_{`sW75^clz+cVz7F;-0=$RJ7sSSWBm}5F zzY1zX^Br$spZ5L9Q~QCUcO$Qx(J&~~33lZlyd2l)I2|#~{u^_2m2sKlQZ*JHu@Fys8?ANm6s4^@hc)SDWS1yRh z4qH9g`;VvPdP}oG_a@D>b&gN##?iFbintZ`Diy~dPo=^eJbs-E{gZ?twviuLv=KiM zo~_#d?BK_wiuGSJ76#{&W#e^=ezn}e>(aYkd0x!0hZ!xso=A@f@6YP8OR?|G08C5+zw7@TdI!)Fr8Hx0Uqax9f5d zuwGB%{Z;A{Lx+Jl+&|Ce(@Lb3jbARvrxSM{!<8GZX14A;oA`J9ie6;`$FJLhnYoqe z<;goOEp--BT&AV|l4pEH+ZF}^GKxUH+Ujmee&KlQ>i0<%lc%vIwfCWN+qy|YP1V;m zAGe$407RmVW7gqlKHI-^wZ{VMjN?vfHUGFm8(0=X{b-MyDzA05z2 zs+#slQ@m5oUZp=ywuP0td9A6NX*cuDy(X>x4cfS%*Z^NC&|bn( zorutkf^F@u0_gJFmi7vmCGp$XC`3M;Ur^V!L_BRbAP*%Lj~&Q|TudDEe0cN8cS&{S zQ5pQP>#jH?nAG+x#=qk>fETqHoY#?CGWHUE5<}9OM`s& zAP?SXgck7Pi_1%v52J&W{Gxtgi4FHTJ98P37xh>c{r#K+c)Nr9uS*QDaFV_)vz3Q- zv@I&$iwK44kLMWGaVB3j*A5;*o{Ur|xSy9-zwzO@v47Jtixu5c%G9I>d6IGNl45CY zBbhniJ*Plo)JUomxaFk`B^GLoRC@2ukCDG>ORbVBC9X$cP;m@-O@2P$ezHVoaWzsY zx3W+3crd4cFzkMec7j`HOl(p+t`p#~)w^3S{FJ_OIVG3BQ+WJwV_p9@6=$#~5EwDiRJ#(#E1o5m;w>$!ey6qhnc>Y9gH z&O5(MMw&q4Bwl?OfQer|^}g|?sCIVy4dv7Dc>&JHgZ}>vTs;nlknJP+nPWvLvO7wZ zgiX%0LL-k0xc|YZ*`;oxBPtOfc_Avc;g47t!7jb6G1xF3Sl1K{i;q8i0eQ&fokc)@ zP#k$65F^K(^dl2C97MVNb*@AHii61?Yk-n;0JOI*KIDgq{j<`ZG%^9;d=Y?(49D8Co#{R@UF_d{e9Hl4^>(yS)0C=#9 zBg?wio_m2q_c~clZiI!z*UU}ruRq-HE9%=hc9miMg}gt$;^6Vat0^~qh;<=ZeYt0G zlBSRK-Zj+3l6+FxBwR=z@T>#K7-1#CBKLZot45SQd=o-gF)7UybE@lH671)}(44r3 zJV6a*aDKq`qn+3Ob!?`_XdTvWN>0`9P)}A?xI(OHak+PZx9)Qu&dT7wVy+Na+rpXF z*gfm=M3&D`H{4wM)aw3)yY3_88F6BQ{Q*NAbXlm5I&GXJSD{7AkXiisk;3@1&JH6z z8w=oNRVLou2B8LIJJ9-8xs7Y?H%TFldnkGQkSY1iIA}C&hzO$ytnYfs>VW6Rc7+M= z<{i0q^V=ea(Nf*3r9!&)g5s5Zm^mkLHqOZ5b-Ux|Nb*s@oq7c99_wezR`;qkjG%| z51wyaZ=1{&Ph-RpGqoz1`BX~G2&}S@mIv7j!#lxx0fa$B-)31he+>6eF>&K}uD3=F zwa@nATgAuF`FgXvDgOWJ5_tTUBP6MS_BxgQ4aOT*HP_D3NHr<;e&)&;ILLYU*Fv_d zTpY;vkQ3lMdYE_i0YOMg;t8rzL0%7|+cr%0J1&vI+U!1eYhuVtxf2KX^XLw=SVR6i z%Oif$gFRQyo>=z@P7S3Y?l+3W0azdQW9A)7O%38r;Yx+_Z}kmRENvbjg^P6uy=`~b-1}^8m=mMzkid4_n9F8 zx88(C>xrU#$M=*3!&Ep|^Fmj&j_9X)0)cSkkVkan4DQc_UJhh&&H9cs+_;q8)sNdF znK_A|3wL?B9VHL|?Nyjyq6pM;ncDN_zF1blxg{7X$Scr* z1N&E57)1&nXSX)78jmI2?j>RAxEZapCmY*q#-1|3Ya`5nn>B^oLNJ~G{pc_rU6YoG zc;-Ia+Lz3%d?0B^&hyW^$H)ZFUoSCKxK*|MrAR?{Yq|>9#{sdkr{4RfEb1Y#;CN4i zJ-Kvp+W1N3uN@QoKn?3?5u)u`Z$=b}nb2WCy)9oEHI#2pJRiKjguS@cyO)QNJ$Eox zMsNG#f46ZytrJzna!-L10OXrxr#~%A=zT%E>#DHqxxX0U6sf+J+w-<|4P}OCG|(-D z2J$$+pMd>Q*L^A9=kp$x&GBYu+KD*b?+*XMWNTsW)BfNmz+-A$%s1Q`vdH5<6qmQd zVa2~&bg3_6s$ZYMo@eC0-= z7}(%fE2$f*OFdDkV(V6T8JBs~PECL(K;I;O3`hCtx2pG7O@+m?FU1UQ_#tRaP5szP zdHpt}@eGhhL`?D#`2BU(q8o+#H?M~^o~Xb+qP5A3lCzSDe2<#-z5vH(^}BM1(Nk{{ z{<>FmLSnw2Of!Mj1y`kJx?|m2e$0^f2dfLL-!LY^DP552sl!(%eiYpskz}Ar z<1(K7R<5>(ECS>kY5I{hf?zV+adFW%-fYmM9@*Y9TdbPOc){8FROcyQ9~a~yQP$}I z`GkaH&414M&hhoQKH0{py1N$pv=Xqf+06|{1nx)qXp@$tdCHF%BK-earjy=BjPrL6 zG1SR#T^r|z+ZYQF+@C|}P2z`W1=YJ<|BLGq^w4 zKvp-?^j@)UIiB;8e4fIG=i{i~{g@XX!YXD{1Y^aWsu1M0CmMs}fk;lPm2iKisxmLf zwN#S%OKKtwcbr8Qlb@mcVnBPV%PbHhJVa>(P+CH&qGY)jRM^RFb{HtbsV6g^Pp!|j zNkATX8)^X1UJ(gGk2s-E=m&pMDXNuoyp9sc9vKhUuQ4pv!TUFDM9=K@DX-YhY)Sr0 zf?&;Qt9?4=vVp$W1StK58Wdt)QvW|xwcaC#V4 zXiyph@;!6ei}HMskt4KTHxpeUy;3d{GI6BilA88cT?jCYG@O%$yfOGA@cEwa{!PDL z$SH*wWAyVJSr-{#PyQ&5AwQ74Xn4s6cpp`qqR3?LcJY6iuQp@Cspbs-5wbZN4_&Wm z!^B(jC0YLG4J6coJHYi=+dnnI0aC2rTQ-XS4BgECIAagG+;Uikl?-?lB$)CFHtnAW%UQ(; zcu888;z{+R`GIeI@uE+X0^|#u9lV@1bXUZ`gY$#GTT8*^qb*KpY&T60YA-113|xJ^ zRxgl>jO}6OiLZ!jG@*RIw~}4}o>QOd4lD)>9Tl?TcT)PH3+_9Y^gW~kx)Vhj>i_>6 zrYNu{EM*h*1{bB`9}!4oDJ0Uq}%1NHM2)cd13 zFZa$>BE?{7`mlZfrU&<)CxL*6Ff4nHKR8VF_Y2In`z_%%#mbss=IZTP4vAxSy*~C> zwGre=TuyNSUQ3r9`!DP7YG26NvTQZWPx9Y$aoUep{vMn81ir7ODI(Ppk;U1D*6WTJ z=bA@uVaVHX;% z6Z2zvw(+r$Z^rsqL;#fQf3qX63lN^p|BLmkIlasvR+=pEyHruIZeG0ur zDst+PPsENjtRRnULscJWFFvn<0)b}VsZT_vNif|j@=r!p1MAU~!@O8`RDhQ>i>`pi zjFoUrkjr{0ZpqNE@%5{Bt<>`rK?3Q3$M}vAJIK31nFjY8w_MoxQuV_>A9W6LN0#(` zC(=0@?t6EAN14y#1$Z)1AK?f(+B;Hbsl_pt(tq?nqiH)RML>)07^fIQlk zYH)x0IIu83>!fPJ?&X!AufwT0w*Qm4;z7y9L=86Z{#=$2239+Gu-TcbGNW1S!;(*G zvc^@-Q}Oa9W2)d%g#kiG$RlY83I^KSs0tq{lr=$^DHwhB=ofvi_+5>jaAS2hhw;G@ z$d_e2k>*pI)2Bd_Z?&|D>_cA^DgJV4c3{h_TqEFeaPHO(@+dmP766aSC;sfkg}>~3 zI9DDw;_8>nqL*SDPj`sMg>Q+GxA-ba)t=6#P26ldpR^WtNk2kn4Yg%(5cqJ~G*>$X4X;gm;QesD-GX(-KD;xGx=`xhFX1wpvpY~EbbdQ0LEf;LJ$S!A#H-ZbZzkJn?Ml$t*d2bFBS(xv7Uosq_Ev5xvnvAKMVzw&BLNODu##-l`hjf_xQNRB5R}^qO&Huulj9G#B|L4rSgyG%kE$1@XZNOr=jfuE<4|tYlz4~hyti(Mv^AjB> zFu3Y_-aOrLGPZ#s>t08TI8=TAJd6n>aJ|@?E!{+5Av>uzu}*K(RL;gLO4Lxfa>@?((*;QIaOtYXzYWPUvo=Jv6T9XQ{V{?c%d>VVe|e4N#i4;-9C z#v{imu$B6hUuVax41H%A;R&y@P4{s-gG(Tftsx6spY$EUiS2sOf~hQ$s_N$;aj>S~ z66^gtAd;WgGX>;3#QZ#%8JCcFyO;6eaB%+S^#>Rh#-*Iz9cxeH|83yGLd^!4taH0~p(+sw-!&)@gG{&<{R%MeGoAOPC~hX=DPP@{;72j_;p3VI`&?Fw*9O zHfwWWU%?*mU4EmN(n&w>>0dd+B41p2bnxz2@+u>Cf+Uf6#S7-U<32@cuVZnnbGxZ@s9GItA{H zb|bNp!gKDMp-kbpz~5bf=l(R7utsRkxr`Q5fNQ~WkPSKMpd;Do!_Su%{vIa}eIUdL!XX`??d&Zt+T9PyQFCY7s0E zLoJYRH*(6{a`zUmPzTRafqSEJCoezBX{y~&%D>oC zC(VDeu|Y%ayOr6`j_}K8L62g4Z_A4^CZT+k71yBG>1S8fkww1J=B@KG3ZM8>S!5?A z?)h`1+4w*(pG&)${K9^YL}Qh(P)SN5T4cnqln9gHdL1ndrgbMgKKl>ILkQk81^Ppq zXM9Cn`B}#KI9N0Klbo!SIpB@Gk(u5k{8ks*+wXt%l9jjTLiyB%zJNSlWB=UUyQ)9>C*x0bd6Cq!d0z)sUbnvc#S0H-p}0P8JL zdlb$#Gg8uOUau*IE{%KRM? zL+7)Cp9Ok`xWBLQ5#v_GiZ5q7;kW;Jh4r zw<)@}vl?*xsA6gEn&~Wh7PmjmGPn~KS*fBn@h?k0pp-G4KD*K;T zvR%8p8D|F098qDUc7oU^akmXIuG|*0V{9^)R84 zgVp+q`Ny|4X$_k>B8y9TGv?lEE;-6iJ5BDd@~YsU#}>>2UXRSEUKec~eI%f8 z^V6@fzs#**85zngeeJuL6%Ou4MfOcr$ZkHef4-=pK{Y)dU>E-xA&N?pQ?Tu~w!X+g zJ#Yu*8_S*m=YJhA!OutzDN-LTxIQoTCllnJoAL}#@3K{$V~_*+hE0j7d%u0jE>M&j z8J1>l-C(~*I8^YqI?GAwkDfZuyn%;>_A44A!25l}HzgW%Wlc#}3D*~6z8cPNL%RuT zG#}s;UAn>fsj$y$>vcF7m(*b5KLH2^SE7I6kuEE5u_To`Y!~tPa~KgIkCM9@9ACD& zLb0d6F&d4DU3n;ky%{eX01Zd3HL| z=ArDmK9%hG^b2-PWA36_EDW}8u>7nl1hL=^t|KnwkzR(>0N&R^i=>f>$Mu&UOr{4S zHX`-?N)eysLcd!ZOa}lSUeX|QiY9JfCVYueFm{M-f$zB()%YLzDgPjPn38^XYa+<= z-JS)X$4S^La_=Rste|gt<Z8RYi3i{*VKyjw^yd-V#fBl|9ay{B zD>+tuKRR4sSmRV?C0!|%CWkzvH_c$Ztzm^YQ?CQIN%B>HV+@5c?5F31eYWO7GtMiq zlz^vS@LDzR*uzLce9KP-UoM2j@9H$9@ktr6ZFQ4O&gF+PYRIExI|k3+W0~alA`Z{k z?<2%hKDen&iZGE4CuHwoG`JNo0$!ru8fIG?=@VyDnKJ$IWQC6tIAm}1f~n`(Yd&e( zBow}(fjm*=3GnyKAv50K`!}P2@u6zw=`Qxmsx?Een#z+1RUUNkd|O{E`&!cG#9=>s zgp#j_za|&>Qe)CnlPh64HUv-3e#Mj)@`(Bc5P<$*x&0gL+SrX!)_pFxw~WM+hx%?t z@0_PQgGdb?$amUK!e8QHEn}98=&%O2{@k_MOJs~wpG5mR=><{HZ~1OI$gBSU{ULyN z=qaq+D6nwB8lY++$FJwNL-^>$;+ctYjeWKOc$@~&QoB}{lMWRA&58GwYWSBz!$UsL zC%=@T<3IN^d(rp=@={lM!1axjeJbaV7iejl1I_Ci1y6#8YHcKy7ku4k41E9&re@o2 zd+J?h`Jt`Ga#jlNdg{Q(*aKgY^5x$zXyY*jDiohVUe%i!aJ}Hd+*6)Su^h9xa>eXrBKdNdZ z>lkSF)V>XnE1BLp4Qv>I{a+&FIwYo{1!C zSm<0;5b|h`e8KTbJ(QXo@pR1oD1<&=#pwLcN}sUlr^7hP0+D5KzG2$#OSs3$^ri4O zpPNC1OFgFi4V_htm!xbc^KF$C`f8F8;8_ma-0W1}+W1s11{}U=?@?dFn_s;Cy4X zKuOG9S~wsj`bbuI&R7-Kl5BqrzeYou^S1|Emi1m*&IilFOKB=@t3*CRZ9PP@HxxIKt6|M z_bc38DkPiII2hK{#-A#)Pq~KVSF=oO4!VGRJ?}QC3-UVbLvl_7X7j|pz&hd+{CbeN zrNRy22zS&NWYB~13D`P={aZ-Mt=g#KiOWn+?3$WZuqxToV@6;u6dc6l#R_;FB`kE| zdveUK$-i)<2`TA1RdVfO8);ElxLDswe61Y%f7KqGZ~S_-29D1%3)Q#8XSFnoEJ8X) zx!o2Vr%h-w8cdF-q1Nnxr?eJ^^(xJwq`lAc19|tfhQ_;lny!Mg`YKB;Br$~S+xJ$G zhZ=VT?l=CO*0o2R{`{rX+)>*Q(Ry{;&MhjelJ>O&e+zj1C3r927v>!NG2;amq2vB$ z5~CTdd_0jRIjc6A;4uj!ricUNDeBFG^#_IOVd$^dOgA+9I0d$N#$V~Vp_a|JWEFhw zIRn?P=#!dgYX;LuPg5OKl46@##ym_q`1Rzzl(CW?^tWkV9Xdi@!Pp=;pA?bb;FnH# z-LmrLZpbVCQwxdP3@Z6hjn5B)5E7uheBZAg4a-YE5jcEt`naL$uooNxqo(`Hp-B#n zEVf|bsfP#TkuVs7w8~%!F1y|aeTdB?m9gV$#%I8dk=YK7{}oL2Zv>znkuY>LXA~pO8NC@UGyu3 zfHtN@{rDJRu)clgAji>+YGdo2H@S=@%TJp`FkfIRo4Bzhk$9jm7CvpCtfb!r>koL3Mq&{iZIrM@Qm?sOd<=6AoD&zc zDhlqu3I&xOTnYJpguF&#SkU{U3@4TL7QLm3!Rt%HR3M)bXBy0_a9GXnW?V!-d#gLj z&IkEn)h@34(SF}Ee_7yeEwLJD?i$=yI6w*Hj$(|4yr!u#S>XKOUDy157{ydsPlZf! zn%-*W+Y)cTz+xSQFvcGVcmvaH`1Z26`XNcXJ1;UT!_SAbKitdx=K`59j#L z3p#ZM=ey`gB>FhSmPkKzQo0F$C*$(7ibm?7RyU3%7lZZ6Ot^K1^Ba48Sk0(Z?SGzi zcx`TtRd=?cSH4n;GV)jSr;LH}p~8*X0r@;RBdVQd{7>q-TlbWX;$+p|$E?|!GTNf* z@@xb7^!B?Zlc%{WA}Qq=y%LiY|88imOtejvqfE4T{$x%K(f{W~TO5Mx8%-i~F^n2F zcvJiV8GMQ4b61187h`h-ZwSK8!0~TnHB2}p?n~0%8TUO?-xFaQR<)~oIJj>dp4@sp zkG6fKu~0tIcVyu8QuXO?l3L48pZI*^+y}J1H^0d`-0u(;9IqqC2Lt)a1l(z35@Y3` zS~r+|OZz2<8>4-t!9zM!m-29auyrXh6bE@Q9$)u>_C_KKE$ph#_rHI)GxfOGn>gj@ ziiT#!jeY1h432-}v`%ulEnL(q6nMD!xL$}p7s`QD%&l)2JI*GWe__}bB|x49KLS|K z6{7z2R*tpjW;NoWTMA$5BR+-?q56;eUbJp*zG{;`rYed5}kLaiu3mg&i>nf){P8Q`(X z$E8+3#W}$DmL<+aJ(L+{qUc_h#xaHW*89vMS$tVk0C{H3o8bK54-Z+?(|DeZM%hdl zj}WSJhW+NLB=3O36=$1Uz~d<9>&({A$>h0}p_e`62EimbipC;x{otJV1dcdv&9yL{+Q>xF$zi7ZoqV26&URDm-HZ>zZiEKhHORl-I!dyKqF5y9*^- zx`+eb+~@Ul-i`M+z0?7to^u)X^Udc1zDXh-3t~seBOlE(3#%Xx7G}8)@CryG6-1Ei zCY$DlJ8j8vSVO6>MA`U%A-!T({snk`&us06p4dA}kFhwLl;-s$B1;B-H=U}Z=rKab zdFzN|SOa;x>hHn+)o8ANI>;}Vev+?Iv^D=WGG$z;#M&(a!_ zD^9bqBct;R0rGvS2}JP!tayv{(K=Vu*D!l_Mpa!cP@2wjB~0m@Ej^#A9`cr8Fu?Q8 zB_09RQQ!W9Ncgdm%A&sz~jmtRsA(AW~E~J|C>3fm6)ax;%@@6 zzMfs?+lG~m8DjovhP+~Wc5u9Zy22Al^!DuJ&$AUD;U63;F|?Rp*kdt+a^xz(>&KPa zNb0f*!+qAM=sI;ro;Jw>$4=f#a4ESb@}GB+ao-qwAP>Hr;T~u&rC_Txn(;;T|DQ{g zqPildEnbfgV-8f6B-c*81o9cJBm7l5I%)0-V`+$i@tm~GOD)q4>n;_o!>_Z_YSOCh zhrEPUMzH?=GhrfKmH11w^w@hAL0f@m`U8kA@0r3XruxmmdXO@^m!{GS3O}n`Ox@Yz zoF+2nig`OZC>usB?93~|vBf%uA&+EK3S7Ust|j%N*2Q|S=sTD9d`8oF>_Ag5(6-9=uP(B2i=86C>B3WxM-!do?*RKb)K*m`I7eTFCA z^U~w_HdKcHye~Y9;CPSb%5og=`tZ9(%#To68yU6lUEbnPZVlfg2#|vHdX_hu)c>(` zmtk2fVHkkv5R{Pa1_`B+2I)q+OS%NX`9qCdj@)`QT2lq=ECH)D~psK{+?} ztuj)>^MX=`!8NdN_tWm`%u9T1ARpHX7Gur6YR6m2oL48#!){ODd4%_=-`As(V+?0& zeXiEsg1pxF8SwiN?cV04{KPzPF1&h&pH1r#eTbaT+%IzS_n_BP(OI>Lms~4&?J!01*Qh z3Rc1Xv?4xqtB$;r5Qb#fsFqj`eM;^-LkS8gbw z%tBg!sTI`^hm@|)<6^_FuAqFE4+3Dltb3tQGXQlscUegVUN6mC3PwI2p{uCf>I%E6 z2JkXSmj&l%(mZdb>AOC=H*EIzALY^EmEQApwzQf2427e=fxJQ==>Gj~;B$O(?za2K ze3xpcO&H1Z;4$US2(_F`N)hZ|*1!6$_AJ}&P-9_z7xx!xB)y@yM>2hmwnp{N?R|kz z$nHPyYdsry{7Rlagp`lCCWgZ)m%Z+1))z3v=zLkRYjNsb%mL(^v2hqtFV1cKNUxc^ z$xkA@R~cZa!t2{zt8IKYkj7?o@}?skVlBEBm;Py zpJQJdO)NjEA>m(b_$n*aluLSK*P(68Nl@n8O0t_4rr8?v~qA?+l8IK99=WV|Fi($}o&S$=#iBR=6 zabY*hGmd*=k0$bC7$4AHD~>mLOnwgFzNnTP7Srbx>;*c0qQHW@ zB&I_!-#}X|XN-NY8$h8wb2t4X0(9?_z-{Q}PZXdOfgf z9ofGumY=r--J(-bJlP7<#f7}CXO!UlJX7sp@dU3x@Dr{kO$@)1`z)eSZ5M(5H2Nw7 zxSwl9_NB1^tGQiD#*=5biZ%WGUqs{WzIKGbm5XZApEeFu5JR3^&?2~g`m~~=A>h+R z2o~klpXRo}G5VwB58frb!s7eCS%7>OxBTDr1asTey!Z!tzOo9@Zog2u#G75FmK&uc z_@Mfw<)4Rw_g)z|zdm&@zVUcdCk%|SdhG@X>m7U;$rTIW%d6QY*8x1%XYjJ|eMuhH z{mLbwI^t!L zRICdDHM*Q{8{qLV{l5Toi`>dJm)hnqQXI`+Mxnj!k;IV9v=i&j%mxMilMEs({pSGB#^(^k5+j&Wij3 zyr&H-;rEzC;-^!LkS8u(2F|B31@~d{0Zk4|!AmkL?OO(SUD78CHAoUhvvei)NBZ7OGiJlI;yVW7Q#rHatimdGE44jF2? z=q+ngowiX~k^CfO)4#C+Uai<4vsjm-O=~pT$#ML*K^4IaOBsRwF6^OuJU@8p34~c8 zPu4#hTc_vOyls=eOYdTTL%bX}%y^wYAU91>x1~s%houMNww2o953Q zqyS#$6XJA}T8f~#B`QK%lp^$GhEJ-q0h03Hg1NqV8h(*cW{13#W*YGRFz4aZZEvSl zKeHbjTtaD=5P0(9)w3za6gwyIc{`RE4P}Kjata@*>>|p4GVz*jH-&sD}meb z^U4<+T#$D^{}sGH21$IK_qiVJ8SYKXYKwFRxl>D%>1b2B>5+vifP9JW5$57p{<92Q z2)UmEcV;6?-eyHKj_GmLht7u8M5wL4hCD(~eQek4{PoB$Uc@Q6xvEf^-{N5f$leaCLPpM;}i>rn4r z{%QH^ZSY=W<#6;3v?JTl%?CGe$PD!qqsOLJh9-%I`BwO0#x!v%XPi*NL>B|DzhRj(VGhOi=$zGZsdj4Wg_ zL*O_*ho}a5k39xpzNw!gyS`0!hr6{gH?Use)v^zDQNOiuI`JYjGXYOFe-xRuDuw#H ztK5tSiYZ&3#_G@M4?f65@6#C0exC6JszY9kd<^(JCo~^IV`{()rf|8q*QePtANrA4 zY`_;t`Ac`k6Yx&u#&9N73S<=`R^+qv5>1Lm7cZ`Fj>eo$#KbG(Ein}|ArHRyT?NqI zH}gTo74tv*f6>|(SS_I^eH7@z;1P+qZlJsF1U#QI4x-6`&hfqqy-459wWNxwhnGYt zUXQfiM|@K5-So6tkeBaC0M550j8F))rDSVE|JJr2Qn82obTxgleH3pfZ}0`zOW4qB zXjQ)NlQ2qmJH8nS*0M_6tV^YDq%!WhSF7cu%0keCJPI{Da6aRh+0$^mPt2xT>6xAg z7x^h%(DXs?u?eckAzIaE=8Wc8;uAp~E7JY*SYua_jXc-G*Pb04Po6`mqa zSn?l>Zt?|HsGZh(=|*-xQ&<0aNGZwS`b)HH@1)g&Y@c!a9WsZjJf6GdGohyZZWGgY z6yWnWvv$2(Ov)cq+H{w0C@;P2yfrU<_VSsW#b_i8Yk(@}m~m{~7t{sCGw| zU>?TV&xaRgB!6Sxlrq81@nB7d;|1~!49j62AFeN44$>3r&?tV!zIO4_>T@#QNc@0e z{mlp zk=4Mzy~8)^Iw;f5ur^KST|d{UyoCwB*+U-x8yT=acy5pp{ZoA2d(quH%x5nu_D}l2 zCpZi3O`*OSCLrJOa*r=&EgivWWz(eLmo{VB)w!e+`izQ^7i-bOQ?ni@4v^<@3j-cM z(w66`!Kb-W#(L+r_!ZCipHGEjr51dwxoU>51H8bDwABlSGP#-zWZ(HB(fc!L*$L^2L0?iNNb>b6F-)_}uJ` zS^u&-xBZ|QIjAUg^}Jrcie$(S@?gJeumT>1P5!I^d;GD>0!*t*rt+`OiVPJ^6TC3j zs3!1xY4rnmNuHBFfvhc23GVk%nC#BAIT-$1wehCK-oHaWeK}nGrLUD5SoIk_QDf;~`4%QZLb~vBPK^QY3oOoq`Z1Z1 zbLnX^?V8_j_o&_LNAqXdk|CnIVk;6mjFFIc8S@Ujo<)A9mnGQ4`obFqqm7-i>)!cT z1Ub@|l(V$!*#llBO~aw=Q1p_VCvs2LWtxC#55ZDCu?g>3NmK`-!lem!G~_J?a)bMa zVhrTxmp=p-v-T)T5$di6jQNSMJ$e&2f7R1k1iVuHH%hZ&%SK3QRKXrF^h7D*2ccON z8k#@$7-dc+?;Yl2Aur7i`u^WAHWdqgiLptMN~Mj4!iw-a*pKEvyZjaIj6Z|VBe!?0 zT_V(ashP?Nmd!*pJ%abH40wMk35kelJmsC-Ho`L?4-T7?2RI*fD+O-I)@^0AZ#p;Z zs`8fHyZ3j=BA7gjiUj(BeDIY=M^ThdDt119DEF2M&^#a6%6~nLH%D_{DV1SXN&d?SaHccS#HkGs)STj%j% zKLcQSo6R;7IO6ie=lc98-)BMjV4NhGfPAY6hEE5yqS=JR2U3VplwM9f{V};8j!b{F z)d}{eW4~7DjsG z&)MUOm@SV=)9@-IeGYtc?iAg?dgw%>w!w04yo=;F<_jFU_*|xSvw_#o;|V$4Z3d(3 zxg=C_p?q#Sk57So+f+~K!%jSP1-3k5AqPRl}!LITu6PgsS(ECVfWlmakkXrotnMH z61zRDUC?|S;7wQ7npG5uaLag$#ZG?rvtz=?L9Q{vg&$qHo3&oFkWMdxJQ5l5J;1ZG zRY~R(;ms!RdO_`3HRz4&mx#sr(0+|!F#wML(7l?0{aF{ zDbmYYyhNU!s+2$;em&g|-~~ubSZHCUyKVdL*|9lzQ9kGxh$w1^_8}pXFc&4u>uEV=~TQ8zU zx7}@skM2r=R4$;Z`v0F{o|+<+eT0|L`ek@s@7Rs)qGnqta%|D?|IY_(WR+G&#T3>< zo{a<}9pKfhG9HdZ*wBRz(jTIw;b_?<5hJ{2u*!VFN?Qnc$E@x$X?q%Scpgs!kFLHO z3M5~P%HH(m-f1Rr?QRyDT{l4<4Y@OTepOKmntbo!*+!CdaIoutv!ji^=QXBeYveG= zB>+6}xcTF!xQf#stAA+uC!Vy}+0#6)39fRB3J@6MPmVS`YlS>Srx6_>pO;}u9B$zk z2Kz7L;&SJgH^ccMS8so3i>W$qnFAhrqRI0|Pn%mTb+4)Y0;83Q^XRp5?E1J?i|B{a z0~A=sF39V1*aFwXn%tChvpKtBFW}e*$>Rmcx<5ExF^gJWM>%JL^MyqlU9xE|c6FOP zbgIo;^d0p~F}I5V>*a5h3tF-}f*U*kJiG?IOCVouQm9AXE$W(q_WNf~zZMaxJ*^+) zksjBLn99GZHee5hWPhk%E> z6&ae{{b^5`O{u2jcNwL{I|^20Lkq++8GEDu{|uuq5uY+|8vtiAc^~++mWXJmW)FR1 z^a~4d*?wE#OBn;kVaP)legx+;{zIL9f_698Q8=Li>;ugo8<8E1Jjea3y-1?30Iz89 z)D)*DC~@O>l}v%|TZP_KE9?h)u}(&HJ^CZ_VpOXU$RkPn4t|g9KonZ^l*S0TIiK&)i4@mU)6((Q`O zbK4+@Hf294Qy<8{T}MKO|So zaBwJz*&3HDz2-j(+X<%)`$T-d1dfNAW(?+|!fB^CWUU=VlP3MixGv;)vMjZ*xs7@c zYLg|0<{|H1wHrJiSaAqgo0ZS7C<3c5`t_rnj#;`HXzyQ){`lC03*?*OIrV#ClBp-E zZ)IZ7y%+TbQDk0>69J(TL4wv=<9DOiI^+@YbZ!FI3q$w}?;YwbS1#R1-TO2?g3Vit zr>T2l>@_Qke*rJ>h3|*?+J3w;x);x!KD?yF!uFTf%QXMiX-MT|&WAHr`Om|D?+Ety z3E8hA_YvauB=%T-K872ixBFM?qjMv(H8&y)0-mNd>KnsQLR@-IF4Gs3DQa#XY#7Mc zXGE&*NADd~b}wM|pnQl5w4Ok|RI0w;ZLBq}z6|cHi6S9ns`&nJxbM95U%s~K1H9`` z9)cxmaiN^XB-(i!j54#O%e3`Ag7VQ`soCQX zoQs-S7yr^A*(L>_Z%cg7dVkPMk+LBCwx1d^ zr8u`^`gB-<&dA!)+NJ(xWLgpi9$b%IFsTCHH$8YLz=`R18ha`nkx19+VHNfj6YVRR zTE4pH1Gs(_R{CLsFwr#dApSwHB)cGwLHAJf(#6XrxMlsZh4ZFq6B+V|^wQ>le3HYl z6?k`fBs)r>Y2?a>cpUb9`x4)Jck`{Xnt$tvB zw$eLE*D$I^%fkg(Am4n-k=k3^=+z$L4d(JyJHpRDsM(ZbpQuf^1X0?uCZ&=Q{L4p7 zV+Q1#K(sR|IbubG{oAYN^%Z^o$3|YmpV*Z+-=P$6KErb^K$!4Jmn>M&-L&T^W7fU; z*i^+gjDSNu3nsfEWb%Fz$V>9y2J2;0QJbvVVue~3&dOyNJ6C=ASF;Hp58&m*zUht_wxo8A9Djxd>L3z>KT0V1RG~@H);g&02WNVEo zYyUjNLIcpV$6Ux^V z{Pt+QCAIwLaj;5&{mW&`&?H~|{}n9S&Ny@?GI9H_?T7YXrUf6W2wQ=C0sZfhEi}WL z+`Z=SGI&u4Xgw$5DcPWWqGsgae8vjr(w`l{MwaWh)zQqwiaAq} zz=G_nA?d_gyF|cinU1dwXnlX0d+|>C{ebh|OEbzpZ`=`zkph|c_2^t6E8Ub?M7n`S;j2IR+?RxjVmanV<%(W{LCWeupZBM3V0Eo zRw%1~KV?)EN(>%IytviIEMvZ!I%KJ~j@b-k-HE;Y=fw=Pg6lcb*t;={T0;R?y_aHD zZ{4tYRMm)yQphAszLIoA6G8<;HD(Z33^n&*S^ z5sVAO1Lt>&arTzI05+`UBNofZD049@eO&>354QeEdjJXGQBL`b?x*lag#@OM%+@Q6nM+)-x`X9jlC9W_!d8{GK zY`P~RN+LLjDJfd3VJKUZKwni9T>tY@Y@}5PTYi>o#Es{1IwbpE(ZDvE-)paYE3)t6 z{N#~K8uDD+PQl|>n=6Jhh=~5doo0^*M&)lwhb=Ll*uHpxqo4rTpDMfSNIADX@e{8l zW37?@#*cfX@UVnKV_HFuJ<#KjfwTJ0(}>(xkydMcKn*i+{9s1e1^8ROF_Md75C`v=Uq92O=qy`I zO+H%s8PiK}V?U<|dF_S_;PdirhUC5&_u6aPyH2BfgUl`akEA$OPoMm7Ah^{8xZqEl z%bzKl*b=H(ZKYogs(Qpo@_r)R~lgK_qVY_hOimIW;T8wBx9;cKESU25E~OUd_1At5w*hcfyedPXOgaiMK*xEQJ5oeKEvcAlRa}} zoJ;RwIgKa6_jb|r8{Wr0vL|A5B;fuWp`3K_0GC~#tZVYw>SfHO{3rM2E4Q}#f1AgO zcQKmjTnr%(?$irhUvsGOTH_M^e?Ml&_rEHr-B8 z(j^2XysY^%Z<1UVTh-H>5KU6WSUWLm&Gjqs`>2wF{ zGbw_Md^xa0YyMjmuWkpO#88PJKNS#0Hf{fARRX+5l*G=_`s*)!zSmAaW;v9doYB1E zt!Uv+3eM~wOk=)h*g&3~C@MH#U?{xBq+Ane)omVWA-p@D3gi2g_x~5JhXiOPqyW#r zOOa)7_~&=CpetBK7Z;?DeZREba8YX3aH>)yf1URezK1*{`FrsC^ICB;cT-TQb6%=g z->8{L+C34@<>>qvCaF~n?l)7s3m$i^37q#|A?i%Gkhhmjk3vp1dNLX9-i9IVGb)%IMiq>M@tEEdqu zsgVsAqP`;{*^!b9Q4ap`_T+PNmj~oM2`mBYQDzx+YIj+3e|mP+qcr4+Q~cB-Y**ee z)w^srgYO@$w+p!1hws?GjcSMC6v!;tr`0H1IbKdj$($VMQ862r@_{^Lv7g|6kV+#O zstu`bt_TD{&%cGPL|KYK#!rYQU;e6WdIuao1sqtbsI!yIbN^m@l@~8*+Ve5%p3<7d zXTCdqN{@Y)aX!uEgF2xgbA~8favuMC8HhtA= zV=aO(+|+2h5~F(W4*!m4NH-uDiB0$OD}DvZ$4`(4^N4l=9KV_Qq|eU=zh^~K-7I|f zydCt*$w@GZ{^YE}ngZ@0!a3gQuR5OhNuacwUMxNKq00yzmtz`G@3z}oW_rhIpqdJK z2z*80`JjvvmW6A4y0kt%73ilG9vdo~F5|(t9csIb1@7O-Y!FmJkvDd4Y!`1|SE8kA z>6h)J$icm*P>EvVO84Q7%7eU4)9-9RK98KSMQl-;#S0Sk79_s#zDX|YjyF_ga)e5b zbU=IcQ22sB)-1@>{h*qIQ`^e3sT~pvCTpNQLCu%Q)uB#0&xbt1by*9*TYG*ka_cnq z!*B|l5__@Udf5w28C&u$Bg)+p5AZ_EYDu#irhAO?J4|w05GfNXv5syu2pk?9l6CPM zH7{?AArH3{4qP7+Kp9sMnP6}C-&WJ8`oP>zy052=+9$$(np%qqctkn|uTekOQRl?` z_H9_gS^U=4#$^%3lKJenc)xe^`G#}NKhNQ@7Rbk2yDEj(hv?l!-~XWV<&}WhWfPI= z4+FT;u>1hPdu`p^1mCbwJX!t}g^Yn`m%n?am{r~Ao2sD9Mq`1ooN*oGk^i~@>w|Q$ z$tzALwFM?|_bz%2INJm&U#QnT);Z@0V5k94KnLN|r;rN{34)^WpR*(DzY1v-KTajR z4y%BjD_>~YcW;HfZiGkB`;;@TViliq+tsA3`is}M2`#)GYwEVd=X)ynID!#y6U_1p zZd3ZzEC2m9>TkH<+b)g)I!(QNd>>&43#AFJKFC89q5#)(5DwiUW(#@vvFFVUquHfNfKG*ce#f-+P$F9AdUlTv^m%(U6o8{&8Yk`wzvl>6I_cha%I)jMSF;b*3tpW;3{T?WR z<5&9AeXHxM*hcTe@?OK7XCZk+Vb|w*O(#bqnQ@aa5fZC0$O}^pr3Sn@)st%tlu8b@ zbg6km%uFGM<#GMNE4Z}tknGud0p&hd6M_+g?mL(ersdpY01852Qo{(HU8^~-Sh zeat`4o2nZej}td7cu)m~$vj2A&AhQ+Eq>=|Xu5-y70z932tI$$b-Mkn*OYa+i_W52 z8J=JeKljYOZPH-p*MB$^UW4}{n}qT;8;OAZU+Tn6erZJgh*LW4kFH8TIqi+cfy#n{ zLAS4?*g!r6Skf1F&FbYVUmmcmN(n}&`%IDf#5)W1@rDLB`$wpwry=i!5-j*U`Wq~< zV4?P1jfgG1lY=!$!|#3kC61KO@WnkmINs%TdsH9yOh~PS3!|%AYY)Kz47*w z+aUw~>$=CiC4HI%Su_&you;8z7!sK@jJgirpnQ1wXW;%d+XiCwYjmxcbW#8FZ@!0{ zuJ3BGR=Qs|z8Q`;0=$#f$!oRprg~)wr?G16{cX4xaVE>@b-MafntJP0D|NdIkf+2h z1&%lTr`hOAsNcTkROf$?&$wlTX&$t4%KK%Cwe$k4PxmaL=r~A;;hwdQ30S*TAg>Ln z)Q($z%vR66t1t4<8jf6sJh(gtaQ^n1m*XN6fl?q)Twxc^Kaio!qR;1)J>(O=9y9t5Ik*@lluwfv%w|@k6-&>k5S9Q4(zK>XoEGkCJYnF!6~xm z9(YfpP{8@e=DXLOl^@6jTT#0=$HPN1(|uFVddTh3*i9Qa|Njs>jLJ6TB~s{vzp(bSN|V9Xm}Iy@Y_ev>axtb-xGYlf@SX=SKn^bPpwxj@G0i&CA5& z!Oe~bKRxgKy~u<8rON>CFWVd@iI>?x#+gD2LM!r%&u{PxSRGen*`#B(Cifu^ zBNPFw=Oq)N95&g{#vF#hNt&t@{~k?Ovt`D*%Y#wF{R4PpC`KDgNIv{Grc5MFZv)$@ z5!%eoREvsSEVu&MF&s~fuOM$K%U>L5uT-?sh5xLVhbddyP#Tid6HxTBY z2Qn95LmtO9DcIhHRVU@}+4KHGGSy-WzR%+$enuc?Ixs;Pry_Ox@udha0jKX0pC{ME=}sA%~#{ z<@1d0qYLnPlth3Sv)R;^YoiqJ6|i-@zp}Kl;=(xYtc1S*dVb#QU$MZK~9!e#BCL)CGON-_Ogsz9WJ>! z5l8$P>S0>{GNyPW2^I4CJi;&l&kjzL2G?_;g>JotFnfOu)~5337o>2~M_4EBTfiHr z^@dZ#d@mor5#WB;cvTDokM377naaHQ_5WX%v7~8@!GydA*JUce8-GnwPKyza-1}BH zInUecb2{#$eT(p41;NGH4Zy1lWc`va_*1Os<-lI7#FH@IzyH5{RVon^>9}l!9<&Z8 zi3NFoG?2jlAQ*kEJuk-}!+c?xECvpf_~68Q_1h(JT$C~W9N-lT3e_GIm?a+Q{7E>R z6!naV!KdrNCSAI7@Sw@+>vg=thCD>RJZ2zYMGn*FVT*Rvn)`=RSh}g;pa+JF`wU&L zzeIN!fEN)uj(YieIIJlW-klN2+^8^3V(syfS{`n~AVP)}6a6~% z{pK(fJC}s^|=Wv@(inDFyJt27it}~Bb1X`q|O2f|c4|0h3SL&tZEQ%2lJsLA$ zC@X~-Wxaqrk~!T8z>Co7xFx(!3Ue;n6BJ!TAgIltX)^LG@<7}^1^x{4^?>?GX91E% z(5?)uw2;6DLgLSf=|n374c1HC(a+h4@>wAd*&jI-_z%H54kpOcSssv!h?~>^Lq80{n+t%u*eJ;D1m&1?f3VAp?cwJ3+^^Ziaw>&W9W&! zaa&)Rch^SsqxEr8|9ONk)KWk`g#pJ9cqx|GX3g~LQap&Vl1;2EZ`QL3a}uzg0$xEk zX%dpfy{{g=e2r6X9Dh|d|4!f%-@JM@^Buf&>KF+Rln*6h9;}zWzrS!!M`J;-)%I&Q zVEHvw%iY}8@E0CKIl>M6{=u)O_=6qO3-V#xP3*5>-ONNs4kUg*yH@yQ@4+Vyhj%^r z&l~iP2G?T`VECxzzj&~|SD169=gXv4`qaSP+utdJTI2`5&<-~ck8~sXPJarwSu$_; zw_}e~l*cyXn-i_Vyc3}bVSY0KDBtts+!>&~m?kE7H9>AV1XEJPDn$&Qc5qFj+byoTE;oJ6ZSYhZ?)chMT)dWgdIaA>2=eyjC&2lez(?_U zH9kp;5flFpssZwhrd6fWPcNz1Fli(;0B=%g*9hHQ<_(4)C^TX%N`v*833?6=#L{p5pKWccdr7s39ny1{ zE}s;BRBiw8T+c>l3tbEHuH%}({;v`-P{Ag`e){F0!KB$&SI+`PY@gkRF+#%#*?yqC zVj?Nx=zcZ5_FEFaJ)&=eX1d)4eslR9Em{xr-=*VwuxUdco_7g&{W*nVTU1QG3wuMz zeePOBw3C^;bwDIk5^!_f0PZi@5u6#jEEM25X@2Lmqm-HTNi4H}k;K6wyKTsC(CzAi zSO@ZS^L4@gFMgr6Gj9sT|HFX|@l~9jeH5-S^Iz|d0T}JbP#~XpqP)KFj&_exV68&m zWFgCtmHcr&sa=8TZ2ANoUXrMq0puZ$bFKsD0~dMz*1G2)#%>~93T(X`&~KUMUV7o z_u<6a^M9B4f@;;^Zyi0HMWpqO=GTi2aKF?z&EHb?)w6+f>!xk8uU;bVVyxj*>t;m`@@x}6!H{RpviSrsu1y}P6b z*EfnQ`L@3ESaSaVdTcG3Y8&n=EJTWCn(!}(?U+_CIP+Hlfll>~j9g&V? zUZA*nC zP_j;Gwa=wseWvb9Xux5%CcoS+3->VPx?l~A&+OP2pV6> zIw=XT_81b@67;HZ%P?vtu#(Ij1d(LOUwBL=|xNsTSh$5+IL> z=?%F4XM^at*c|jmqQL;=n8HJI_VZQ`c1Kl!`F^(xxIZFx=aFM;PAoCzmy4K3Tgd98 z!Uj3>SM48I?oG^Sj6>0UX^^L7p96m1!Z+Mb=8DeQUu~h%iGVj5QMlD{k>dn;n`5r} z63Dmy)AlV69Nl!PP^ejDr~bUY5d6Rz-E^F>3>QC3LW7i92IL{;&;JFkmmA9OaxGp_ zS_)~VgBC1m2AF4fSZ2}6dx?H<^MIHB5!WP7)a?A&CV130E6(`yI@5>cW862dZ4{YK zB=P4Yav{%hZ4Rt|*vl>Gnlj~?{F(5ldiFs)&5KNoet7vyfaqRT1Kj-pn*a7 z>+X__bZ+f#z}u70&b-J0hghCKV$l1);PG$QvjmegU-i z;3_!zg17c;XfERE|C_P6=!`7+>|h5?e~@T{&$rXCF+xmC0@q-*X}+u!X_vEYr?4>wXnaPy?_qZD|{zp zHf@I3;DXfCt34fK1Y6;-SlQTge7LD8+mdu9Rv(%m4~f$ooX=QTghq~J6uKvPy>K<= znWM{1J0q{kCdsDTyaDgGY+rHjY^A--*dn2GOph~y3+s9z4WzE~o~c@m-NBqA%{It` z8Os3YmoYW9?^oZKbYkdoE}I+$zub(_f3-T57~~^y53cW)F2M#0^i-Co|z{aMcD?i=J0ThlHAp7=6ashTo>Gl#G*wX`T)CA*@l zM2G5IJ=9;p;CMshZ~Grff<#^RkJ^Z{dM1gPPezeyEm~&$^-kGlYl=_8Rv-_hftd;L zCXuQ`I4^n;SyU6s&7-lt^dNbLEud2ovaZ>I_lF^#@^CF<#+%L9QBO@zPf9n8C1*pU z-|8`Tvq@{0aoQDYkT_kveJL({hizwo!GSz*C~u%%ak8D`9tC;rP7*?0?VEq+DMFu z{w`hl|IaWw5yhJp7{SfK{uMj}CfoLS=+^#RoxOoU=7jaExs0whCy*yU3k!}<{gc(> zo`*Ztn;VSqa759Y;8Z>lqPN6t>~aVS0=yqv32fcfUk@K+tLD;qrIlB#n*O}eYBP~Wng0K!i~s*=9v>|=o^s6Qvg3Yy>-#m; zDHzR&0X}!1_ND0F$cAoQI2B<+14 z{r>+&wAz0j0nE<<;Ck5;c>1XoQ?JymY-34#{LNkva*3<-YyMRf?JOL?V;r{EBVBSG zPvr79Pv3t>d6+Z#+7PSl5Sy#eE*HasQy3Gl`DsX>nP#k$EfpFfop;_2rlMhEn>2fgA z&j5X6*P1a0Jye&%(0^V(Z45YG6Pt^Z8ECuQnEJkyFPa70YL(ERRY~bU7j{A~3*^f` z+*Z;oHKffJ#g2|BYQIPBxXio@!VH?re#F1V3(s>IcR#}8vU=Eoh@c5Nro!GoJ< zB(}j382$mDu;!m*at*w3o>nRH5CA{pR-NcVl^|nHk@BHb8 zUNdJfcej6ysR!>54ZD)L70%t}c~P^QcHZXm;rYc3-oNfa%i8UhQTYg8vUwm6?})Pk zXs?dm@}4V+(_O4h$Ru3r>xH>i%Q3kq5w2J7s=@twskYV@UBQ6?`WKirR)ZzaRwj0- z@XD#TIEK`}vwW}2Q+oq>DifysfOq$yLWx6AkgRwAdi(>O%s|y!)fimARSg+?*)^cO zuiT~v@Sg^VZa5e@Rx5SHDK6ePbxaMi>`>ySexCmBi7f_sGj^!p_}-LZO1Uh%7Sq8* zAj)XtTgg<7*_6K*hLPi!|G$j=|3B{y^4LP{w0EPuKP+eC$>=xS7waE$Nb`eHQnCG= zb~sSPArJYb-76s9xsZ@(!1!u+XhoY|-P>&vX)8@ELz{QkI!}Dm0M8xaZK*@{iDMb* zsFhC-S=U<^yR|Lf{=`Uq>NMKKLwkHV$RnQ31M9WbM-)lIbBP`&Cxm1L+S42X2*dh` zvtKEgT6vQI4~cmP-ERgddv;kUq5mrDq2wj%A-?8fTAt)j@5?wvxHJXGo1_^8=O3=} zT6|q6Q5Yz@Z<;sSe3ZXQZP2~$mD?7OPf!QElp5vZr}Hw~u!Uu(PY^iSK5-Wu?4zdF zXJ`}`V5DMGoM=NHk{pT<&|X14cdL-k-%4Nuw!ZNA4*PjO;!u507&l|i>P-ba{T2?- zvaahl^rBBDmW1M0H4@b#mr`rCnp-C3d=k9gn&?3u%0(Vn|9$Jq)PJmY=DLiYnuxfi zv}-Hep|M~>aY~}xAUfCF0pv5361RKjD91`vZGMR1Nn3o% zV4(GUq2@S>Gw&5eLvJp*0pxkc?ScJY6g?Go&u)lS#vHxtdx0sr}uXty|nBn-6lpvs7CF89n##y zt?G}n1YRPyVXx)|N*kT!jL60CfP8hFLv4Pec(gF~HCptT#L0-hJ+FK%;B8kQQCJt% zS*vcXAn$9w064ySEotN7cfV*Ky$ZW%Xt(LvFrc@migx2fAXTIr{S}OJopeia6C?fP!j4m@;=43M_`*ZfyU8*orQ;a z3mJyX*>o20C?YbenQheF|C~4M*wtbQ1-;+HMG3hHWYLfDc-bb!^TrwSR`55$@z8@! z>28(gGIy2aR>-eB8d)*iJn~m83(dYxStx*)RI85tiy(p-RsFkf!*Q`2?ik}_^dsxv zv3XRNq51CzyZ=0V8O(Oz_>Bk8QKHT`E=R_)=RChoFC)3E-z73>&8^{!atFK=bl?2% zqbl#}Tb6VTl{)=0+b+CrlIX{pkCtvdaJi`IU7&m);SIs(<+@j$$Y>beqj?ZVMIn1C zgXjws9Kh@3N_kluv5320mDorBe$73}drtI#+Cp(Wo)|Z$S>B`C7xF5O zZP@NujK0hAlUj2y73V30C5oShMx;rk(b%nS}LvKv6 zMhggqnoyMA*K!RNXJh83(tA5*Znv5czz{5P5Y4 zc*`XDCVt$`u_Jh&ieZxs7ytiVv@l8 zuM8~7d)2}yswcN^AAhN}o^`SZ10I}2$zC;g`nRuZD?ZPCq@UFAa|s;H1SRa9E04k5 zBM;<7K^_Ur+h2fJtmcI)h-yCd(av4}{wph|Jilzk#3NdORlrAPz$02X7=`_uuZ{kf zIaa#dzhYhd4dZB?$%}@_hoddyJ)Xl<$U~;L*#bNdTcX?(_`FRqM2GR49~`!ljFtHV z_10Vw?<2YZFH9jOy`8UkTMp4|*u#8*pwVZ@Epb^LgEB9%Cv^V(VO8n(omGpJ7hyGGPPDQD zL4iThjgDBDiJ6cGOE?9tN65t=*=#1pM379X{LWZ06DM?|oLvY2F&Fai2~@a%_Tn<7D`UWiJQOWBAiNZN zu>2~GYY-=G*7_zc7_8SaYR+hvbLwnaf8hG_b+_BpS*~yv+yBF%H&+gOn;DH|YX#&X zN|wZ$cpnh)S+9QhazNBC6H{UNi zjGwhF|Js{xGYYhq{Aob_Z4zTINKvAUx|Pkk9Vn-OPDacQ>w7 z9MeIqadmbX%l>mzF1%i2R+wNORMnzB$U}-BLI=Eo;9tZYb`3G}qPSbfg};sbguW>2 zo4V{bU(Xr>9<8%`_fU5fzT2P$Bu4l(@ zo3I|;45VCg`k#-{mRn#hs41oIuNf3m`7~d9eQR(}% z2e!|#ebh$QF=QO_2%HGP`jPeEI`IijLi5#X{+;(#z2nOWM9jLSV%y0t5(hv&e;dt< zqgTV515~+W74YT*^4(bKu`aBap9j6hVEM0NTc#jSP}3SbzY}c}Pf2XDr>jNbP#d=S zC3_t9(84ux-Z_P&wgKLX!HnZ`?@9ZH|5&;UhOU`74&Zc3cQ?{qlG5EFt)z6f2+}Q$ zNJw{zv>*af(%m5-A&qoC&o~vu4e(fBSp#SZavNn;#C61=bP zbtIqIW|k z1Ab4(n{rgWlfr81pTl*;+lZb83&ThfLhkkMo$WjDdt&+ATkp5T`1hw(dE3uI59>V) zoBh=hgAyJ zSNZZstWG~w+XE81kDTVy+uG%QRP_6@QGJ7IKOBYZ zhSnTHUP$!}*uPE3qdRT5j=1^U6edChgB;C@8>GoIC`^?>T}O`|HoeT^TxL*=iBF_!ne?cei8k}oS${IV5jWM~0m%{vtKbd;!f6J`?G6l3Z zPjO?EK07+DVESB-)>Bd9Nl8h^SN9&)&0TrXnkSeNnuw4`Bug{^c*b1p?aLRT#~V7r zh;vahEKP%Dn@jVK`JV?@0s#*}3RhT;4-QV-cdTTt(~3nOmIM|@&Ejfu;$nfekh`ko z3FM)o&6fdQ8-K{mP5o*Yy>aXuPCO!9Ej*ot9m7Z=W}u2X;EDh3+X)qmtDs5pLp4D( zt3^}#<*S5zB`Ib+wLR_GMm~oLc_KTx;C>Tt-PqtCMOS^lTB+}RZn|j=5%NcY!R6#88UB0| zET4;_n{XhHu+~QbXs;Kn+Yv>f^iECwXXmSKU3tNlrV(tM7t-i%lc#{EmgRBVPq`#? zA=KX`K+F>LAnMIzx`%r9`KzK_`z~VLDIw%-knMo?Uz(+BCxMjROZl6R4LG?{Zv*3w zbM0N88gyudasZw$ulVz0meHY|Nuv&0%ntPrc;qMyIdM|d`Fax6lMJ^_G?3@m_~#jr z?}RhVK8?LCD?iEYlrp-62!96lc>uP1nRzZNc>Z807Hw3IEk(35IhLv=VzDHUP(r1( zYtD^yP z@>GIef%_W|P9@ya zMk&X}y#D0OO;cKww*8%Jc3hT!`Cf5=<8$%Ky{NO4MLo8JGoe=Jr@4SN(Y}NVAN0q* zM?=7~!XYX6^)%9$(Yl>u&S=lq(sK1ScbOk?0Ecr;5N7zZ5f9|8puPs{QLl3d=mtDW zr9F@2OeK!8BNzqEXyssEd(RCZfb|6gp)A@3-JvQWW!ax^jGw-OVVk6@ph?F1RQJKr>WgWq@I&`OX` zT9Y}X$_nj(?++mi6*jHz+(bW05#}P4o=);3xS*W7-c_Y8Mfkz88mn`0$V1Ux1M3x? zO)spmaVK(f(01X-QfAfXX3l2S_TlAM*p^OSCt^_#QMtMk>shBK-!OHO-J_tn4Q+K&8?;KBNqqz9+I z>VoXU1|6wi9}yC<@b8pmC7qoG$zsp)8>=EJcP+>x|NO%lxc??A^q4K#tS}Wer!sL; zQa^fF8>dq0Egq;-(76ElFb#Mw2r<#B)0&7j1}HwzVh*?16nvn1d}HLNOkAJCH>eGH zu@g_g^Tqon-w&UjX7WEKpOowK7zgcr#`Vj~v*2|1x!3``VVV+NG;;U7#{2(VkknhRuqF%w0;%+amXeXyx_2&|{(AUj_H}PIw z%yEEcl;8)CqC9`@l5*{-{b%9{PZh!OdI`T-Y9^ftGJNZ=*G7=1PA?ChABrC9UT=Of z-B0UOje#8>eRrg?)1iW4r(ON{g659ogF#7I#O`J3 z?G8@dHw(xk?hF|P@=5+~)&KeK%=97+c3RNKmA6f%$Zu)aF^}UR0UVz@2I(8clfnX@ zk)}C`kGCA+$*R!fT|c{UGc*08JBw{OYz2AbOhIyhC#6P%ZtB>c=~Iv!>&rqg8oD_) zmJp80FqcaT?k7Gf#EltFg@02bnKu6M>0tL}^2`aLziR&!yG(6@=^=jUpT|ci0QSdR zPWTdyaGo@8>hs;MIh7lZ8ZPdA=gEY>Xm?=!+{R$YxYJmiFU9wsBat=v6OU(@5L$jwZg~@4m@)7g8`;bpAq4%J_%_Z@3e&O; z-Ra=|-;%-{3(c2EC$vr3#vfD`9`p3C$dS_Dcx~<$fge~PUs9Ott6=CmKS*EdMb=9@ z$Koz~ltnxx?4*Si;mdSC^!V3a(IXO|y>4aS&(Y1~+mZ2}Zek1tQm>U5*PzN^t$r+j z2JRnJIO&TpzfT-hsbdzcepKJ!c9}rZHmKYrrW!b#rKlMZSamPI%MD7cihusp;30rR3J$3 zhuP=fX8eATM=)Rl{{FrAWGVsk>jTNWc9G&>v@uM?ElyGGxa-j!yc0ga`-t*2G4Hn; z)tLH?+nEvuS5kIf+Vs1@LPE~CUqcL{e~<$Hc?&_{_&gJ;;BxbzXD$qf)=4_u-Lo3x zM&9_YAE#Bd5WIeRkjGV)6za`^VN%!IlJoBo1m#n?|Gr-f- zZ(l~X=;?ODn^s1#bs+4F%XN8Qy8rMayGLX63uE$nIOH);s)PB|6{#1vmqzH*4G?{U zkLpl;v#VZ+Tj)L4!w#7Ry!H=wPb2buV@!ezh$$xh^?z03E;oe}U1bX43=#iz^*oJ& zygFhJuz#b*xlItXeDryi<4_H5HPhTjAGlXFMdz1jv%&M;W?`tfJW*453O%yk)WN$x z^zuh)>!$+@^`@{c0esuMmWhx@8e9YJPulxvf5$W`q{L)XQDY~X^k;YdZm!dxo;D88 z3f5<^hzo;vwQ{!h>Ax2^p#&jUbjDu|Sj*!Y!AXt9(~;U%e1JTs$vyD=i*;rEhZoku z4dvd=BW1~toWqrznwP^PoVNnE#z1?i;!5+bEWEhi)DF%j@a#Y49c|ryd(JGv=k?a{ zBT0=^c?RTt*SiPrKl#A9-4jRBE73bXr5e3`bc9(RWBeQf(KMn-cfb>D6IhKZ_V`tJ z@95p4?KyVam)4Jv!P;1w7bAf1)#&@jOvnqNJ_P4id{$jjuX$hk{goxL^nQ6B=+RM| z70wp9Byi^o{@#d=`wv3c75fUeS{ke~_p(+ggcz$gja{D~HT*EqqvIdp@*ofP&IUXW z?4V3ja4kI8{gT--{CMXR+wNzWzc}}A=o1J8!1=g_bt*Dq-v7sDM?RZGT3~mT9sKF! zwTk{}*Kzhj`EQYWV*%s^?YM*M!S8Kk16Z$AXUV_x@+W5d-+Ix6N?`kIq6yzfH3IFG zP*5P;IQ2vijU8ata`n6)eVjkT>xhWPK~b0OjS3=%z`0tYc{&u=ll*%*P)K&Y`N5=7|B%?z#IDd9Sn|?YyNo$X3EUM+s z#$c#S&w}$S%&3}GnTya|-bywTCFGJ3%Gx}5r;b5| zysf8RK)$Kny-L(6r`Yz3&}c3pMCmJ>+(QM@A508AM6ulZQkdkQA@2~g5&RyO+tfK% zv&c*HWicVwjh(WVSZ$RPOzsiU^AS(*{mVRf@SAYwX{AQq`7SJ}<3pCO1I(kgqhhko=Dj zF2X);bF}3y13|3SLr7m@{w_{XX>|3FKM{uUv8TAvP|tx20%=JXE;x z8z7%0lc~EjDJQ!_Q=yWz&jrulq!_<&w#Fm(gINr~+dh4U-X?tjw;4H}M9LG3`r+Ls z8$V~|x68vveEFxwG?lIYJZ6;>zS%?H+UXc zpUL}MX%b;QO^Sbbgr$lH3WExP*C~<7&a3lMqNr;x#}3HLcDe`83z(pag}B#b86>rE z&c+PuJzhH=XF1z4`;auLg6p?sdb|{`x*PnBb&}YbGf8wy0a=YCmeW6Bi`mSD8LBTI zyCBc4B?wPuM z39Kjab7r;yPJ1`y@7J5eb7EQhAa5ph9y|{cIF^8QJdrl#Zh-O&UJhLyKfPq8JZb*% zoJ$MbKY&Nwij+}7XgM&5jf2&C*gP=z!%RbZo*%WN?3y<~9Hue=c?bv*=fL%QXKKe_ zEX-ebFJJcY3ClGD?YF!3e1itxL+Ov;{AKhcx?c1Ch}v;$n2BLAZn8N8wJS7e94~e` zu%463M()!P0B&tzar7Z{#7e z%~LhxATmPf|5`IEE)_q0+Tz$(<(-2Wgggy-h+*E~eB;hLo~n{4)O6~o^H}lc=VW|| z7CD`K&tLbZJ!pU@kS#58dQ!=Aj<`aSGd2`YW&TApImMA}c3ubhcHf}R=%4rNM>shD zd$-Ys{Qcr1hfRg~W%7@}w`29Aoyz&0uPIf{!S^L6ukf2CSEgI4%i!mId^t~2vE36x z@b(HXpBzw%88k1UEkgOIy2rrwBB6U*In+}=KMI{)kNAYsboe89+9^%=!!zLou)T66 zbdlwx2)Gsa9X3b{>F|eV$d7GKg?<-4x3D|xY9_x(rrY1MV zT-&vmQ8I;Y95>xDaJ&>~@95%P8UOh>{L{i`%bpWsjnPiBv&{~Zi|u9dg8ka&7no~M zK4REH@ckwL(-}=k)6Fen7F^M-?$Ht?!W~Sffs)pU;E4x#6*eGbp+x78@nSMbY<&z|Eziw@GlR$hAefl*+)q(c>Q9r3y#bcZVHy1wk zktE<I)b7))c6zV#ow*y8^v0KC_v2q|j}6F6)s6ty(|QWc@#g5b z?+`^X8Kuh;*sPUmRlmt2!3@1E0?&_YXB9j4$@?Uy38Y`T*Gc;m{k2UXDK``BYY_NB zKWqC=We@TyLz=+f^A!s!!*viuMR{)2uCYBM-iT4GlQ;`&@k8=Ro(9P0h%Yp996#OB zP|w6byL#izH*@SYTozDEzSJJ)#*uXRcnW#=46nfFqpj~m$Ze1%J^^d)?JQv^j!aK0 zjOw_~jL8@Y8Q?8Wi+x$3__6~wlkOFstoJiz%q-+W$(h(&^`NV7zr(-4y+@+qD2tI)E@oYenIDjqWM3zv{r z2Img$ALNtM_ekv4iK^SNPU(%aE1msd|4ybg`D0IbIkbV|p4|1%orA(P-eN&PyU zC~3B8Jw@*CYpz$D@9}uw2|qv{ig#fQFkXp%IhH|+^3%JGcKS7?78b83K+kQ}Sd!b$k?tZ`Dg0x=5zw zc;5FvBmNZ09P3$W26+C*sg>%h-*HXcaXWalmCet*f?rKu6_68S4GAwi9Gre8g1i&P zO&%cMSSV6fSlkYi@E)D>I}84xHpACAlchg9HYTdT^H&qSqN>kr>bzX34|}Sm(R*Hh ze0aC@QTHWdWk?Wq18=|;8RX#;S9<~;Tcx`snP{BFw$J~2U_VYgFYov*CTWH^o~GWU z0Qo5MUF$ak^u_pjSPS5dkf$-&Psh`0<4&f^$Y0dH?-($r{CEAtXlwv4n|mwy>2Qv# zjP5t77E$FEoGG(ne)0l-%`)>O!1L4U9Pp?6;o5aK>IZ6 zhkqa)Wd>dKC2&4 zpb_o#bn2-mnw{fe5zdr7b1{dnV(KVS1nb?k!hF6$KXhA4^{-vF@^NUC1svJ&YcK!* z*LcBSM$X8E3%DSUgJueRe#Ob9?JA~|*-1DZJd?x_^4GZcH_Zck4zV{Fv4DJdvCg#Z z(v5N&>r+@HghO@If6E7mDR#P@n}<(|5d?fAo^xZ?#DT1@L~ygc+;$G$C@<<$h4uGr{+rPmvjpCcjHBrhU%T zX2-NF2YEu5Ii!HM+Kz&#$^WdxY1V4(=kbPPQ@NE+|30$ie(q23{2$dJ^U+DWEmDz- z)J}B!c@v5p${PXK%l!r_F^EU52v=WnzvwDK9s&(iKlf!E zlV?`Pc%21%2wOM#`wM(sw8fdYW(-YoT?F7wt!W2RW=#J7A8{^cIBp$r1w>@Au;I#T z_V1-QHGfgv^Xft#;sp#?@8LQNJ9&ruEoc^nn_XsCZ(y8CKma9!%y`_)ADq8@LpY0s z{}bWUCN*F^ux6sN?BKh;?;A`(YK9$GjEDchK@aj=x|6~6+pEcgzv~V=!^+{4YA%^2 zr*|TkaWNrWhg{PZmO#FdJz92Ry~wq?Qm>!=QaXZJ)Qy~drS$BPUvF~_C`0L|Ui`a$ zbE@Ea#^K_)LWAs^Kk7TL{AVd*i%zJ65B{EBh4VcA;Ci8FOn3Ud$u81-_6_Z4e&=X{ z60_oj@7eiHXT?=<#g79I){qCEI0){)5MabprZwuF6KE!-`m1G}i^JQJ zz&EY#4tcW_9$@{5CeTlbb&*Jd{M+a43BUfGpPirH8De}MOgk-C20Zm1q{AbPZocO; zE^3rx*BZup!+hVuvJS@i)bw^jlGR52Adi#><_x%>xpF0rHoV;mR$pn*q}K3jlkl0E zO^07{eRi5Q0K9P{WkEx63UaulN$yIgE?G_Qk2bd3fkNz*5)?y?v|CYukSC+k44!9o zdkoZmR_2xIv@Z4yf1{Gmio?Gv=&WGL>2Ul6@PeZETM{D^GHOgbP^I-3RZ!O?UfZlq zcGJj+Ysa1L_5KcmJecCS6(C=ZUBF&Ock^wio%~;Wn@R_i=0$k)z~!l3nBB#G|bP8T8vQ{&U~m53gf}T*(hnDX!wSbt56q z8iN+xk7dQ9JQ%~dPlJ=t%uAqN8hG&hxio{fB~J9-CKT|}F^|@oDSINkZPNI<(xUuR zn}(+Ru)Dr1Q$2WN?D22&#z0=2qYaE% zGBV>B7yWG($4po8+B#2lN<3fyJcdM)X^xB?Ed_U_+oV>_aF1_(#M3}9g_?ldrY}# zA=1T^=gF#z0r`^BTMA4RB!|X`?fp_PZxx=NujOI1mq;$UG1c^TDRMOCLf%cA7+6mp zMvB?(5Z6~lpYJZmAgLH9xyU0SmB6n_8ma;B7cE}oC>39xwH`?pN~TO7`nBzRnF?28 zI6at#ZR6g3-=77LN73U2-Y+GeLgQ7p;m*|M0>@X0W3HxS>(q4AqhCbhNqPeLuIsaI z%)S?(QIvKDzVMG76GR%qDBkqHY>2a!vzvnZ1z!kxt0ZIqIGIqe{fCdPep=U-y1nShS1E04f7dhX_$%YWX+ z`UtpQ5HS=XJhiiG5xe`;v_gH>ppa2ca)*VEJ4&yr59F&(HNDw>*FW@Q5Pd(f!T7uL z%o{>kr*y2{6CE#B<6^noVkn<}sRcNmiYN5nMQ#lS!Y&Q8QEq#DA)7ANlCHtuDz-sg z2E4%_Da=*npRs6iZMxx1a=o}6orxog6s3A6@1B4Y(zG) z@`FqYMv4i;LIxNiB*f0fJ+t8YCe1tA!4Z!_}qDyP_HW62Fv15Iagx`EZ#UY+E0=aC?L;ZmiPl zJafszqbvQZ{vKR^z{l1-9+dxocGr!}f%R1_i6w?Isi}0< z6PMAohc*&Fjptt>5An&5e83B`eC4Q&++AX962mykFDjMp`}HRDIovtbC%tx{z0Af$ zaf2{|cA3{J^fuGRa4-=T6l!T{Ji+0xzMA_%ycz#IQ@R$gKXNP?3mUAZ??joCO;CVe1vf!`MxB9PI-#RF%noi$5 z{#3)ZNkW#rD=IrT@MfB#=z=_svTkaiz1NR(2-vtS9LxlN>F((^sPNu&nbE6tP!%1Q zC;|ECqr?kIbl>2cxvfo8rpCM;%!_EuN~!V@-V?xb8)uG+9DqE6af(U6`+4c!m89LX zsIkh16fP5MqtnV7Zh?rwc-nvi?icUrXvopGwtC8Jb&A2Aljl)AJc_G|jRZ;^U#O{BrE)!&(48Qvg+`<-37%$n`$U5J!S&1& zRSw*I!CW~+!ff@#vWGgV`|!kCt@k6d3=d#E^h-_hFzkDUab>L{>p)A)1*%?Soiom_ z_n)}(tJuoy*gF4tOh-sy|0cxk3NrowLDN)2RHdLLie%x|A8*d(P0~DzS)>2s!vtgw zx|bI05)H^pz-b(E-rAskH}8LSMRR{Fs!uOw!mF|ZL`@J_BO8SaPu%Wzgh%n}zo{n+xV6g}LAgwfvmpVrO2Q8C$o zyc*k6a6R+KTp8!6UiM)j*Jh*2d1g>?8{ydZvV(ivM!yj7njF>|xiqxtKR#p7dioG- z7q66h%?5A!GOqcD*o74h_1-4rotTt??+;iWs`5ErDHa2@aeaSuR7F!JrqXCbX(}QT(S$T*@td>?A_E(0>8>g5ID!XwMvK(^>Itv%k|GVn2U38PyY_AA4QG zD_$Ns+Hwea@P*6Y0PodlNG{dg4N~-Mt=#?0_1DjHLLJhxX!gyx82p8TtMFRy(JCcHPpQN ztuK8qY>;2wVF5Qg?`srN;#169EIP5B{ETk}*S7X*ybYOQl24X69Vvcq{JAAjU$)z6f~s zp|9U8;~TCCBhR;Iek<~*PwlnrSB1ZJ!XTI;rw`+W!-PCt@)mIY@ir&X(js&tJlco> z?UP#>hi9t}T<5GxbQjSJaJ=XA?+pvC@K@U-y85`G@X^!Tp{jlRLp@PP#yath;$@sN z7Ub>2dxGACQ+^d+$*On7SKEBNcS$(E-%}qDhL9=lc9-q|`Cvnlo7(>=<|L<##uN zZCe_^%a+2IO1GoIoGtlj(^}_~DLmHyn6+m!$F)#(8YA+8@Bcy^c>M^p-N5hPn5zpE z70y2}xu1@s>)v`1GkioG#d_zIs1Zm5&Ucf^7;MW)eZsD0L==7f!yGAey?2m$FZ+K4 zY^VOQho7J(hCD9WBRb%IAxWYPjWQ6#=#-nvGN*{V7jV+BBQiPPohk8kVmW` z!w%#V8S(yrwKZFOUIa%aY@uU2{5*=Mt-?IBI5JxU$XEOHC)^?F(ygJ|2`LVx1XruZ z8rLxuLmIBR6D$n9WG})~$kXZM1m}PKN@A!kM?G^%v_Z^@NS6Gw=J~^JCWv++t}wfR zS3MWCb2*t|?QbdGn@he`Imbblcw-&RLwuYiy;^+2RKX5;aL;*jfqb9e`99hQ8?_}& zACSsBPTKq)(YH@`cc*4)MFH2BaiWZyuP@aZPHjz6PA>*xh0}+a7JA3v^Bum3l3<+f z2ns`9%N@Hk;GyeN?kai-l%jJ_zBDj%S--EW_dMxpBQ=@Z#Rl?qnb&8JFs)4_ayu?J ztarTVuxRW%+DDeV8COC+>qut35{EoQ7c^eLyVS%gp|W$aj}5@M>yJ*LhZCs%f9zoP zZ_DAZ1w2NpDF=@cgRg{%Ts~~p@aXptEYVh8TSvt2P^W(OXkO%w!xkbRE!r{P! z{ZqX2Ej>QsbrDJP0A2p66Y9j+fw(dk;Ne$O&uJ!2G5v0I_~B}C_T_chvLE&Lg|i8T zGxsAY2I}p99*W9q@O{K<5#qNfaNToBn`}NYsI_3s{$Vvt$s$=yC;_Zr*6?<`C~GTi z-cUTpR(Yyp_E*RPvua?*o+74v0ZzN#b5#w>htgjL)}uyhE)$#MceA1iqP;eXs!>?{ zSTm>yJ?u_zoRfik3Sl_4A+O_V3{D5$oaaOwvb<~l zJji&_N{mcJ&!6pABq=((P|5IhO`~h=1jjN$MiB5A3bZ8#CRe%Y+GQzrPFeP;-}7fz zV%CrmUCX-jY0Ld6)r36e(_QfT!Jm=QCSg_L=LHkr!u!*|{7Dya8`& z>Wq+84*g|@m-q4$D_QHz4+uKGD+toVBq6?XN`}79W{~$g*c05pqLjl-OqPG&p8xx_ z?*2koD(Yq{&)u;Cmf*^@4)6vHKeo6lVcCnRQXs`=oKkv z@$dR&i7^8GYcaf?ie zE!v%?Z=M!89Vov@L9J1~J+L`p1$oBgDBybfJfg4svO2sx`|8nhG5gceR21UV*3g+m zMVKE?0FTpJ;P`VN+)ml2(M?3>bV2J7g(hK zPKUL6)%w{T@=&>G{DJmP;b8Ar&=WHzBcI@ZwL8e}AKCHWf)f#7Z}$MtzvO;b@@VN| zH$GXR)1LdeletRE!l{_%k%`AdlzQI#^E`w9akM;V5y9f3J)AR|xM#REc(NC~0!T``B=B z{Z>xF`kZgfOMnmC{N34K>Q_icSuE*R&wA|DCCWC-bW}ZpATNGS8hpR?6Z7fF`SzoI zRwJ^K`Mf>UI8W`SBF)97o1=3F^v8Cd4d+{iE*_CMhSDK^Lvq$bk8+eII=nypT`(hC z*+K9jkhl5W5PaUyJ96=+6nmnY$iEDQV-z(ZIAI_qnTC>+{MZBQTVhjQsIeJ+GM^7{ zpL$SN6xT=eopU_Qlp)aZ$8!r6lxv4W9zljFSWj_oL5Y~Q*NvhiXdRQJ4SLT>NA;|$ zUYoBc^D+R)=P4L>F#Tb$gvD*sRMQ;h-spe@1OEi2E;}GEXQ;9?e<~XCJ|Av^^~=L9ZY73;rw9)AXmbKLPLmv&=e7fzS5`{}yRVjduKc z-)Mn)9X%aV>(Y0pcAR9Z{SopG0?Rppd@tMQqu!gp%Src3r#5rn+j_QaHK$(nE3n4% zD|o(1roHaBzSz#aSUwEaFLD|sJ(cwmhKlv<@E)Al-JIc1TiK9zXG8~%_hu9v>V>cz zR`^`6>!w22QWTWI+U z^~?Men-6*8#K~a){=ga~$P&g7{Co824`UJ*m1nHZ1x`tFBy)9oR94fQW1XTW@Hz*jvy^)IQud?26kGy(Ci9xu*kFBt=zXw7*`u$c0s$9sMeFnAvLBJgRBm&8gh? zT8@`_Ui7gJ^7N1C!1Jt^b#Z!YgQd<3&Ro)v zc249co#*Ft8YJ&KNCRUI;;(RKuC@^IRDS&PPKUO^{UMr*C>%L^f)^H!eY3Yg^^0m| zZChMB+vtTt6g+^ZRbX|om$)`C?uZ{ATd$RXMc$N2Nb69Of2FMD-9>c{`vuC!erpYS z4I8JI%}HeV7DAt;!jWan6-BU70+@50Z?ith0-k;Kf%oNhgS7MA=jm9vQ4y*gGczx~ zHV#~O(#%MNK||+%o@UMj*uS5yN+m6vqG*5d7M8`lDZaY)$nN#(4Zf5-bp-eS>SHb9 z>7REJlQLC3AO9xICSSIpzG!^dFPz2O^V3t#VyWR@fABPe_JHow?0RSubeu$5J09`OA;^RadO*|rq-YGT!k(x}UZyzG;JLKlj~-de`L zue3gVK5U0Px6W~}y|xR#*=AioNsX*zy`=kk7be*;F`tOngL<~fZQfGnq61_d!~Ofxbw3exIRBfjH;p)DPQHCBUsj*7 zZDqt+tU@-&MDMIJ40%M^C*b<>{IW-5bDhjbtRh|c^2z@0>w~a78iPlh_$+(y`;_&f z@9B}X6899F*z-?zHz*g(W@*VuD>rj7-d<>8dlq>9^IAPVg3pHn&u>9WZ5HEJAJ$rB zCo^h21Jwyy`)_YVG7J%c>vwTwinxRJ!&b*?UV4_UEnj|E@x*dlv8LU$n{@jmXIFL< z$~T(N4EBe##o)YE*St0IgTtB3uaaqBrU|tA!3)AkO=)nyPIwFP<)_yVa|wGMyplI1 z!b^UF-Wp}y&iwx@VWi-@IOU~0oPB(b0eKvsVr*#-80LEeGCQOCjWIu4ZDor<_0M3#>Xs|E$ALpiNIf`4GSJgX5L>+20y$ zX}^r5w}|Hby#-{}zCb;?k-~UtcxxVB* z-QoH&sck$5c_cFjV0(#0({4ip(QjxExY3?fG?0qo`qPIl!Ld%cR22bUOM?&}Ngipf zj@*iky{<8PA ztWpcg&JlmiLNA^Fgi!H}LCC;WO zvj$YiNUKywsWIMucrz)tI(!LvJD%0x^Bd_>Nb>5LO>>h_vBqkQo23ai`)0`{?Pok| zhCaY+@4`@03~We1yI1xZ4Qe7Uk>?hivOMj5US@3nM1XQZrW!D>FTTRRz0a-tCGR1(eQ zeV`nF19=0)(C^)t_{YC+M@E59dlp-yRHEEp55-OZGla?^uYU2*(-<%Z^Ens^MHOi80A@!0g4=KzjVG_>DgiOYi<7ZRp-`S3YYCqw&fI-@%R4Avyg@y<9;8tT zjDHpW#&*}ZV}`Bx=wy=o7I|8~`b~iWhCkqadQ0aprb{<7_t?#)kd#t1k?&yL0((7j zv>zmn^yj&Q^F8Fj35h!c_X`X^>UgGlOyWd!+n#CY-oVwLx86T+S={DOB*6FEl{GQR zcg>$dv!jZmawSc{v;uPBv?;5^{{5`rr|cE&GAx| zsChAxP4HMsLF%4^?FKP_r)3?VuBoTyj+gbuEWZS#^=1I`Hx3VwpE3}_NsYZJdUmZ6jU}pmyOFQ z7!wwtI}=I4TAnEq{c2hyvX1aCUrk8?(B3Z2`_E5e-I5E^72E9|TgwXeNT0%)M#ENb zrziv7asFK)(pB&I%6UXa#&U(^N4~5=T~oMH-kdPWTsUD8S|rFLZ_WY77i`wM-%|MP zc9<4ptxtk8MoX=9hr05)s=hC~C;*OkcUT14Cdp`39>}|E5ZF7Sz=PzRD55#`sb_o zdtSQs@01NdK3g1)`lvG>?d?C}E3ZW<*%z~_k@7|0Xl^sFO!BT|cyTZxkEam>obS?P zKUpI$Yh`G033!2Klr-_*eOK zXbPL!d)J}WD*p43<^{m#!*-Y{`LS^2#)0OsLN%#J$5!dccqWUcm+#!f4DkHTMQnu> zOsNb_jp`qcUk1SNerQff!LG^j-eO)b9NcgH=iw#sr2_ry=2TrkKe(rDGsE|)oxRc)uane%?qi<)CXnw%LEshq+HZ+(`3Zr$RQS%S z0c+%KCWgH)9j%l155IIN;zQobvNZVo<}W%e34dUb>3jNSo?I8FIbM-2?Ui6@c|#Gi z2;jXRD znl$CmfW-IrS#i(rMU08$C(H1gCV+=Crya~s7*H(2F8xt5z`#cT?W12F+T%f2_aomN z?5DJGTF4`cU`hf!kL~D=d4rZ6(i5rgJ47|U|CjFel?U=`%uYwZ^`IUh@B2aDXgl8C ziG8%{8ii1MKfm5nRJ{RlNu8zw{g=haGMgYzpl z;W#)SUKC7=1@_j2jInsVeJVfApD25@x7tJ{r7F7nopS`8e#C`({|CKJ!|U1O{8Wj8~))GoJAlXZ4C*d zkK``j%p-pGm!ZyA{qh+-f}+?kFYByi6`lG+ZdsuA;$4!0`+o_+nmJ`15c@yNtFu#x^JnL)B99C{-PA1Ym(XvCH zLP!btykSjXZwToHuT&WZ;rz@JNq5Alct-UNwusAx2>ku*2?>X!{XeqWwaE46!A07V zfw;8sq_iHMQA`6$Y%+_v(%g^-d!7K^f0l_;hP$cFJ-T;z@(FY-n_m4X=y>^rVIepP z;Qq^!;@fY&_!oMLLvda>&0$R*gM!BtLJo0_x=Ce7(N|dB&miwoc;YE=zrgi%*%&BB zMuv9Cq~^vP;KBc%4wI;8M%u^qeGqs2|GRt&?8^5qPGOd;(5(Qk3|*1>6H6J5 zdZwpYYnUG$_H-z$_NX7u7(UW|w4#7kodo0&b^MA0ykAJM)ax)ubiBJwpJQxt)I`RK z28(ozt6}%59RRPDpRG2HYb`JV7cpQj>sm+%X=DCmnWywpp3vswT+Vo#6y!~orGfQn z{7aH}58L=RTHe8`s`4IsWLOIYY_fBR@CQ4CfahFG<~nmOaWb_!C;7*9N|rd&`Q75j z_}dOOc6g_{>X40p9&BmiI*@OE8)0m7xhSszmU2jRnqkE;0jq!bW5)WHRxWrxjA!!; znp)6j*tdN1KLgY)l30=?DZh4e+T>x7Z9CekxbsLu`RYH*gU?5}Hr&Y00ZY+`%Ovf` z#o(ID!yxw2jjP5l>93}Md~&&!$r0I9uA>7ctE7usB2{mWaCmd8VN@;=UKAF{vqk;$ z@S;e;`R=vlzQ!+Ug5k#zYbi19!FGowIAQVVvW!SvFL3|fDldf=+h8;$-sipNaHMtc zmhQ#w==p)uDP=RN*2{;Z-?C6X*N7Cb9^gp90`uIi{*~AMpmdqctZlO1;%Zf2PF?r1 zAb39UVJ$mYO7VHTrT3NBaz(`@_OwQ@683SEu(^=XasDX#l?vnu+ns{zOFbd?(~p;k zT;q&63G$?>94|b#%irfw2|Ez(fct;J0@Btj+(huLs&4g-><`X~*PJ8WNv3IO=Qthh z4M?!x)gcdYFdf{l3n8w6-&))Rz7}^Llkq2Hum|+4DKpGEhm{SfBR_%ibeW!?S6LypRzRb>5p8%cKF&s2QY!}Ew@;L;5|CFA%t9G(e zu0&UkC~Zx6j@83(c;&6DXaa0z-Dkj4x3&()N5y~r*Zql%cV$?W65OyfjO6TPwn*gj zfWvmbPp*(h*e%r#Tt5`A9FvrD75A7{*1q zf=BpQ*3l@V3pMycw?iaRRBG3i{w|lta9zZ+e{zL9hmlIKJr$+n!V>mo5nhvy;Kl#5 zmzPlaBJ40~4c4RI2;s+bCl)7q3q_#0< z*G1xvSZNMoVusKG54t+LC*&c#zm*5dn|#rwXn8)8p>eEPbIoyMu3Yr(K;kO%c;cb~ zAMk87s@`k%+o{s!=7o!?rDQlewS zGgl%=Rtvkl!Yw!9Y9e(0jN}BKXSmjOM0w6WOsF6Fjb+wxTN^lEhjGPS39{WR1`PMF|&#G7-t%GULuudSKb zpPrq}I}>&_=4gA2X)bf&V`X)bwmgeE zuJ9ykDAi@Q+%*gG&V*&b@dlhjMZCwqUvO+GE`WDP`S{zVQ4;gKZ>KM0cFE>b4uw6JqgJ7Vd(UqETkT{yfO@ z&G`!UA3AZc%6&B~)SWNi*Hn+#m~e+ZoCrFFaa_}Feg*P5+TUoOzD45ExAtqXy2Pc} zy!fop%~I^@ZjE}U`m(9!%_qo{$P)$Eo2uOn**DGlJ`cGbUpr{f-5m*EOS|)AD!#ah z2lL(P90|`=n3>~pI52@2YSY3FPA9HiFWPq$-mF4zmYZK{9I(bi|yyPT(%B)pZ&L2v++Mz#P3h3 z#JV|-U_XsLGq8B|4R1WfD%!T)$-W%Qhp2zu0NgKTCkua=Eq#=kZ3I0-WxBDl6zSw9be;1Oqp(n+8n0jO z6GyuD6nW9iMOz1Xjv_SRex7yjgi!ihrIbjN;@>H4HV3?m+&sp-mo8d6?%?}Ymii(Q zyA@TZh2!EvyRSw|GEAM!5HSf92PpEJrCl_F>i_dv?bX5SH}99Z_DEN${f8voYi8QF z?%PGNQ}V*LyL-YUxc~O!cg)8~HgBT(Mo6RIjCtS_>!%oTjI4sw1m z@~coqy#8BV_(rMv+km%FOb6tVYaW2#C)E0jEzUY6s%*3Ff!H@rro44~HIvSWZb|S; z_7&jq2hZ<}Um2G4RLEx4X~s$bxKJY5C-0qXZt zGOZGaMq3A&0{HZe9ix6hg77RnaDRHDfK79?HrymIg->}T-LUwti!x2XhlyXV-Wh6J z#p13<-H?ZvJ_n9puql#fbV?PxS6cj?IUgW=={0rW-4 zBfO=_2fWL2BBeJ9nbvIYErk81vp%^64CZjt!s5i7yMX7LlD!E1_z$WUlb=;IVXavS zZJ(BETFX`YL_8IOQHqmt5~(*)AO`$gQUO<4snAn6@OtPbi-^6Co3juba~7`gxh0 zhvNB*%;sAp(zR3DQQc}zwaQc-8=$;6W893h;f&up1EwPiqQj(v2~FiO|E4Yf;DuMU z&FhTW+=RSpJLr2xe4U{pwdzxnqw-ULfiR!*fRJCLWb)DG5fZs^V{W(-^NETWgoI9A3#?N}t; zcN!JpHahy30dJpK`Q%_fhXE~*)#ES1y*qu)@wNH$0dF-9>B(yx4JFnRxu!<`#X zh^apC~QDr5~lzcXxe%va4$C%ZDsF#Oh3yOM?cdaviBJ68SH!hw88?G(Au z^8|S3CzAR$YjVbu;n}i(o;^S4dtl)TV_EN2J%BvKsIDoXJ|Yv{)@E6A3enws?X`tU zo)B2l;nCd6i`3;FS^?g=4*nW8)>x7K;ztFi6^X9X$fBk7#{i5M%Z!n+uH6)TXOKrA z@@Wb1_Bv_v#BSu*t12EQYFkmduZFh@XVRIRhl?V7znUeF=&Y8012i5~=^ZUE&wu{oLk^Ud58x%GeFt zPJbP9o#IR_%6Z1&%2NK!rVz;Ibe;gKzf_o^UHPGTT=5$lQ5>Hfjf}TgLN;27)aycF zp$jM<5fwX*`jhiU z`7dsR0ysaS3<*Tm=4pX%4PHHR}MGZ<$Mc*b?~dZoA8<+G^TIzYZk@obh^SyWD4g!rQ9vwKY+47KXWIIrl@ z0xyCE9%t3bzmSJ-HU^H@Y$NdIh!Paz_HS8&aL{r|6@C>>{<(y)AdV8O06dvSZ_-}E z8JpOLBg|bE7uvwV`PCRrjwaKjJLP`#ZH)1!NZ@|JwQdzFaQ(a_$LGWX6?l|26pK2s zg3(oMcErPfDzEB%fd$t)HMURAg6A$p3*Uv!2dd3-NR^hSs@YCW&CsNW-U2zzQI z;$ih`rpl3CQE9c9o>M53A0p)Kxf_D#1;&x}Sr61-7oc0jY4-~`BBm;STs_#!NHAI9 z1IGslBvUNXu?yR;s?u!Ycok>y)N(U8eo~W%&}TB;Yy7wQO1}_LA;4T@lEmN z^58JS@o}5cn&()-W8<=KjKt)Z?BO?>|9PFG!(e+=6p}?UjTY(=AgU{ZR{KgqY=ita zFX7y{a^`OXz&koup*UtX^VPFrvoooyow&XHOBjUU?p%_~j`E%tJ#+{Y$~WWe2(Bmo zA*v?VlJ>;beDrgNZrd}VnZQ>@^}onkE06_0*NJlN**~e}d9ctnrQ0Qh zJnYp04dDK}_LXL8KKy`jXpZqxn3sCtkt4O6x8nzi;cy4opC1nfS12VWtj-aVwDbhL zBrGe>`#I65Gw6uk8t6hP*rQJld03%eyq{pQ{5Mq?=#lqJAOCIc(`w{DPRjG3%H?4|%xHkCK4; zh*NhIU7OuX3+spp%lb-tmrA!=&@Gxm`>^z#3h+45$JeJ3h3Y6c5$Ii&`eM(Q8^;QH zZthm#^A?_LV3OIdSatJ6FL~dT(o?(Bs@8=*kz#AZ6FkpvptFEJF7=j&awXXL9aB}l ze8f}=r<3(}1=phB-jnP4b8g715Yh+N|M1c{8Wo&+R{~S+Od_;je_wgI#A8`gzgzdd zo)pL@&1OKoHe`N|NDwYR7r|b{UlQWAXi-BnpPJVob9X;Lzyo=hB`IM0;{Mi0?k(>l z*+g$9&G@PR97`PHI`e*R)SJa$;CNj2H_MepCH)Vi4U_;|1aGyGK9PBM#2@DgK^RKk zcPXCp@j>31g%H?2Gm9V@_~jj6cr@C&hCX}4m^?EIE0Y;e^Y4d!!Tn1<29av{2A_2` z>j}o~k8_F}XNb$YzsDrZwl>}(_4%+z{O7@<2!Z2+ydX@kKuwD0w4a%2S>T+8saxU; z11{Fko^(*}0_8o~Cp6o6|N6Kks$WdzQStpBmU%T@6K&p-rxxrgiKtO^|Mxl)n}Pd} zdHU>>D>@oZoU=8MD{-R7J~^Wc9lgAKPa>WY@N}^%(WD5QbIXsY;;%PkOVv^zqjt2k z&~0ooQP4MW%`F9?@)9lcg5QtbA1l5O_mkLTj2&;a5mj8HaYKh$;TUGsEvG>PJajjL zIW_pP@BK*DxjPXpLN|05ug8#Zj7g}Ym)-~t;T?%U9(*UR0FWUnmF+*(v-A*!M>?HYMl(hJsOn4Gp6>=VB zs-gHY^J8zFu3<$dAw1&==9Z;T2J-Q!sBa2Ce~?r(-TFg-8cTP}a&kp~J194Q~|in=>6Y#*PO0ekVjOIED3nur(Jr4l({M&ni@W+yS`dCM4e2B zHQ>lTDOx52yzW!whO54=oshh&=R$M`zxO)ZsRYwzQG;T$0s^=fP^z>c?;FK2xL&6` zjqXXa7BjNWIn<7v(r6eImew51&^a1Y>^2N|F@BEyO}qoQ8pAzU%blKP9N0Kp&zKI} zD-qJCFLn@QQj8&wLS%yy$d~NwJ2{FSPpmRA#=0+RJUBr3*clu9JD05c-7(-r$6?$m zEfuGCt6mqLiwX#-%{1=4?Ow{9Nq(_E7IG%EWCD43;0nR# z4bLky`A~JHrm?D+j~DUP`0P-X-OwRoaGEVeSQ?F;LF8-5%e9OL`wwEbNfx|cI?+RS z8}ygnn*R8qk6%aNSxZ%xRV9FY5j7?qa*gHBH}+_><4`-wSKvB*3Frp5RqrIBI45RPOtqXL$rZzmfr74($Y<9xqPsPTq%zRG?(}7Lmkh zdPEy(g4fTRn>5DO%g4nR)SdQsEqh_AAkwq@7B-a}Juj#1DT{q*VTFd{Z+@~rII;-Z?u~BZfY+7&)Yx|P zTaTMq)C+_@zrSN@B$a9~>YH*fMQViN)yJ=+ArF_HvmNlVwU!!VFJttEvHu88*F}7E zZ`^+8nQxjHA#MVmzp`G-H}aVuC6T0-oNNzzr}gjG!}+(3c~;B{O!_~ws%sS`K;Dmx zTkt#sc_!ARzvWiPF; zs1nFyPe18(Gqj;U2q^qahP=8=7O;PFD~||Zl2Stuq;N!VdJH7_@@tCn%T3LvU0vxD z!2A8C;o&8Ze}r!4Us6kl<9-{H=YlKKDX>jhxWp1E%Nt0kkQY-z4Bmf7-v7QHmh)4L zWoF9caL5*Sam19aAGs$_p>G5%ugE~Q3SC2Unp|%UwPYpgrg%hJfQ&G5w zO~U^?_#UE4;QFnr3;dYYY7Z$C)2%Xl9lGp|dCxu-Lfnp!h6e7(^P!8Birjue8KP4) z_QAta3F|Kyw9yOw_bEy%(`^pY(YQ1yA8gAfaD3_@_sF930nHzdn=*ql)cs+%m)iBx zV_c4AoLLemZ{`nYH4|)Nx*t0jtzF?RS#V!!}v}oX^FOw^&{Vj<3`Y!Y#V~y@;Rvr@<{~ zyb5hWp(;Nh1xxy4t06cZKhrtys8@#XD1B$zS=Z#G{%LKFcq@s|QIP0kNnOrZ;&KV( zVe9m50_A1W5j6QzBJmhUX`uh_`yg~8p}_)Ye6Z>+7=OU^I&qGuqqhcF1#>U-7e zzOkDG>jdrjkCfBHy!b=D$^NPy^0W~o!1+0?zGc=DQFT31hq}j}%Ttkv08xk8n%^|C zYbPIp`e5G+q7RxG3WYzDTaIY%5h)YU}mLxF3n^C&p4>jB8w&C6KYfSGh>0>?Voe8gN6cXu(|uA zGIh$8nWO)CV|OcHdqv}r#}fv-Mt9~O{u1LLWSC!>*T;5I?B!!OJvjbb43o7vqL$6> z<3no1C5=^*?qnikal>ykh7}$Z-Xa-f{sQH*VE^|+DF6Qd=I>4;H>%nw?Q1E2vCYP$ zILX57Ap&%gUv5z;Kt3%WzE~DXd)J9)j~Po!NlLU)e9YKs&sTN6kxKB89G$p!{8!$X z9d^K@55sY5D2Q=x$qaR6A-Hw4r%`|Wp>fI>wM5YecwL0GEHI>(SBz>1l4FZ(Pf`xG zkRMcce~50IDx;`B!(ttPyw@2g6oBWtkH?$2@;GlN_Tq^RT|8l+*l~zt&;RkKjJWzpVtYgp z&N)e7D7ZJgvn)H|*OME)RZIgs(MVb8-7Z_Nl+~L0nT9i>yZ=*k&mKsSL=u3Hx5Xf6|<0somCVKfGb~x@IL6IZvX1mSe{@H3T*@vxhrH%L zjNtS8*XiV-Qfpw-^@J@`G+LO>*gL7Z!jX8pQ#%JdpX2kJlsD7`OUPu0m%B{-dJjL$ z$KvV>-mB=o7TuTual^a+JnxGDaDG(S-zGlJwe-U6jgFDx@eo0Ip4t^>ljKogH2V)A zUsGMShOuv9qm>D2LGHOP8hvs7&5g(Czpp^dF!XNN$5^dnLlKXbGb~_p}TFZ{uj*ZzX$$FdqTN|0%BJ->0JboNdZtk)J9F`}-VO zi4*=p-aZyP*k8_H`1axE{a(JDF%=?8a7E-qdPw8yC;T>TaCirJfv9b_uujHp!^kO3 zF?3e%3tCp6wa_hb#0CeqDr&|oklaHa4)^>XP`@3dtTD_ZgU@>&io2wOQCN{e+3UDH zc{jmqrzle`WT6GGaNs27p>3Fi@(Y2KMxnbGYTkg${bE>V@Xx1XyI9t z4~yiStdxN)LCXN)RO1-<{@W*#JXc2CkMunivpCC=T_z&f-JQ3smGAYxaBCXFNWH&; zgYuEBr-I`RzrybFnM=6k*J3ofi3D|2cTPB*Si4B~A^46>!1Y7hB4jbRrTuCg??y4h zMi}pMU|toiJZ>I(wWOca3A5+~4|&AD2f*(~=)!m*Y(EqG5n;)$;+}%3EKMzJjlL6{ zm25!B0(hfO{BF+-h6s|=n8FFPyUutjEJ~H(UC3dY>Fxv!S#8mtLtfJ<4A}nlxU-v) z@Y}yfNBd!XOOhq-qe=46$S?906EOfA@O+S&IQ7m0?{@zSVnQ=O5wRpplI=5BB;Rr?G%^Wlnal| z)TaM=VbpMuMr@W}Y`NEWx&YXyG%@@hlqPJ*BMd$R&x6bp8Oax=?(ejFi53~Qa0S@B zGx8z|cUG&`D{u$$X>o{-;s0Fm?w0DVPr}brs{G(~)J4JWSZ|c`ZGghwRT~fT#Jc9e z@k?N`g>Oqfj(nmeN--7!oZYw(!syErZEEx6A`We$psW%Ej z`@DZ2Y-Qi*FX~%$q7guzRHP=j-jq3rq#VA+udauwMa^p%75oMfeQ}iTZAkLA91oE1 zDt4_Z5o1jMyTk@(iI>Yg+FS*t$rxQGf7fs?DPMf#IU(eQ+^vD@VZ`E+pD>VOxLgKJ zIupEw{is*9#jk%+dPM5U+W;Q3=y|>vB0^3}f-I|tjveKBN`ra-0)6cG&Eeh*kyeXXD49e?J{Km~<@1#nBw=&PumaOHVjCAHGdL3UDx=3Xlbu^EqVX5I_F= zNK$IJjtkx!f|zWCSf& zRiw>Y!TlLb&hD*zNgg-4L|(!@cSODhc?MG&+?$&GuQ@cUKTL_6VLAP=+^@h5GZbeV z=T)_ksod%+a#Kx&8wq`Rb$eK`TBbQq$q~TG_22bVB$5O2k!_CS@b@h5^;Q)}#_#Q- z&)ji1j8cys*43AP#tL!Rd8bMSqLQ|BCBBuezsVVo}f?iY=s#%3+Mp<2)2NfvKTy!$x7yCl)oIo}xh6@3}(C4I;tGch(YnP{>$JIWbx7%^>Q zOehI?E-}sE{tO}sjzh@lL>%7zz}+ycM`S)i@DBd_))2l(Snxd8jGgP8@(;TZb>`OP zaRKw$Zf9(cr_F10KQQa9rZUVPNTeappN1WL-WqN&2&!Nj5*sYa6mau&@XJCgxVsvZ z-fPag;{*9P`fdUvB&No?1=O`rYZwd~ua!IvGqLZlP4&_68`{k1{_`q+kc0gZ3d>JX zDSPKQ4mN@Yt10oyHC6?<+nBxsEt$nwY!EroZ(CN)z zz5WxDo{~@hdBi^W;C_XK^+PUtv^`7n*Zyub!$BIJ8(r0)tF2j2Cb)JWU!H+b$kB1n z7onfNzk7VAg^jF}EYdQ4cI2C0F&~}oC&y3}+Fg%;y6K0Cz zLzpa)zjo@Y5~T$Dw*$tLSF6#^t}#8*_Hn~am9oURca;Q3HyT$9DpqIf{s;egFP&z< z^6oI8V))@zO57#1YGJ-6=%xuFsqXud^x`mjUSJQO(Ap3Wj!j@0} zQ`09AjOJ}*rF+J)Ib|r{Uzv1F;Q1haqW$1vAnKH7Gd!VqRyW(k*}3mP86?;K`nf6K zouirEg{xf)I_I5A#wQwhUT1`1>E&{-A2t0D7MrEU6H$RYrX%QlyTp!J`DyxkcBPpE z3^R8yi)B4J9;Y(G_}vc{O~7L^P`|M6s?l=|$X_{+cDqvAmtJS)rw!tLB9x-Vn8iQx zpGTy30FKvsW2917s<+NA$&(eOlY3tm4u%(EbJzc$W4Xp+bYbHaXxRXV)m$^!;v z%CZQ6_ueD-*LP(z(ZlE#3ucRr!o5}1%+sCb)-6VkhnvZ0};I3!N-EilkRjbhT z!I1&MmP-%vh)aK(0`-xd(R!F9Lq#ph(D*Zx@lTw>wHZU6w%iK%{1)xJxRHZ@G4&EXL}0w_)tMB_ zs}DuXh$NhzrQmrfbOEf60ihlm8}wZ^l@Th8{wO)htPrg06Zb1hOWZ)x%l|wT7dWs! zvgT@xxB@W>b9DaBxwSdEbHZ*8=~pODN5xEd0Qr(#G3Oej)#QDc-E{+&Jt^Su^m}== zM?U#S{yT#@ji@AV0_Bt4od-Pui+IC+vYZ9^j>m~K}NC5Z&_Zio!MCNQoG_- zWL;o$LLfZBQ&5+PO`miG*8<9y#5xR)U)tY&8I*wUKpNuf%|}k3Z9pw~;)Yp3%An&z z_YLr3A5J{0E&_7LY#03|R3+Aad3-zKd^!>o^vUO!7 z@CuJt)*ABgjH$r)8<&*l-H1_1Ylw*af0z>l%Lg57w;~ zmwuzSd8^hE!X*QEhW|c0i=Yah!Hi_JUZqnx5D<t-8$E>9XKF*P0FeiqFMf|%>P+UPbYswNW`Xt z`gAP0q9@a@Qj#IIVMoaG9LfXte{mnT1~3=Y?MJe$*#t<5SwHsPs3rAg2lDJsgZmW= zO)RMBm!lL~^dd+5h`Qxr;z*5bGNXCrcZT%E+)@`P?;sEE2@WGr-uhTy9HkQ}!Ej_1 z1|Rk5g|f>bRUz)1*d(_haC{X^zmL+|C?OefKo~c*G-)dd$23gS_1SCR&{gYA(c|HE zAmkwo#)9hyIgCU@6s;Q~pA5)z#NJdq743Q=d_#Awv|d9w3tYdZQhU4n_znJG^4!B| zPBZR)<%0dc`^ihT4DV9%YzZVCK0w~{nBQQ3bc$Fi*h^Ax=2}i+2>a4lw(tjveS-rY zO#`<2C%`j#>veJxsMRZ+=e?p*X%W3YV%J2xwLK|>mm=(ZLGdIu1o9F&eZcw{#na2{ z^{#g8k#MKQ!w*dF+f2E5J66n}e&Scd&zfM!?uIfzEr3`gsx<~umQl$=-6sb+JA zA!zE$qSq=u{VG#$EmkHZwdqy4{$?zbBsUiFaBIRtfckLA@Xafm(V<*eqfx-9pVd2X zf5f#}tHEw~_7R-_25qJO_L$KR9X-u7tClvI80=47&?5`DAe}$XqT4%*tx1Hu$~0y0 zyan>674>cJgbl5{3pO^M&FZ?R_?*y4uu70{u@Z3os#&P{^RR!x?Ar@5N{E}_NBxL@ot6;nAHUk#N=wb9%a5Dc0GtM_l;`e|T zXWU@}(IR)~bam0e--M%YgR!zx^oh{@h z(GRDm`mjso&oA%iGySy~8350$3Z2fGWP;O9)XxoZ+Sa5Qfi%~S`ArKN|7lMnwG7JA ze;$)=9k`yowyNXlMI!c+43!DbF4Q{cb?tAbw6FEUlDk#l_>UrdsNuCy66Qd1`+Rq} z1Nvy!3IB(cV|DfJjVbFGY(M%`C?AfBKG>e>SY;`g#LxI8)gv|9U$RP#$?pBgdlj_O z;QM|R$j5n{dv?YYjtoBv%S8)kWk=h(kj&71b=e;yN+yGgYE$x`w?Yb?zc-T=>mDFI z`-Z&UUuIipE5jv)pT#e*|2u$Y;5p#6H*%|U5N;iYSLMBbduo|N%h?Z;Fw7bjI#pd` zG>1NZlMdxGA$$gop9u^cKK+K*cq^~d6x`exc~$+M$GY@j5I>jPd)1QLq=L0J`it1w?=x>XLwz#mT+oWw{tszWQHDk+hyT*#9NAOpwG z2WMZqOx7)F3w7H1UcOtGcVZ8>k1?X_p>QyX0=&-NLEl}u2BNjUPrl7#I@xOSH`}lD za(KlnsgFM*r06yUPP?IRvc>N=4*x$or;;DOAZBt^%fYa^E)5j<_@O*?P z$y$t(#*em-*quLqEgZCcRZRIvlRH}#2j6k=pd*aokPmqY*e}5T?I31?^$elxsg+V^ zBDeH|rlxs+yn$P7D`)0cMIfJDUpwYExMZQ6p(zS83!xY?^rRw8tKyn-b~B@i&uw|> z#gNCJk^_!k$h4Xt#2K44`yN=^&EJm|48_-;Nf-JEVI-$>0-hze&O>^>husrAohc$y z#(fvPVHpFYee>j3<)sSZEYDcVA&*G*v>YgJh8N#ap#j6ESq!|8X{&<@14CpN#N19J zbQdpheQ5QBAgg&_caCGnht4YEYQTwTVtf7HH>8q29_GD`3#KIa0(tnR91?){iC2aY z!C%(<-`)a}d{`!4;8p#R_KUxK@qvHA@##SU%lR*VrVgeWvF?IEBumn0D$W#hp7lSS z6uP0`k#pbv=ZWR(fbAb=*7fk4q>p-ibfj7MG#3iDz1h(QVPSM=)Q7No zFD-)bf3VE2<#mAb)m%fnJu4;zWd&YlOQG-y0-+P>uX&Uj;iM?+}R}Y+o9+GG$_hY%;tRKbH@q*`LbJy<;%YpP1JRya4xW zH}f-O_{iOoJBYnaKF)Dho-6*c6CFC45T^68O8tGwfj0PGeMC8f{gJ3gpwTrJqGd%)jXHwA+On)*QR>^o;zM4=c$HxPFaN?gz=cc$5qe!CQevP6bDp#M2Q( z+gAc4*WiASAcD|0uBLs*ofo^dRbiKUG&`tPx@ydS396lpS!cAv@+TpWh)A>-@Y+!x z@l^e(*NSf8^X^tsH!%f*dRdF$%f|2a!SN~O(~S9a+C4!W0d}q`gczGR%xDYy9B+1g zJ=ZIY_awvai;(wh#TJ~;c(zh8m6T2qOcFv){T_^td~!g*29)=U-bk8V z7|o)L(9_!;m>mDMz1a4z(qdK_aD@bsaxfIGOOSUr?C}K1Cmg#$K`fKM*a@pDaVLv= zU_QIe*O65G%s3;T3Gjr{{P|w>x+8043HKkf#cH`zI)!i_1|^qY{O3(`ReJYT7xB=Y=M;UFr@U)q^uzr(y6nwq!GABhtSh4-rvn3dolvqaAyf?_-4T z_cT-6#89Yeu~R_*l7Wy!6&_rl%&?lK5MEC0Df>MUKb+vyWkW4$sI28ltBe}BDzCxb zC=m)8=he7CFUoD1=mkkad}d9Vpyu;>Dl`#&_v|Q6H2??s!|j< zqGx>_8p|W@P9e`xg&Hhx2PZ*N_-87mQkPHceX>eVWR$q#-jj-kyj6SzE-y@WA#RSn zJ7&%5&pqt(PyXNM{cpDvP=~7z9Yc#ZP1CC;|3KbzY>Q&x4|qbhEAsOW7ZF^S=u1>> zTZQe?o%RRcuRoltH&#}Pb)pQ5ANOn%qR${N zi_Z;guOcv`@hiAy%bO2Rvr#V8>i*Jw@+*ho`;V>z^?qvr@>iDPMF;#?0f% z#t8=8Ltd&cDL7y7Hj+>3NH)9_!;OsQA&N+#t93rjbisXp`Dq!PPjlwjz2L1wKG9rT zwYfGA-54;Fptfh;ermq+mYD{fPmvH71>El;d<<0q>LVqR%$@*tR~n6&b8@^q5#Yf@ z+t6MeJh3uNd{WSUy+-wmfxUQ`;zw!Dl#Z^DsMD$$)_HwC*W&v{aB@j|7gehQNq4-!nh0Z7^{WDKyv8M+Y|*f`nnHs(D0S;| zjQ1eA$tNpxeE*4@Q--Zyyx$HV^6WIz_nR>Jc{t_!QlBY%WUfYAEEqvf6V zoI&t0P~5?HTx65u67>1Bx-DTE4VfGZZ0dwRG(0#7J4xhZWGkfzA+Lbg9vr{O=QlIeP& z1~Y>KYn(s?dCv)v!2UO3BTDjh;|dLI`FKW{jAE4><9_Q2;zG1hu~HA}$#dWuHUSy?rZVj`9CIj+)=#{G(lZgs+{0=zNm!G_7tpy=H~s zI+KoLlX5prJQDD}typP{Wd>pvkgxqfx5w#Xw-|DjNx<>E`V$LNMB?3V(Av4h^ql&+5TZB&M-?;92M9(djd{r6_Ym%qCe&dyn|%`xaMlfB){ z?phTRSgqvrJ?f$_xTzrzjzt8V532m_@JYn^OF3LvpN1DF{{!3Yt!=_y9*y<$A#nW^ zJAMXko4hwor`L?w4wm^Qi7oMs_QfZDu!TGc1sYLocch)bHn=@9UcDV>z4B z=!p}>wJei%rmZc^(yaYjpFM%{>a&SSExoXoSXveFAw_?c>1%EBmee+Kq_cI}{hdf% zbQ?G1^(<g>xk`$~@2D{m)c0p7%}-qY@TOZNIftGc>wx3Gd(>C5Ha)~t{paiF zZy%PSmWiuNn1_4p} zNh(Xj3G0<P?$fo0TdO`?JyY1#OuL_`XZw*UWVV6pj`=VWMxzHMWsM zKat|X4cS~Xwg=y#+OEwS zpuFw}RBSvdxd8|xgRG^M1ZH*3NX=w|cga%yUne(9wp|t-ATIzXSOoB9<3n|-@O_@u zZbiLz7>>BhE`j&@iWATOdtWI7@aQqpr`AxdwL5d;$)lB#a^EH23BAPR&Zf8c+1}xw zujA(odBnZe;Qp%c?&Om82o=5^!dtnxLLEyvT7$d5(FZ}430Y^rE4WAWHn(A(F+b|) zu3?3^Z!@rcaU#wd zd~fX8_kQa6U22F0WvlM5-qI*OTlAGGV`mlPD3v0I2 zEr&%WgXqX1iu)k<{Bl}7CdTKlc^|(i3srp}X$Q%Nu zf>k@pp=92t!JdhK{Xt?sAjD;g|xzrZ7qN8VD`T;wN3JQk(O+yU!Vs=-ZKry z1)zRcy~5;f1n1q{zoiPB$!NRH7a;k5p56O1bDsJEDDM{fe7kS@$ny}h$UkcPH`s#h z3xivTCv$ye_;m zJkMkb@qtBzBDC?=dm*V`UtTNUQYqeNJ%<;cV(^PEg83Z=d3r9t!1-^d$N0U#$H9K< zCT{h{AF)5_YiP&=-o(3WK6?P?M@ZVVrhF(Id&p%}Uq)~TBA6T~6}?J>(f+o>vaqYV zL`+3N9-cjC4^Upq{F9Id2Bd9MJbz->fXJwD8pE?2sZ|oVjOcqH-}5z#d`!QK7jIu6 ztl?`q9f~1Okd?fbq97E}-22?>-j0z3dFyL`!Sl8%Bl!fAyQWRB1hbFg0g<~}1#CL+ zohHy_EMw&W4^wx5?Ec0#hv44GOTE<-L!QI?H&@Yj%EYwC?>|c#JOcjn@K$`l^=A@C zvD`3S)*glgBN+81r<`fCK@EKbhJvbZJ;;F9!rqQp-GeSAn1#iJEx_o}=kW8bF&rfAJQY9plB3PGFJ>eVthvli z!kWq;@0uT)ABAT$aI8khyfQXiNbGOToQeKp$O1EVWv7w*#tFz5OCB91Y(UWwhxKN# z_kp{6@ak$HPyh~&GaUt1TzS8%f|wQVDs5-O%`S6mC0< zD$0TVwcNX}2%i`QG7$Wm=5$k?&U;_R0N(IPOvuZVo8vptPW*cQrdO-f#dX-*Z_BTV z6hBZPw=`D%=QY!zgZTmyXmx+&bi;`WTNx;}F@*i7CCIMGDRgR{8o36%aJa9(uh@H^ zt9|iKvTRsSS-FW)qkcIZ*kjFw6(TShbNruIYX$v&t!k;nTeof@hVcqbFD~=q@-#kz z`v&FqP)y>CFMzjTu|h)mrJt5b=-|a?!yBfXr(?u#{AI^H`#y9fWLNeN)IjBhHN*A- z>US^>^H#=FalU*%@vavEtARFeut#g10ILG+J1XEcTZ(1NVo}M;(-=QKHZ;|V+1>vp zZ8ya45^{U-D{g!uw;uBLSVO_*&9C^3ELHHHQ*T{ z6U-{;;?YYHAr#RQg>cY*>N1-9{9b`?Ld}E^I|gm&KaYj19qf-v_-4iOYW~{bY|fOBJ)rqv^rQ```df5qSt308`@sijhXsg&ivQY z13c;?Y*Sj`et`ZsU7)JxOWEZODVQ?8V7Qi@%gA~qgw#ThHuGE3w0hJY$a_+|(g)PX z@NMSPsdE<1UXxR=E}7Uw z-lo@tcwL%7NBb>c6!P#qzwH5@V|ALOsezOy)r=+yBv@|H)-5mnbNOvO* z(t?1}B_Z7%f;7_7A>GaQ?e6>cbI$MFnVp@zb7yuR4r#cTC@Gq`zaS4Gt{?o~9Ip`t z!KL2fxh2g8EN;-54#qAso>iEh5DB6s1K?#$ugLV#>%6#so~Ft(%WeV_KVg*ac5HMli6}`r@5l6{z%+D#=Lxa3$%bd> zi{apfrp~RXB2x+#cK_;m;MP3f4f3B9uhsuB4tZTAp<X&188eE7EYm}$}S89yi1 zhRZY!%-8oY#IKR+lH^ZA-m}^$a6jJt4jXUc*BxG0G#0PSmvII?ndYC-_jWMz^nbnr zp0eiPM;2u)7`^+XNz>i)3#I+6u(hQ=;kixY?}B$xk=HAbhoD{$*8i}0dCym@n@W{E z32=6BrGs8<{BldI_|>G-{ICFcUtuG1h8GE*2jZ+PF9xcOF*}7u5Dn~l7Lf85bj5_5 zDQ!a@%o8(seFtnFJ|6skuR_ptEGJ-6hHE6?Li*f!gsK~;Si%#v!%@Z4^`z~p7g8RjG!~k7#t!M zZz5sQU{eaPeQE&=n6=YPTo z$Vd~4{2wdNt*c#_5Pa@5pCJ>z6No1L4YXHegv{~#5qUfV>v4C-`<|bgV)Y~8RqC8| z6>5dV17@3ir;vxIRtdgeaWbk#ttN6U{LG+P%QX;g;`H0Mi-El}tpA_m>jgYyk}Z?# zw|=*dvfus^KKjKm|JoJC`_>&1_!@VNY@4HI>H+eIQ_x$1`z?8>kA?NY{b&Ax2u2|M zN-&ij{a06kebd>q9!J2-oX^AhhA6g?b!jT)<5Vv@YA`#?``oCjc6qgeWa}qG-xK87 zH}r!2_agH-UG`ozqV{@W6#IV7S)lH9j!4}R^3%)c0>D$}DsWrK`SF8}W})S9zXC42 zrwWHs{J5iKh9c^z;55_`1_P|u^(VxE^{`LQXY|zSfez%Wx@V{kk18przHnS^nmp;U zPvH8wCkJ zoE9R@#{#lvD&pFsDbd}}UB7BGfbaL*ep@2x@O`dklBDv}^m`hJHNtWVxkdRj}ow-Kq6i~!dk;>QElHvU)1#wfL-D~DRDt!*4;{ob{!57!Z^XkFzkEhma4oWm(nBMj64&mTOg z;o_scZqIDctFuv@*sN=m=C4aJ6`O)eW=D)6SBvp} z0(sA>pD_X+1KjLL2Rnh~?ug&atuwC-j^?wl8f6!b(a1h&|IaYq@MG`AQ8OpR+lCVd>_p2omV=KP=1bj&p7$2IzVJ(}rG`9HP8qPC?bz_K zu4En=C(GRe%N~~!o}HY_kL!+7__YQlc>V>~+B(vYzs%8ytlYoBnN`>)VFe*YpoxmW zK6_sJxHCbK9`ayMV1j`7LbsH%(#$_j5c8vE5XGuzG!L-{5r>%k-k?_j&s)g*ma>1g z(BWX%!~Jnn_56*ARE_>ZZL0dH6$h<}O2t_k1LQq?uLtkn77RX?_>M*G&LE~oO786s zU1tKgWvdr3TI=0lKJMRh@m1`V)q$*A_OI^Mc(T5(LGA#rjVs4OcdiA~JDm1ckcanX zvI2-NOM$&m$>SmgvtFHoR+g+!*ip;lKnWK2aA1BD=)d$o0n747lly1WNL$&rpPxmw z#l4rC*>BiJYl%(>h%Q`Xg1ntXGjM%$X1@$WzUy~@BunGkAEg;cL$3+HRNJv1oKgN`QY_@$)4C_yl~keuQ&qw-ljWI0Ex&@-HjhR zU0@QvlTna0@ypje6Yl$8rgnh%P~np6wj}hY^q8NR2S3+8KdzoHWO76lZvE4gtr+L! zA^s2gUYlYW6K`l%c+$+E zY}w!%=D}BN)%q#ia{^btH!vt;_n(Jv(wo0%$Vk`4Kdu849m5gQAlOMTu^+hi(TM+DlYPk zqaF2-+f6`~e3UMLc&l((nwZYl@1l$h+@Eo3(I$=f%JLUE@(=H7M`heQome^AB*}mq zikw<)Dhjw(0mzHfy$1KoSPMncVQv|ix}N{IW3S7iIMVnxAKRs~RMLtIK98b5OR(97 zzm5}i_$%u-?WdmHmm;8A^!ecCPsZR&KCi%aG02NuoC_%!rajHc+E5d)*X8}Nj&?+$nGXL2J%#wyutOLCEwfkCX(c%Zb+L=DWmW51dNJY~6Jk)@*pgLu2u2Dw!+Y^}=#1_f8;)07~@Sl6Yj zk2y+^H+=dE+)qAu-13L<_{d#h9jdrPgSJ~j#dHA6XkY(6VRSmF@-5{`M1EU0-kN3?Z()&~Fa8I2Q{%tuVR5Yucv~A- zZBC?z5wyZ#SiE|{qTkFJw+AId^s_(if&0@eP8&6ko9%|j0~buOVz7tdRTBkd0z2`{ zp9oU(yxN0z3?Pppgd7}yD(&+=7bbZl4vAhPFO_1|o};%L(b-Px*6lD_0{s_UFkI50 zZdF;W`}F?uU-{Bf);#>Hv~Y#FuYolaJ^?AG#*oLW)eiQbn7@+JX2d`F z#-wn5#_{vnycHc40XzfjCFv>&=_vMjRpYE7C2j=2T{!;@k}_Xfj2kIgCW|>M$iovE zi2&Lg|A*Ltw0r9WVfGVgKr9ZD!LIHgYL1*j;Y0$zvUT~A)CFSgroAoX2^Cp_4 zAwUrv48-@*xx2E6YB2ad=|!34)+KC8r4`!hQR;=IhpNyp=4L#;ALQBJ_k#Zi)bbKr z6gfWeUA7MCSDtjEcXj{&dLrE>;U$~!53oMY^w+!ZPf1wdLu8INwP~zHyi$rD5{qyq zD&=dF;iYd2nE{XoV`~i7BT@xqz8GD6A;9MqiC*ULIhqY1tVf@)^B0KA9|7W1=Ut>$ zOQJw+(%a{GhwWY}(9*lqjZZ`pa`wX0A<@6|Lm=d#d_e%`7y3hA+M){??&J~lSBKWq zB2;yz_N#*&wiSOL@d2;P+rXv8_yaO&Zg6y6yFj_2@VD@T*!bXTj8~3VcP@!`5s>Fi z@qrrXzvQ=#bsYZ7Ju6cC#WJtVe(v(e4BMYmNt7UDfa@(*ec4(y6i%gpkDHb2^@U&0 z>-AoQ2+B^syooRzQS==w_|Llv7zFc4Spl*R#ZD44&yU0is$J-9b>}dJ@FsDg1@!XZ z_tGTg!ZAi{ZO1$VJH{u2j_i>fsHf%hL~wWcj3!N1or*;xq4)@g!@&EO&&l#fXW`_; znoR%PCyyIR&J zPcAPC@<{3W!1~oxjMz2Ycw!hsNpq^=Mss5fK4CW2NFws@PI+aZ|2p#e=OAXNv_}&{7H;$y!m7_s4bHKc{Q)*DS`fLl!9p@(wysa=GIlI#2JqMfss-@ z#N)nlME2VU@V2Npd$3d0hP+9~4^Nh_U$$h|yb-0Vj%N9(@V9ZLSo$Cl@@xfF!TkW; zKsw?7|AVX_y>7>!p?1{zN%q~B(pt6k;&3uofTt7t@OriFXggfwpRHES<5D_< ziw1fdJ)y|adt1Kws_5yw{Wi!;Qi#?9;w!_X`i{L+Qs-@$D)C*#HGLm00W+bBqj#$d z8xLr2=W4iM5@MZ6a>1hWy2LNku_%n}xWGuCow`E3NgNzAqjt!90WSyc*T&$zHG1*Z zHbozu0w#Jvoi-gaWE+cM` zyMnLHpab#-$3wvU%44gxeC!6%=!~95?imliui4B~`iug{J%>N80^p6tI^f-eaw+4U z{_eA1z`;JAWZMjo@!LLC7>-K`wm8u0g}jpR_u%@HO4;Gn^>hJ-)cZgVL-kJzns0o0 znI47Cyw{?@`IIzZ9hRJmOW-XEvzaK@5)n&@ZpWuObKKNTFImqYDd7Aft1%_> zNSQ2Q^0UJ9M++z7Im#cZrO(T$pfF%OXFXhYzzC%e4aOzm+3n~Gc zI3x{**)ZfXM{)Xg#Xx+{v)b;qL1;SdzDL#5^v#z46vpL!<-8&c%x|00;&R*+Mj`Ja zn+cpxd90qPEE&MR*Mw6mgqm4EA*fjp!taq#|#Xi-H{vrwp@F!?OZj;9rpl3HZhw5I9ijkG5U zcm|GtH=-F7V9zn4nP4hLogEv_TzH&PQBs~y#jRGx3#`vVo@GRIgMX z>aWvz*t(BaInR|;6>HBzAOhDPV@T>Q0W8*wA8|f!{;^Jgnf%UTE5(IpSoW~@S>n?| zn$-g2$<`5p5GGZpy02M0VX4vDLotQ+N!540(E*6h2A_~X=lr_ucX6vL z`ltFEXC=W6QnGbb8NrJyhlHcO<7LRBb8i8k=g%}?;a>#nccT}x<<^R9h+M1NOr>`6 zXSt|cB>|p14UrlW0nhDAd3++PlAEtFFYdTrU|zvRC-?@k*vV}mtV15z-+pj?G~br= z4)akKU)}QAZx*S%xrO5Q?UHn;k7QmM;QnfAfy1nsEG}9NaqU{fm-kdhHUC# z%PW`Iz*C|74ajRwrUCP{PJSQQun$dEEERHBraGmT?Ecwr`2TRc4oF7^>sM;A*44e1 zj`sw{Wnw33=qXwA<=<-Ixtdn4K1)okZI@K;K^_s_Cv{+cx$Eq`Kt)KL~y&lIKa-5)YpajT)20bHZ^;QFI?zoqfjeo&^#OaZ>oZjoE3 z%`-Oz#Ku1ygbS(?NZ)wBoG<|0PnYAP$<*IlN3Xp1mDazblyd7e>`fgMwJ4S7sO6ySM~&tzYMX9AMA z)&F)1mrGTQS4i}mwLhYrjbw1u1J_q=LnT=g0hh}w#~g9iL+~WQd|}26k+T#R&V9Wo z%78lI4)Rtqe}MI8*&*eU990*=<`mth^c$q~wDN2Jx$WN%uDgf%fTsjcu7rF&kmsC` znBLFf&Uo9d9j?5*M~FaVMTO8YKTeD{{*=#;u5Zk3Yo0H=1^T zDRDm|N4=uHqXRr|&S}XmXNQ~Qm$z^9cGTkrt6g(y;O!an7wK{hi|G0*E*kNirP0++vPZ}Q6*@E%RCKTqlkGEB$VsZ}cJ@Cd%iVwt77*ZeEz((4|<7hn1u z^6>Y+tpM#sCA+VW+C7*Z|4Z$g^@nF(iHdvy@kbJmNMHs9;K5H^A$_`QW}>#e>OHzS zh0RVIq>DUy{PIEm*K8;CiP|v^gS|FOK`% ziq0P%EaJ2YOJHr%hpJJszsWC>j;sa5XA2+dtOCE*41?07;yA8Af-C2gapPC_&Mnpb zmrD3YqyKLefaB#}MHbvo+2P~l`9s}qur8C%gwq(_+S5>;WPm44dFIbQJ&L$9B+BzO*%>Hnd_8~#(N~HswnHk8*-hJyIlJ1ub%2iATPw| zJy>7Eo5_tOq^tWxJ?`-)JGkmzBlvY$%itx6$CczI;2E4nO2Rf{X9z!Vx^8Wg=a+h~ zKSrqCHJ`#%#R@QZoC}ac-m|MWwLp9a_Lj`So{jk}v1B7WR<$$z)GoIcmkD3Gj5&S* z-qIMt86$@%$Dq_}r2aX0*tYO&(WSncCMWb-Q=6a&6bvfJ)6w4n=jZe1oQOeu$>j*l z8;RIVJ$XTi;k<85+&q?}thWGfuixR+tA(lYdp}G#yX(cSgmcIh^YnFMB`vdFSk3H& z1RdlB_v?Y*^Efc7@c1qj`Nh)9NbfX2GE#Kp8A*Rt=UnZX<_o|}!Q@t*U6s=;?JED% z@Q4j(N~|D69W%@9UbUSggC)Vr{tEIMNdAJ)qpnP1vmjXVuC$>}zr0efF--y%jK!Ko zRB2A7&w!VAeT|)9l}s%gh6IB)ye86Tx7M+RN&5f46QZ*Ey2kLLo&)mW_TPf}Df)5* z*SFYwrjLw+mkaA^Ja17ioI9I`ztUbxgY|5yxio3jOnW|W9oI60>)jmncHd$5V%BV+8E+X<)H_?!UE!ZIMc(@ z-LZ{P=}BXt6cOfMy79`a^)Rp*j8oD!YT!g~6@xsb6=@d0o0D13DCz5Med#xPdHXRr zSi^65w9t|(1U57Yj883KDEILFQ5pZ2=VH~cxFRjCekm4BB&Zq9pN6Bgm)INLLLTzC zDY#y+a7d#N&UvN$_2_wvj*$XGUIVsy63kl%9@4!`Aif_)FV9}xRk$esv~j0V76`phDPS$EMLb1)G7S6j&UF)asL(Z@Q zc!EFDWiAV^KQPJWe`V9MyZCZmrjaGrcJT3_#8cbYpq%+XFAM?te&UfA^^pvX=*WJ? z#4a%w3e7z6Q$U8rSI#9J8#lmHXW2Xbrg%Jt_z;gWvO(uO>FLSAtH^4eSgM*VYdyX}cjPp9Om0hccC1SyF% zn~88gSbtWI*Nx!TN*rU|Z3^Oe2Cq`2Vq#IXq277ShamoCH>o(^9P$)i1iS^VZ)l~A ztxDzi!f$8F!qwUi@3Oe4o8jr;V5Ud$cp$!Bh0V&Bg=io3*Hat@co1M;k2RU=@lT%| zDWe(s>DQS@Swr4FN*(xp+vQd3d2&|Dz`kXYbCh8YsW?hF@9Anmw6yG)NWk0KdP$gD zA$Xd#a;uTW@~K8?77Nb2m)3=TGcb-zww&wE4)PWmb-?*lb9-X+ns#~6kEeHu#8q9H zr2AkgwH-zCz~Q$k;2}FmYZLu0X&-3E*-F3J81J*@v>^FWM^uxLoU7hS>v`Y^d5Dgd z`#^hJ7N2W8enc=(;$gGb`z2LUXMajP%J4LdRK&Okc&kwbd4vNWP}z1_+5d$5`x;Id zoor@>%sz(~`?GwewG-qDc@~`cV0?SOD5z=5be2pUJeOq&H!jS*VVoGp5|d9FHNo-c z5P0Tjh%w1HWBrV}`^zdX+u$o1BzO`s&H%KDtfZcKYj?<7P}c@Mf`6Zujz#(3;ORy? zPyK}R`WUTi`=^ld#gg`4aUecSvmN(bB@?<0uU;)ABv!1P8;#hlG1T|lLEkI>pX)11 zc|o4O-8%R_gpsTUhSBN{34Xo#K?*8g>D()yR6a@*{My6RbHMA$GsdrSKlg1Ud`3Bd zq3vvamrxyGz9%>w@(IoDrA?yEf1ZSg7q~vUxuuQ^S;U>Eu0ug!T(lOk%Ml1-K(XRZ zwZ$0(yrFkCvu~U$IFir~?AgBTpenkXF^(=g8Q;+TMJymKxFd^{ETNMzrZtD#!)wKeYNYArF@E3|xP#4*IIG3%>8UoSLe-e&zMKUybS39YHD< z9@cFG@Y4IQN6$i~wb=y8Chu0lNBc42_QZ%j6UH(n_Feho4~+ch-EAX-<2fX~Z^7lG z#PeM5-laM{M^)H_&KRuhIz=LJikEfmGAs>$A7;lk8~?O8SN|e{=*={1o|tJl!vc8HSSS8cjFQ5ubI$7r???SU&IR+2 z>$$N+8NAOxi!jON_yKwUKUxOnYX=W?4YFI3YKBJWr*dC(9DSHFFt1$Rj$2guVgugy zv#IcWlz|y|Z~nctS?#T`vk#&&A|A7H9_3z+Yr)8?Rgg!9?M(ypUoXzfzwU|mwnbv9 zzt8q;LmL#E%Kj;)Is8k~C;~jRw*{4Ro!$tqEq{)d247oP>0F7^XKJ&(By7-3&a3Z> zt%1Dm?QSsNrE%%Nnn+L*nRPdT`GgWSL?ArbPv00S73hlv&M$-hwpXOJ?&;S|>&6zx zPFjV&KmNSPy+nD?;}gEA)U>Cmg*;>*bqyfCdX=(;Uofdfn|WH;dH2DFIHkF7cpfyH zYlBI_{IqiPw;L_GRZQ97a!8ZAhnhVMR!SCJr8S4{M+4rpnfT2<$V0H$8V5Yb-$pb6rz;MDHswpDYh_B{#W%_SWmX-+LIXa?GT#Yw|3F`Nqh5&8L4{0f%9R z`Kk0(0PWRqmVOb3hjY*`Z8~o`CpWV4oImwLqD)UBnV(=C1-p&l z66E1pAJ7BwsUZFquBdAaTQ6o4!Bb94VbqW#teb>sR&S*s0K6vp01T29XAUi6W)cKC z_`_C@R2K$%6?7-QM@h@n(jJm!$U`XT`wDo9cNOU_ToSL)c2GWN6S6M{zTFHO)BV~R z66!Suc(C=h?!8A}^Ne?B=iF3jsziTK!1kAZ3h9vc;p_7ydh5Rld4$nS;Q5Gi6&}KB znoaHr0yvjD@tyv_2_nX(7UVY?2nX7))7JPr5>)d!;)U&PQH*cig6Ho#kGji{!KJm&n zJ3Hp*QJ&7>;(&JPd0{|~oX!px+k(F5n=0gju5yr6y=SgMH z2|1hZtTVEHr^Y{%|MPys34zZKt01^nOjT`8=AIQ3uX4kO^y!4zm`P=hELzLJe9gA{ zUzThcS6Y%oF|BONJ=tb{k~gEg=jI^$I2M?o~_V27p=_Y!jSrFj-NK&cZ=M18>hi@ z$Rm!j&H&mQN=T+slp;P*5iyO)R-B@}c{67)-;>2$6l9V! zCWw6RIA*EiOAn;TB>84v_0q;%Lmn*Mh!@})W^;bu(+JumN2k^g4pdk~U?FvG#Hyt9 zXBX!LJW1ZW%b(N(Du+6JL>`yhyyF1kn;|8{T#~TFS?CSrN6~p?_ZI!VYYDep#K^{EW7eS!CPq)V#-zLa>7~k2At)StZ zb>vdRt!#ESKf>l11MxjaTi!7as-z-f?Z3T%70^0oonk*3DQp^>v$WD%XCM+qhdkR) zVqm>4NczEJ*^+$G>9efE`vg+)+7omSbSw)Gf-rBeKB>UpG-97(-!r##B~({8oVYKk z$?;E8{gY{6=}Qy0AIeG3AXCA%KM|UjrlwyWFm<)9Ad#`Hzh#Ug1%NDO~=Yu_cnLLEm?LrH2r&(L%&cW|<-LKYU z#%!yo2FK#$!@8&~)c>Y+F19=p9>`?-v)AE;QpgQ?(Y`QXd?xcE8klP|OA!kknao!s zME;6eOf$${Jhn6vKY;ioyYD;}*}}#Z5p@?#I{U`HA|qSFVlff2?gW$k<9)o4;fFk5 zvMca?Q;FE}Px=Qh6qk)G9OFpxGvIf^OE$Y{$M_;ge*xa0Dh9)bu%`#wqon%xYb#4K zc`^^L9ZKACUOR+_ipdwVf{+KFR+x6;s(0Qx)-hUZO{=fcvg?bEl?;;1NzFWt} zBd|vWuYOSN`bT`p=*am-JzlUB9Dg68R=v<)oOcn>f%x39_R872KgW&g zKDw&)n|>De%kL&G%hh0rU-C`df+xyXg}he2SaAJDZ1-w>-YY~4KG9m{!s^4`X?EjB zB_~ySef~OYz}x%VHGBN7g>mQC?b)>dH=7X{qE*Y>Ih2m@PZCiDVU6!KAusv>7Odwy zr?|Ah_gLsUL9g?F!MW;RZz$Ne^Ea@)X-I!TG@Z$M(;Y;!~dX!GFQQFT+?%5HRs{q6}C=2H7Kl_$b<1 zJ)?G_w&AvG)-p>dd%N*-Y_6MTYMPj>hb8aYhJOF&;SQ34@i9{A`C%AUU;m8g@fll{ zRCg&Nx3SDMy6dRc`U!XfU0h*Wj2qf~u5U3ulHn0icKzWi;9}Jr{yVB!ZY9}+r3b~w zcnA-!Kcqr)`cqAp+RIhy3Hs&I9r{K^I}(3p>BPaRr2`%>RQL~gl{ffRVQP)sSac=vRMbbGOZwY_`!S=1dk1N>EJ1HW*+vwbtk z@#?Mc2+ys$Rgz1XJ^cyT6!qURC0UHujU>=-iG)1D=m0LjBe0}|bFiC#)6igkI47DH zI$sBGn&0akNOm)=2Y5YRPo|N*_vT5);d}uIR`0(L_{?a+Fnxnr^F;e%zwP}l3i7JL zT*3XpOJrfGb(#Cu;-~cGD>>5|>MR68D%Mi^nIbG;eM41P4C6O)^qrass}tgf`ZaUT zhcA}V1!V=Q5$(gQshySod0b68;PX7=n}9@Hr-tz65grTeamV4g<@SAKi@7?f;2!w? z){;l|Ddtb9H@XC6P8D0T)ChzkFDDkS$KUV<^5TA;(WQ@u;wx8b0KF52)~e_{mu8h( zpWQHG@-JJ_nZf<{_Ce0%Ze~Dx*Db^Fa{Jkdlw>|wSSSV(k7*A)ej}!xOO?0RSkN5% zx)=j_XhwJ7eub&q?NDRl&2Y3;x`h^ucZ|a6y2@r-;w|2>&phCLc-E?dnkFN((IaLg zF->PWH#w5v(-kU2YGtPXfPEdam;ib2yFf;Tdk?z5L1-`&o2Xijx+QnU3XLP+~XvUr^QS3PNY5+To6=mH$iF2p6P z<}`Xul3(xP2$BdzON-i^Rw_Rz%%5I^=kNI+VyaP?HsndN^b@6I@0qQBCFr%-JCYV) z>&{nN&kK+zLmqtCWeYG~%sUkM>S4XUy}2qFt<{)LB^CC+TG1VquS;fq0OG?m|6Y9; z+&fmit5^p}8^hfE}1z5 zZ`p5@7w5}^6D>Q{{DH!3&!dZf9*fvRM6susu+O7KHVcXmCZ`u1e-2lbC!rn^G->$6 zq+I&;Cq=G?AIu+c9t|@M!F;lWSMM!xAl0C-)_}d7PNw@DU+-Od(TFK&wxIh+Fhmz>E{i1c%ng^#~8#8~V%&nFQ!avoGZxWtAia6Xub=01jvrhA|z$$!Q| zqxDQQ1{Jw&$(+L1S(G|F=Dl-#5#+Ti{R8LIej!$5#c+N-E28FYjcbiXvZ+D@%wFDS zov@o=eMk(wXOrjBYdIw|P?*!;|K+f?Ogcv^A6WzM?5d7Iymaf|WJg8vjq-Qpp zaN^7EA6Mxr$b(0?6#?2SCUut@UGZSagQkD?u+?BIyy~q*b8)Ka@bX_Pa6RP0T*er7 zZWLo8E>ZWwUB1z4Gs2A2Er$d(DeK0(n>Hh>gS?F7Y4G{0<%ptL`uT>N5N8U-{ydp@ zYieyX95yV^u89XcZ;O*CV(=qLA=(msldi+tewt7ZQ((K#czVn*d`W9>NdKb(nf z2d0U}6*FRP;w%bLMx%B>-m{!kJ)phLvS#Wk)7mG+a5~cGx=Uy1C9yfYNXxo78m8d= zTZ^Cwx8-!7&R0^k#aqmLyc#g!B?V#w1EE?(&6z5i>Ru^-~4-1dVb^chR1+GWb5KhH6xj~ER zf>Vvc2copRS1?0y_&Hcz;oRoQiZfSyE09+~_Y1t=gq-@gW4ZNw#zi#O1}+doM;#_( zO)rwG6zHJuZGL<)=FejrDf)cb9ItAIZ`Z9R;Pdw`ERsY%!63B{__pb5kXId90Dg}` zF_P2aCg;ze(S}!Z;bWN01B&$?Q`W9j#Evq?Kz!V59HpWC(Ho8|zkmLwI%2a4rZmcn zao2HSnyoY^{eM=x4|$ATHM~IoZ9QSKtT{wI>HkCwd#QhDE;@Tjrcrb;gCM;#(?|xb-O8d-QV{rtFtcxRW?Wjv4`)g9y_a;wr|%Z zsA1mneU*$*O*3$-jVc`Nv@WM)d&HpX>OyZGhL4pl8j? zbGmr?r3tH#F)xjB_)-}A!h`?1fGL8n%{eFq8S)5qyuo@M#*&L-FI^}9Pw&-+y4~)OAB@tWJf)ffl7U7rx;_Gm7)H+3f#;b#V)wCnoV0y)X z6#SSef_%K4_4>Euf!e`;o)fDm`22|0GxZYk&aqR{iG8%U7kYmi#?wG@BT=^tH&+gL z`ZbF7$IQ7l1wo3w_*PO8TWoE4w8{IS$pb8NGIi`c_op z>P!Q9$+I}%_(PVMQSlwM;)SI<57!Sn+iFTUC*)%)*&IweqXxXaX`huyr~kjSH9OKI z&6}=0rd(1E->pC}_5bXcZ2&cPn-=oqyWPS0V46UZ*jyRkH&1-To*kG(uC8&n(^{>hV{Bi3K^EQx6t`*0CuSxaT{uDy`!U94hv#O@Y@Jb3i& zA;4=6*wn?duKmOC60HFheGu*;!?PKkAQV47a(y50rW>#}s|(nuza+a0I@6SkP4~of zXK821^4X>G>TGO9VWj zuSU)h`Fi(Z`5$R?{QGMJ_*yVaCucvbXz)@V?V0adNJ3sz4-B}ULhFh+uPquPkSLY@ zv6ASvAm{V5aW5Jt9odNOe!$zrk_fVRW1-MwUMjQS-c4b2%E!i7#95@$0xwp47yIQ{ z8uHS3N5T9BZNTO8=O6vO`5$vKIV;KEKG;_}Au2{k!W5p|03NRrZIo%6o#=^<#cOCeM5khiEb1CBqRxe?vro4*O+74NbH+!7B|!|Nr5yXoUT zg+)T&b4%=-F1Hm=XhBLMMo2s=xjd{R#eD1w*Y1B5ZaoLiJwf4;QmZxg1`NkKjA{J zd96N;0^f6Ay7j;Ms9z>()X0!MJ)Zt9t3dHB1$W^AHoeKQ{qt{iM`&tG_j>X)5ML@;R6zYv>}12iDd=~^4~ zjFwK)`LK#q#yHYm?0G-7@8CT|l(3YxeIj~|0eEP$tH~4fLVtge?T>j@bcc8Dl+?)| zO#4|x)Nyb6^W#vCbr%noa%a4 zUbexv<=pP7e#X@0AIeo=JtsBit3Pq0hK88?8+4=0M)T?(YXw0r6oQU3E|8T_ajaW68G< zU&4_ul{#thdudGmwokWJNPeO;fxMUfSzx`%n9J2GE9A-k%~%wEBWauE#rC`^-#*se z!zVg$|KkS{_V5CXD`}J?dz<5IQTy~Ek+~vghQklew}S5(L$xwZA@9v<7u0{3C@dc7 z&2Rs_bC&%6ZYsG@HKpk8-|TB)ceEfNzOtGeJ+=PEy0NcUE8Zui!}V>lX;bfvluG{{v&~ycOi7YB+-Xq3@o-57m;Qp$o#ljT3@TYdHD` zm%1;q?t}eh5d8koNT%5NpaS)WfGCv8r`SKO5=R|)Zh4w8t{P|yi0FTne%eAFiM!Dl zaDC}@>&g@sdEX{f5VaiE2sDLOP~FW`h`bJIrF8__i}UlJ54v49X$`H1w*m59eEE-B)&y_spo&7w}%4(aAK5jE5jinw<#Nn19Z7;LVVa{pjoP$HyG- zLK|}VD$<9n zJ3-zQVGQ`b1_}%I4x=%*&WFh&t=0>X?gM)CIi|Os!fl>C`hfS>o3D$$H%C-VTdO(k znaYLCL)#D8wGf-C_J!t^)ssjpPsm%6u?3&!*fH4w_w^`K-d#PXoTw3k!5)ppL8_!{_^)^^Ihe^N5x1#rZpb&LaQ<(?o*6qz!T5Isfx~5 zQ1Pay`njr-+!m=K>Sl&bY-QL`ZFdorB=|>Y+URR6{3rmckbkmNqdGv(ghD4S9?5O5puAEj5SRZ_`*4k)MSJ zV-Va_A^H;5*Y5eagv`5ppuGn;=7Qg6Xe@NP9F2S7*y*wfQ<2X$DL6F9&L)3!Vt5C| zLLPA!oF8y~`{^9u7N`Hb$K7P*)w_^F&{8<6OU5bwhc&US0C+?G8)jj!lyv)&$m&EV zQUfHSWBfQ&@Z9^^tJtntvlTE2kk^!Y5B6Ud34CZq_z894TGI>O=5%%3NYdV3#IFSQ z@$umKx`hRsr}!LI8co9!Oq{CKDV?D?7ey8Dd3ma_|J=a( zldOauqvx$!UH23bkHk`;+hb^f7kD12ty&+YDzzg!{|ip+i+tsj@`ZP1#^10b7js72 z1xjp!xKg0_+&e?b!1mr_^A8sI!jGTqYJK!C)jh)u<^0+8*@$IG18i?fGe(GK2#tT9 zs1$_{zFTlsU48zZ_%QXf#qakb2nO@$Umy?p`PDbja|@Mp7I10&rg@Fy#tI)~(3f$X zbQtf#GI@&!^k0g;UFH3qoghsl_Pbh#9vh9ks|{h zwgYL2GFdF2c7<(AQ&QOSYR1V$M-__rwO1FfcG26)#xlr5;7$YcdzR9hniQIczJK5A z5^lpJGpA7*gMZN1MjMHS)dF5eSwUl3aAYw;hzB7do+#1#S0s9u2A5MpT#mzxBvFgq zKOnE{JqMUSt5hN2a3k3`dNEh?oU==wnGr1{RXEE0%uj>|_ZK8+A~*9Zs2qi5ud^K^ zcLhW8Pgzudqjt=f+8g|uw6Z5@fIQNO#a^Jjw212Y)YNa0Hk;w4N9J*~t?{D!ago){ zOM}E+f%szeu)EH(#cf!e(a|Fx&U z?oKJ`7Nn$9S{fuJq)SRVrAu1k`*!#J`#I-#?#yh=y)(1VUt~#3effc{&dyfIi&^^z z)?>xCoMkmU4@ld~7dx3;UrgAuHkL+re!u%?s}Klyk!L&~9eP=9DIU-A0V}wD-yJgY?>m>^^Woo>su%&2g|k-&jI#( zkuH+%FxA1($EiKkK^ZNT^B}PhMSeYaZCqCb9O4isW&(7%!LxFTF!GhL7PY za|H6vMRdXU??ds}XJ3B9ow1EQr0FWlevhsn9%1%H)GILh?10BUD-}Vt(Y%c4PFbdI z6^q@cr%{!WAvMgoI?Qxm=1?~~33-i&H55R6engcSSg*~9*W!_^I_f*f@NS8=^^M+h zxw1}y^Q-w$jg|zSFOREDVbM((3F&Ia_HZbaXf(!H%LRR@FW7!BLmo-{mn^^=;k28A@&|a%o2`-gh zg+^G}UAi(98lq?bo(ltKlatj4nyk-_GJ~}o*qy~WzMpn!$=}<_!t;GZjTbtEyw;`_ zaD0b60>ueXMZ^APL>ZgE67M&wa=4-zdBcFVTlF6B)~-*)D&oaX)=U&?*FNJG3){BH zzw!z+>n%&Tlf9~H;y;JHgW)sqd4KGG8Tz{hQ+R|=5m`B@fLFWYv^Gh^XOWR@vIy|b z{6o4>M#Uc4r17^@e=ub0>*g?AhVr}|_R}uyAbN#8{hvo+iU`h!#%uoxZlEa;ckM^$ zx$r631Vm28^7av6C+71l1Kvvw??gY&C8`FqE5ToWKM48QuFo`sri7j4`UB&Fyw5*B zLh*J{7!`Lp`>Bq*HNvBnsl$AHI;M3(#*a2U-$nNGir zrGoLus^t_1UshyCJC+NNo1FCohYQx%koI1`06cfEHJOP~v)^w?P(Jp2%IsYCzV~O3 zWb`a)Y60^Pv-ff8ek6VZ9qA6Ti={PrbM?z?jqAcR$bs(4PRn@@gh-GV#9asOzkkF< zmTL+mx%@m(O?gtQNAM<2i26QD3rR+50<0&(5Ml2GUu3b}1P!WDboo9$H~zTV$LP}a zOt|2?PRbVc1qS31=PPLg@%aw1WG7&%<(tncCl)QkA7%i(daeUTV1+TxaVg~?DqCL<~SGT zG&{2CNuv|XUuj43-rg`I`(%)pg55*|c(}J#fnNzk@f+oM1aL5e88Zn1iXb}OTqu|J`yZQ4T2*TBM^Mjd&A;!DYTaIASu#* zy!|nW5%LIB(T@SIW}3VSqt8P5xl4Xb#+neVC}Uof^YBXGzFuq>;9XSPb2gMrhJH|3 zBgxu%UR7eZ{*cKV|3i+w#P_@D_el|M$kQl={{PZ2y18JazbcfRG^MA8bmPPPC2Cqx z2(h@&8y@ieTTR)kfDc!#VG(MV#pJ50|DCkeWC($skE3i!c}PZmBSZl5#D^=u@eK|u z+loesmSFfjQTm8Pq6D;St3BN6=hhB)MrU9#r^?L~VO+x>Qu`MP<2=51u6r}}%o*Rz*Puh?FD z-GlYD1LBiwO84$eR)pBLUuj>>xlL?4i*7Jpg(fL)WnqaAa>zg)(wdq$;JsQXD}Zt3 zzu#_cppou8Dv;4=DiB`Yef@W6R|RPATD{{EZq&^57w3c-^L?wzU-|LO$V?5$wc6V% zGO-$=F3OO1%cug5??N29L*k+Klm7Oqi0^yngEZlruLmQ-Ho6AlV0}%x%p}$5*=~bG zV3tI7Kzx&6AE|~ufghg^piR*GxY4e_!|G&I5 z?w`6pbP&@3*4O&9+=$jnYV(79{~a@OeKU{ZGyGDLA{2iTKk%U{>gd2)1M-+7Ljwsn{7h-R^b8qv3Vk;iNQW)|d4%or;QrH7#@Zgm&E&PNo)_Ou zl`ULYTGwnTnEF#?KglTo9{;u+<#zv6!Ja;WxJ zwmYA4&1rOMhbZCmNTt?95!##`$a@Fsx()q3Uc)VGcCwn5Nj8Hq01XGMX(q)M?xOmvtV#O zRN!dR$^NVlap(*?8olk|X@mHKf92~EzxAX@@Ov%hYUjS&rF|R!j5lC66fqF|SNh=l zN2161^Ym0NnLc#v#6cd#uRAHAy6gC0wBvZ8s*@l1kFaj>H~2m$ z6dQYgmUhzQW>{jVh|Jm8v%rM7{F9a<9dE}SgQlw;J00@K7Z<_x3h_5NRD6`$?1^cq zd8uZvkL1o5dDM{VwcAZg!TFzcplF^23B$2MD_Wpn@oI-%Y5VzDeU42v>@s`{Gf#U% zCgf2Y$Aa|@63Sfc(OAlZj}8{}31%qwW9yhB1KfVXK4U`QdQWI%QcVl_#T0(dQ38i+>ggvwZp+&}zxIB!jcQ<8kvU7w?cf(c@sWz7Z~z`voEF)I z_1|$af(A)eU39|;0T)JO+o7rx?dX92{|sYph=I8J`cf!4M!Jemqk=aP!*L#^+Dh7` z`{Ao9KeMLYSI9%2lidM4xtAX**UQI8=?94t-qlO8*yx3F9Gaw7C~~&G2E5vfC_+wO zf~&7MK90Y#9dr1?pR0*({HhoU>JNGDE->}G2J#509a8}B;jUsWo~JAwyXoL&VF=;X z)`RyZUl!X^r@|!oycceJw5Hoy$`wv|<-hRLLHKMi>X;%{?_ADWlg*KmDEL<+jRGZ6iF^jGkQM_)fzcETtzxW;;$Ynjgs#P=ne_swmlo}+@@vo2Hu8!aps z=4TJ$Q}~QZUAhz#tou$akY}aH0FLj4P5UU_<5AFFumR;zgObtyC-IA;|TC&-<(Age%$;Oggt& zpGktF+&Yd=D$7WXoUlCROu_m%b>u^Db!rNp>}}sy_Jrt&b{~<8MB7t=`z3NhhX0?D zuxW=pR2-Z(p#Myg`~vy4U)7^KZvL1x|LV_Rf|>ptle1;6C==YDV?JJggmQznAEivVNdivRR zt3sCbOE{SS&Po{du~@;;*vIT>yhj?^VjvOxZFYd?9NNN)dR8v;!*USvcvUjM{TtBT?v0s_72Pxo#_W!=?fKr)NhIil4N+iMiZOM4VGGTC_-I>COAj(X4YbQKw&!H`u@qjxRyH_%`g@wGRbE?g*w& zc{&lo*>0p&t5tnpT)=v4J##ZG*194baopP%G()QInKZtd=GROX3mwDk4sP8BEzLrn zdny*VJ}9BdVXt*JI<09PV7pZuY&tt~F8X!s=ZL46`WK+R2Ig&*I8(WtCuxbQz)TwhCg-1y-WcIbTM2n2hu?*NZ9dt^YZ>@gFi z#@xH=TQ&c4g*9?kKctV8T^Ne=sK?4$tB}`EItZR$K&-LrVcJMYouSp~qm+N3A{jI( z#LIuZtMb+m4)A(@GP}Oob$WM~t-cxg{>ND4EvAubvSKpc_EQc6tWFrrCghP{op1y3 zT?|L~5$&XkSP8hJlW_@IEwG>^@XLMX#=t0<0lWj08)Da0du~Qwx#lgsknXbRpCzvU zhKvbXSm^0(dk1{?ArD4kECKK=DJ?}*q@y!j?1hI@Xy1OSG|p%$>m|N({#gR%3m0t~ zNIX`Do(>qt9;((1ZhN1T{{PR}$hPBmR0L}J2hQjhke7;k0)Bs}FNZtLH&wUSB#xz3 zn?ZpqJLe^>7BOL@C>~lT5TCno{)_kzSyiztU4zlXqn}{jyI&nr{%iREkuh00f`C`m zSCEIqNjwL{$J|t&MO9Xc@`Iu_QWFVe^Y^@ zg1DNP*tz@9D;FI-<1a>IycQYPE#$%C&(i@O(sc>3p3f*>mR^=ms2<7+Yt@_tMmTTL zDh^i_;O#4~{FGzp)G88gQP_KA|!GJoAidb8N1UelYJr= z#sQ7{wPHpBHsm2hXMp)-(9dm~&qZHE1of=Mdeq2%%CW_r18-di-IqZlc!7SpNa$AL|!*2f8S62ZLx#kb-v33yUdN=^g_@%J6k zSBc|6gd*Ax^?|c4LgZ7Ctl;?%Z(e`mdHS%3TZtS0eb?i2f@^>Jy5G!?%yZRm*xtJ8 z3(5cIZHj~Szm}1!NXen?Y>6K60Ha9>g6$?TL;4T7ukiIf!1FEw4e{&`3vENuG+kZ9 zA$M{pMK;3(eFd+=ikBQ2GhHmZUPGSm@e}yG8i-TduSniJUqW~PmfNbBhlIsA$S7EQ zBY70%3pBSu#MP}n)j4aMG@Wj@_sb|F0@+5z;|GfI?F6mcylcA`%Kyd3MGbxrAOOL5 zT&+%6yT)mSD;|Ct4i61?{${SVOaR3Z%->YK8)x*%qBAvj&loh4eKm*vxmn1(J@Y-t z-(167$U!+#fxLUcJupA2Q_o8OmSP&H7;xj0h=5)9^V-ujOomD&DiNA*wbhh^cp&&MP9HnB91MlpVFjRo!DdzO*2fBT_|FT89Dd8E=e zEx`Etwg@wHA5md&B+qZLVaz)ej7wmx!c}iL|L6wiL(|1wA1-?5{AcSKT*61b=`Zlv zNG|bM*C#zfu`5yG28-anQQFrQ&(4y(kfy|95rXLX!p6W=SXeX}d7?$D(~iUZD1 zXUl>vNIh8Zxy{J_+Ot%TldIDC#>5}ZD>v`<*#7&xB>nkj!4|Hu++Mk54l*LOyf|2h0JHf-8K^9KWNNd@b1oMJ53rM0UZeswC_mrKMHH4}%UiWqD z?r*e%Kyhp#Bj!hx$NPiGiY4WlukMfs!+;2$H}xMZr!{`BSbEcl^S06ZTcidJpa1NT z={tCd)C|BwK46f_7?AB1j~r$$Zo8;6LGJog+4nRTIO9ufHFw?76%2Wj=*-~rl$$9+ zo*$vUp}))ZQASpNbK10iLx#ub9M6RCH|S*~uSD(OtbR_w%Hv*4&P`Pwag7eI`#Z77 zb3Y?XrAHkCdE~#Wuz>zc=4+Ob#gvQ7_6>@WB2ZL_MXp7w_iq=+e384M)jf6e@~QMT3enMTZ|G1c_e1u z;P*iU+)QOO@KRW6c4dso7?*b}rpD_Ioxpky za`%J%X{a|R+*cu)P~F?!98S2wmNe7|sBfAz%~`Rt7}LJ1Tf%EDtU;0Z?xT2HW{zhZbUA6dEVRsN_TIG7eW zDq+TJ?Fe|J82ExZudfOE)xIMvurTc^2BObJ^+fjhBrXkR5$JMFRze;^y}cvg*(3-A zQea>UvYI# znzz5JvyF>dH3Pb2*gk87eyXzR=&4wK_+?c0WZqTY4$mL zWN$p~V?olA@V)LPzi-;ru?;mThI8kUXJkMvjEgrTzlJMdsb73telhu@ zK`WL5uk^jlcn&+&+0OyUgAcj|^EcFruPj|0R{Vs-YPTaTDRb`{U!N+%b7>w=xq|lx zh1cjmGi;sTo0wyQWM{g^M(B;*R~yPcEI*{3o|PE(a1TNrF48#YwXC66YX!V=dE}(| zrrCWQ=Oq!}%3HuZVNZ0$3$%B*D&fnEvEH*+ZKjdwsdLP2e6wl#px`-NzDt%dsEXT>C=I1X`C|JG#!mWszmetB7T{5-r~Rul5iiXm<3`76 zWZ0ID-TggT`mw;ZH}!9c;L%C=D&!%GbbSW;uO>ZtoZdjaa3)o^_%`um-IyXPw-IYD zNQ!I~JUtrI!xQhaO**yY6Mu z(4zf~SzbN(><_bCgf!5kKje4h$Gfa~6M%67c^)FlVEyI&?;Z=`=~S!$=~wRtZ=^H~ z%Pw;z<$@} z#gqx+m+4MU&zOina9;oI^(KH$KG?n6FHXfflU-Ju?+Wq|ghg9{{)62|a2LiRuC(0! zoYG(lrW}N_jqcZJC$9jI^Z?;z{@BgPInc+Ri$>{{Q9IKyyi= z2F%<4ye2jh|M$D{9DzW&mJN6*7Ea?oa0 z8b^O&Hd*vEj=nwA2*igeDe>It_F8PGou<}vSHt`w;du%v(xm;ul>uwBvDN||8sriE zzPv@+TdtqCizn(Pn*D8G9FVl`N_Z}=4(+0V1 zfVbx-RH#ieaTa5)H`x+=kougKD<@K^+U56yZZ?jZqEifNj&umc$J1H0Qr$sC*N)o+sl4>N*xMeTt))P~{z|MtX3%%yNWUiPg(!=$bwJhEmc zUAPnfzxKXj;{nth>_+mp1dGJ%xBY;<(F7=&@+VYrx&mmhat+#TAW9K=O znboLG0mnVyg^+1|na2H@tJPO^c%X}cX7@BOW1+@CoA=&jz1`9`)8iTB)dbsu?N!Qr zfgl^{oj6k{`n@Q+Zm4V0>t)6_jp`}pNw9v9WxFP*l|FJWBT7gRUb;29&?L3X^k@Ar z;lMMM;IkN}E*<2_VV;4WVe-nK&)xA+j&Opl@Ax`@6Te@0E+v8#RmBwi4~VY^N1fb< z%kqo2-sDZ)dckFCZmdBwyAucNw^y8Q%o^sdERctckpXNB04X8=r zVhjF!fz3ROcx;Vv1wBN?xI#JlQ7PTkQpwws^Ob}pLIaI?LDfeoww+Y31!OkJqh(SD z;j~O>z*EF@mad7bA1!7n{*y2NM2I_(#|e29ovXvZ_74uc!PCB~y z4$L>p<>Q>O6%q@`9~GqZT+b8=L*6uxIauF_Hu%t}m}+a7Tj#1Zop)SS&OulqnqA5u z)U=`ldU($;v$Eiof6Pb-u$GGTOCBnzt#87?dnhX%JA|xk(uzW!zAY>`-!S`UVmTt# zQ+p7&*!u!u06B+i|7*Cj%DNaYVF=(+2gsZ0#pRHU7e&7g;)v{x)X^fQ_gF^ggLTf< z4`f1K5r;g~NVjmH|HP!NxK96^FVgbaAH0*-pwChcctLJg!%(42{|WFCggZWS-`@IY z+ciboRCu5Yja46|!isN@u+U8+kC2!)zJ@$uo#W?#7r1d`RC6b-K(kcF=kHC6&>huE zA;e_rEhuO40C@Ry3Vv;3f9BU(jE*y8moSud#xsr`R~oG&0pJV ziDo=ELg`8dB5Mr0!~eX3kE`JP07-hj>s{fGKy}29iOhCnfElnrB2LG6 zCGDAQXTQt-J?vM)FP?d-__t>%pY$PbRm&87znxiH5@{UiJ+>#Q6#g|>war-hlqM0- znU;1ZTM5KR$iIewK**%rqCYpJEiNsRncbZBhh6kYu8cFMOtCGg*8uVeDYV*w_()^? z?3*^E=L)VDw*;f3>Vo@d%|m0V^lohkp8$`P$oLvPk|UF=XqzCt&`TNordk8%3atgbF>j4|j&Gwjk zu(h*Aq$j(yJWI@1xyC5?g8n=vK4(Tf_rJX}hdh|wG4T9goK?u5A^+B(hG8x3sY(nS zLW9*ym2V6o(?hE0&gPL3`eE8hh4 zALU}7G}q(p0-X)73WbiBdIzr%Y-4f4;@jNbwQE09gIW*BQ_uej?*FUZ=Q8CAN!BBh zWvrZ;U0<$WwXt-w3;~BSxq27k|8Q{Qa!xeN|N7orL>XgP92M^ZEb(66>^!{Mj9h z2L9}C6>VzoI^9NmM#AV(>dg)=weXQp$lC~j1<&``wpo~Ryhb^skuN-$5+^UiP)hgw zEU0E*v!Ez!{cH9Nqc&!|RYIMRs!MTx%p8@(`?wUIXzl z>e2Mz_F%{lVPtDOKBF}#{CJVhJv2qrI*|g-Uxw*4eux=_K1O9fb9?DPGd5DIe&lda z$krz(mx1w?@UrS1>{5!eb$izA2Feh_Bj!hrA!o8Bbu2^TWC% ziF|Z6b<)gp^p3R!1udZeTuPSL2|HYzDOr3wJf0obHP)4Jv1v|)oVi?e(={i5ZcBqa ziWfFu{vpT6M}>=Z`L@-tcmly@i2h^M6jwttqj~sxk}lxw+K4{|tHXK7Yd<%r8^l1^ zc_1uo%Pk)|Iy%A`>x~%=&4N7Lq64sA_sY%$k5NWuk4u)_nPoaY@dGn#r|SRt)GI2eq%$rFy!XcSlvR+0JOIkXEWkiE&V0C zhHZYIQ=r-47DNR()RyLBMKH`^ykk6fk zk_`!`k^)7^#iKwQkq!XARUa|zQk1tE_%8v`xgl*%Qgvsmm|63 zyf1>^DDWjhFK@NwDMY&ngYJRW)$@fXx>Ote%~H>Q@sV^o1Mz+BM%adHZ_JA%m+Dqs z74Dm}A(NvP6x-)Egw8u}iQ9htOXY(`C@j+~_=T*JhE|3x$#s~oj5nvCa&*-?p%?NR z4l}`eEPW^u6YIeveBwp7$w+$Uk2X}Yoaztjdeg+}y+C|*uOe2hcm%1)Z%QIPd35XU z;gU!@k~-YK27kLwH(v{O9)LUw11Ye*miQDIjY*|`n6L7imK9_F(Ho}9u*rNTY&dBF z=NqYhQlhC&ADPBRZtu)mi{nmHd))G(mL0PrpLZKJyTCZ66 zbmK9&Pr3&a{`4Ix9E&JAiYRoB1MxB8Tsf?yrQ^NkFaVWi1W{mUu?c40ZNK3=McUP|(*oW={S z!L-IAOL#v|<5uqN`>jLM@I)DACxfj2yf2Jg;QEKS`!dBo%&(|40%R$*Id=&~C7k-X z|Id;?y$odm;?oP>6*~;Y_D<5Og>%I=!&iIrmv&Sf<0dBgvrN>koE7OL6dwU)FgPDF zZbR>%@fH#D?3e5n?ID`Z=a@!Iff-h_kLfl8yaOsF8O8=*SmCM-L*d-{Cx(W)I$PCoBq&YNA2MlkTvQ`~_+mcwW2aGS@HxNi z=rg~nkk46_Ni&xp!v9T*?#qnv+Z*Eq^5A|_vI710(iKe_6$$oAT&ii@q-N&-=cK0D zoXk!X!YRhUdUiWu^-*`>#I`!mzsRzTkBTP@iWt$=CvPsw@CW#)`tPXzLLTzCY#iX> zjlH5c3?&g8UF_VKkVh~X)em?w3y8N8wrQh1L_Ead$wnlW7>6XWTb0W(l7e8q#h!Qc zdTil>KM|)oOv&;rShRht(g@3&h!E4v(NR58mG&C)V80B3`6}8*!WgR|Z5izxseh!j z>7?f`rMNkD_*y(s0`Pqjef4=Fj#Lw6kci-{$%rfFn`0i^!2K+N)3|u0goYL=OZe} zL;O*AH2rGEh){G}JmEXa4HO>{u@iW|`N0*c?M9M56BC`cc!j5JZXG z&0~pudFr8U7?1W2C%y7oALJ(Lu0OzdjJR;RX)_bRWxDa|lJQpbNPll#gP}%#7Dk`+ zHAW{Ym=GWGwj7Yb`GzEpu{d+4MV(ApY@z*3h>cc9qpE@M+X5ptc2B@tENo}7-s^m# zz4e6~31lY4o8_J+S&>>|!~4y(WPY(xN zFH`vC|E^$Frf5d%Tm@6?NSF1nFDqz%vQw)^<^W#4@$!+N_(tAWf<(<_UEt)epvk-}7@{l0%+ab`p5KbY%;Mi2j}Bb-|Dxe;qVmMt~O^_v4+jfOZ=(G2m&j z%IWS%X}-abT6mM8Ox-2(($3GCI;B-aWslz;slghD3i41taDe$jhHcXjHgcD%q>vjg zvwc?)lBzw4G#}ygY1DKm;1MN}DKt3C&tJ)i4LLF~J-PZ$tVG=d-TXgvW#1V6tAct2&ahHW?{#1*l(=VM<| z{-)BJHLGcss$+Eh_`O*6aQzc4YfJvfy#4s@*7E%`@NFW}|b&~WEyiJF-p4^}C$42Vzq7wmUq z+knWTgUS)(i-yj(A<=j!{!ex5Y6tLuhq;18U?f_J^s+0C;rVaUb%utV2kFQ1Z!x@{ z0N$WdDDU2>mnG@Le6dC=V?u`Qhl_J= zvK0a;=brNyO1PwQP<%X``{4P;%pOm}ps9Z+tTS5-e_kC@Un%S%_DO5}`pKFAexKFG z3)dtR&Q((@eC5Lgx?H9+f?e?6zKyU;iC*e7zfUPc@{orBcU=jzSCmjG9xLc4_XSe) z^l#<9Zwk0>t(iF(189f0_CS2F>Q_NH87xti4@E)I!!2V9N`*#d&c`p%5s2GTlycsz z|L46Ziv^#5nOIVrI2{^toZsaoJ=wximW15jaubpKX!};x4tV=gh?YHXkv2Z~@Dv4= zx3KTu2P}`F+Y$DSp0*b_-G?J;Lh+3qmVoag)Wg5V?MFM}zN0>_|CSFEzIZqmzhzxW zvtAOO0lbH|gW>iKc~R@BYT8NLHHFWGu=v$TMb6ev@-_?(RhbhEAPEN4(zK=$f4l-W}*63N?pk!I4Nh-NsqXPHen1h$&X)# z)1$FdS~*rMqBRV(mpH>Xgrw|=m1}_^kB@)n(odv(tVk?_25^6fml zGQ`e3UGj>k&seC>yrK9|I#t2(pp4Fce#BEOK0w_k#xI`sr}TEVf0FQDt^@;!sX80jIr0#nJqwOCi?EL5$ z$Rl34Vg%YN1HU|b_0N|us;JTF&qe-Z1IoA6P0szXcP=k5fcE~4cqV=tlp9i$$eE`{ zlg}qD_3Wl%99>^P?DwS{hT~mX66DP&`Gfhdas}qpQRYR5%+_x~p`>l0vI$}DcR0b6 zd1!9pfJfv;vpGt5CZqyuoaxSetVK)a=bRPxqxVd37OPOINeCtp^58k)!SgN#w1$y0 z1`N%d<=!#QzL_~H7!KVssGmkUyLAx&@6*Rmnv2G>rn`KXRmjN~#oZ)+1fo^G7^e0s z{VTgF3>6;`63~+Kav1m9uC}=+c4vXmhxWOk~;H=QsMcKmJCB*-5M@hwdn(%SrO#H{Qv(K z0WV^;-)3?#V&9E3hX4bEE+}1s_x@$f2NU>v)(5~_pjeegpS{!gR6~FGE^U=Ry385V z)CuKs)S$nFWb8og=nLeD*};PMZ!bS%(3ci0IB$F3KLqLBl8x>M+UhX`1WqztX*)5IL3hHvJc2ryUoP9NO>rsHwzrSpSpMt7 zW>{Z4Ag7+nfPRY8cCm6;CD#U&0K^W+`|wQ)oWE?-?7~Ex z+LzcM_p7%W@0%8In2S}Xa~2vArhxmye&(_Im#KVL@^vu#Nz35D*zw|Jk_Va)CE1&D zX8a?!zs;SHM*znLdYN;*iKZj+yNRr_Jgd$#@}H`0==k@unB4h%!1?aGg)G55y{|k8 z!py7fiDpFn_(XP*A9xr~(HD1Xs7(>OW}<8iOH+6*4jSt2Jj;Hp7Aq_o3Xt6P|{j_M||e4ZzZM| zX8THC32O(YK=u0jB;=J}nuF`f)=o*%&Ko2#s{G$|`uX(G4ufAd6>`kpjq5|_O;c(! z4ej-Mxk@y*R)_U@;BID=Z<@tMzHz$17yGJp*Ig_?9^upwcsJe~r_;Ndr z#8i*<|13WA?~1CiC+Y^``#|LM^`iw>@6hYw$ID+&tdHL}$W=`dmKNM!)K~JU(Jrk+ zUNz$ucpidZCQzQ9sH6MhA$7z#r706}7};}o%GgZ0ED7AtPpImzF7UfBmp3`eI(@Ex zT|u(RcG^9vLB(oP&fV&n62``V{ii(#u2(Fs-_)>#3~8av?Z~&l<&X4}Hr(yU7S0fs z&5r@`ofP|?ACWbFZITjlUPehPr_3%E{a4uCzRH41jRZGTn*N{19%2g4$K~-_k*9JM zU_TRd2NPYz2t~&CXP7XP^?SRxt^?lGnQTn_Tll2c%F{1|t-hzjuvxYH>v5e^Q2ann zz1+Z3-}$fqp4#65_nWPv=ULxsNpND-s>ENM%Jb=^pG?SpY2NwzDqDbeo>QL_t9Chb ziYNCi*5;5KCL^f0`Q1Cjzi|%+6A{>72lpY5B4D`#@RASqu=`Yf-xQy`5TUfw+D;{T zcf-4wkF;}{34V|9Uc=-T&Vq_7r9|q}NkH~tzb%`jlP+!ee1$$)&Cc@9}b9*`wV-4#K-V$t+2B;v)>5vcAaM6 z)M`)eGvb;$9?TCce7BHC^c>p&i0==E=;(W~uG&n7xb!L%@4!i&Ea8RF@9_o&OZk8o zjDL2XOz6&s{t)okrbiHyZb{WmV*FI&F!&DNv^M=#;~w%oEJX+JL@id86yP5SAtxrNd!~xbA5$9 z_}S8GtLBm*yQ5?+cI=yq5qeyP#=G#$8pCpt-p-Y2ad}r;1=o04NwKF$iC6eYxlQuh7w~*-@!X$f#~#Jpk>fj2%dh|()MoAK-qh<^ z%R7bK*!D|q-~Zx65sK0W#^d-kF-m0R=>i55LewELG2vA6r44-p`o1WOBDmi3&gHYq zIeLb1#_Z&R|2-^&<9^%ga9eR0*JA$fz0&lKX82Hi2qz!30Pn+_!c)FEdopXp;g9DY9IGS81y3@ilNOU|^)I!d4$Y)|r%4r8n({-<-0rj|zw0}p=OSG5g`mNrVr z3)~0=-$%-7w_1_Ml`9*G7&d4DheOvx zx99O|>qBvyn)56J+rUc|LORGJo&5vmt6ra>#8pocu9M1!9|dz&*`vWFuN zA7(oUieC0kxg9hef7sU)3rCta^8vi`ugNWv?WuF=k0Lj=Rn`I8gGn1!@#N7Itix0t zutDgI43Jl}H3p9FpGymTIkDIPvgM$wqRl5t(h=hc{~i&-OI_ADz~glo`TahD(6?gw zX+}BXBeTrCowDwxwYcG@m!+{LtLE#>kO!060zOZt-^aG*uxs&O>tJ3#9oZ0_saTbT z4Xh!}o4}$0USIZ2!Q>q!^1#`2<;6Rrlg-(z8(yW}TaH<6)knv2GZPlbOQ@~{pMSVj z=p!DXc3ltj^ssuHbWozY5;JmlCG1zt_qn;Rs%ZASVJIJblXw z!S;wa*=lC4*7m5o)YOqBMt}RUkt%#;0>@9XTOr7UGcN$gcl)a|8~XZ6*LazelIuq1 zr)EsIiduP9EF=6pI>1ZtExg(HMJ$JbZPwS8n0jX(JeqRZRAbO&C%bEdC8Y0$#eA*{VV*ZEF_&Leq;M5@g+9 zc>h&L^TS1ajA6;IS{LjUhdh)66b0aVA^U~yQM7O6qIf!8C*=TNU(zN+Qt(!`OJJN| z8u0QsCN26r!mh1kTB;d;oWK>wiT^;FG$N6abHJcgdW!WU)an>unDwFfZg*{-P zI5sqcK}Kd(2-ENDy>cW^4RFDfW>SLU!>HK+>l^>CwKueo(w}IXg%u+GGJ}B&ST*Lc zs=-sgI(G-W&(o{gsHt{`gM9t6S%J>y=ETVK8f6E%qv$WAdv!+7C^R9@m&^>@pFJ|0 za;P^umc2rTCrC5*WI|A5sKrX~@`nvZZav^hqxSKC3Drc|HTABEvkMB`yOMBTf@2Wx zR8fHGvF5_j)q=eHADdu(qv@Wbevg;IZZe`wrz{$S*hqDyS%*f%vv8}$5b*v*-K-am z2NmRGG)Ri+wB#xcmpX9#+4vluHwv6nppKQq zkcJ40h(^lD>7&1OdSm}y;Wj(JyQ0BUHCOg8Gz#R>-3kI)~fFnvrdw934` z*!8pe(}ZkyU?KiWM%Tm)i2ywR;1_OXcwe_sSI-r>@J&eNud6pUeFcs5nVJ$j<4%Zd^^ zt1sJc{I*T8hPQaL$tCeyDpu&HHRRz}_JHj*qp>CTz~}$-$GsI+fH8aM2S!6%Pz=?Y z9I>qz;5}NvWN&0_EiCf?PKvZ*A{YLEe_d#_`4q;}<6F_!23zR}dGk-@U_PDmPmqNr zLg1+rjlE7lf8F!V20RQQO3z%xt7&jOZ+pssW!#1H{L|xJYS}QMg$0MUh6XIzK=(}l zsQ(=u0iHAD5h6Y90pr{3QG)R?Pa3giYN8B@^7>f_z53!OEiQ1qOtb7J@5d%7 z0zDkx7LO=dI^4TA_X3e?YNU*?LJV{zyK%0NH&#LiuBUXpTKb7J&oE&AHVP{;dRtWL z2#;=!?NTmjNtF?3Z(4YH>OhUno20GFUDxzqgl$~vq$V)5s}0YP5nu#O=`{Qxuevdw z4~P#*`6Ch<%TBNOPAvP+8Nr`fiRDB)#C`IAF;Btz(AlgUJ+4Ml{S*gc>gvH=V(3*L zcJH*K=%T8aHI*JhSe8HJrRhEguNTjeAY%fukK0(YXIEzy8DTMPg$&!zka*bP+>wF! z2$+N=oi+xfL}3+1T1wpiS_LiSu@U>9Hk<`iQ0Fh);s-(=+;bvu|Aw@-QTmcrrb{#N z@bCl8M!F5IEjGNE#7yG01z5j-Qg-%{joA7hOLrMn#TJGEm~H{-lx~y;L6Gi}l2JHPCdBvluKz2V7U-KNd`m-%qCPEZ>{`&MJR?e{>4Cj#39 z_8*Qe4OKgFz8%Y>?)^+p#@gGYXxqodRGwSAkQRU|3n}m~M~gjEFf1L|-BF`Dpyp%! z@`=`zlU=6=$@smHcnHKhOD+QM4|ioko{;mgeA2;_r;fxEgD7?(t3x(Ru_V9R4Z!P# z4G$={dY$-MMWBb)h&KsVfu!2?1a%{M^EA}Dl`uyv4C0}%X2S#REs;z(SbaBFeryn$ z2LD}qul#+e3M+HVqaq2KA>g&4#BDOtr?tQPHEYSggn4*hpJu7gNgo>(%!liVPVW{U z@vr}eE7bunV?DkMr^2)_xi^zJhaxJu4VHxV*KmDTD^t}v;1$CXiJeW4SZp9GLRM`8yK8s^D0-y4q88d_l25_-pmRa?4@iA zWUR*V*2sZ)p4a~1{X4!EHg1eOpxugnNZ;U(-~flBKJfGnyH2P5|8c3j^h8yZ z-wdciEcKLE%!kRs`Tu7Niz*?W!X6no-=J#J^q$`MO9JF`AF*W}!OLu=D?ZjJ5xp{+|NQ|&qIoWPjFYw( z{WbGMemBI674yRbyb=z(Kc%1Ee{*C@Ao)$Hqxzk5elOm#)&H)!3ar0RJ}PCQ(5Dt| zpWxwldOKo~7xp!r2};CM%cDwqZ>8xQN)N<)Q?(7QX9f!u^+WoCoTQerV{8p)x|LGj z>4$ga1u?%&2Jg3xx2WvhlzurYooZ7@Cp6s94r)EFa|Y@Bx78Nmw8EXmy%2BToDw`= zZQSkc6Hs3o6;a}^>vCG;=$F^J(W$7;!2CWAw%2L)x8#ps_G4rw@nJs?bYSEaYV&Yc z;eR18claATU=J7%K|I7V9%G=r>cp&!3mM=4R8+UrpGS|5pI=6W%vn>vMB)Uu|DZSp z_`7b%rqxp7&P293eo|;LdNPaX9Np=LT}$%XYahxFL%f}kAK>*BOj*V!;)izKxsH(% zMt`*Dq`1r*=aZ2S{?2*{T#pdm@&U04s!oO#yM_^+K@XH z8~j*r^;06hHxyeqZ7AS)cm$GGC&&q+9S;_s3O=8F8oJIb>ExpU z_s1L0a85{v-!Ds?F^S00&#gw|C{{OiAkUI(E6+F2&7UhHDE zoe(*@N$~H--BRZX?drW~)c(*b3$!=tJrxE(bzu8MlG04tfXac4&r5gL>Ow>qAL!w9dRcQGe;N)hOBMu@?Yw7-Hnlex~?!Ep#Lm> z3JH?8P%+{+Tn_xD@LaJw6xN%NI4jY5*A)xTBe}Q!FW(nz9dQ5osn<__@@-dF`NeV) z^sjukH&ZkkQ(iVY%5UNa0dGQ(U;6tWZj_zO^-Pfp+R(^cZXfnlDugN;-=+4S0(Ip3 zkbKVfFBpJ)llA=EeE%0evvaJ@%r8px6>i0Zgbb?&E9|{B06auqr7t)7{!IRktZ4?;vFxzVFTWlYTFW; zR`ZL;T~)i9G^nEKc5y^_MHKtjmJ+`I|1;EZ7LKAG5keDD-XNw}seGcF>0gwv82lpW zy66;?U3)gqTZl*elnd_1c5e2_m8?mOM4E{4r?2>yvg>!7%;G28nZ00`2R!po@`dS4 zokna0UD+LS!9=JdG zdxaaUe_5h^6#a;NY@j^!_C|29+!d*~HY4!s=cJd{(%||7oz{T9J}4k~a}gmbPAd2r z2}yIf+=XG)JHWiSvp4Lk)j#k5FBXB%=Vkql?J_Rl-&G6u(AqjG-*O^Oa4 z&f}CL)T^`d$l%Zbm(Hv-Qe6cRz|*QUs%E#Z-lMu1en?S1tQ8O7MNZiF6tw*&9QxAO z!(<8ui#}KK%eZPZ#M5K91ov|oIm{KiU==pgZ#H^798^=GSR%aEB)gY2 z3DS*{=#fw;uC;7Khj_e9oZ$MB**%KFz8&$4U_pi3d$>#eDpK@Kn6-kkF!xuXwuuwXrD`)?bK5ihnUC9@ChHT!6El1u)6eXb=yDB z9!~-6zYhx&A{h&3zvez4H}TsUR>So`1wMC_by;d#zytYkG~YE}IolYZJaq9N6xIru z?&VRyS=mt0CTi2vd@9|nA%x`1Rtf~`seiB0yQWG{zDu{HS%K1+z8K4|$a%h)!^(vE z3)VlUeb)K{2Vdy}Ey}edmnYQyHNdRBU%*6X7Mr+;U@$a+lo;Zz^frR)505jLXn5Hk zcdzy7ZMkZ48Ic`MiJjN=+=O+e;y^wb5!wz8{~SU^Y{Qbnz&UR=&O{SfGJd4a;^S)G zE)BlIe_kX%EI9t2gUKnAv&JpyoX`+n>d_6|TWwP~n}tac+vS7xfBpHmCH~UAMQ5*V zC}{fArZ6ctN?ydV@Vj}xmFEw4$3mcm>brE<_a@vh^^m{Qy>1^zFZ}`a#vx2 zcn|nz;Pc89QH)J>_X5pv-i*ZEz0+2~X==!CtcKX9pC3H`cs+j6KfjbQp?mZb*`e!d zC`c~|U(J`+sIk(RHpX(nFozxDy|O(4>x*%clEq5Jxei^T*yz<7`Uz5FT7^>ErRlM{ zwMBvU?!KB6BR5nOx`o;G*W##wPN?I?-!|&M99pa%azsFnbmxG0zx5o!`4!E(`rI9b zFNvIF^%LpGtO9l^HJEYBjR;2jXT*TVFZ^b+Xv)Ql&?(o7eX5i&PqA5Bf%vwk4>?p< zO_L{Bm-nAX;0u0V**ooqU+#WEdh(Sui-$+~+B~!3=;)`En*_2Fa6On4eBL~i!3M3J zr4IdWwf=!2E-S+^#dArh^XP^)WTBw^pO<+c4ffyY-%TI0>YSwgu!v}?4QQL+Zx;iU zRojs~d`rOdvdA4N4vTj$!wgX)P1*;isbk>kC28TuSucKb%@^N3J8$wq@^NNhg5xhf zUB*sP<&daaJqLSA_&t}hk}KJuTyt{}+PnwQ-YjNKN8Y0`nf|u;wq`qibNQkOwPaV; zZFl*JLCIG+jbj2359eah5*ROxqg6o-23~~2k>*@M3r<2-UPYDBAMTpe`*-pHFF`IO z>!W<2!_|(Ii8eyeCwh4wlCJR4ov3W)1Uq#70k-!L51-*Rm@lm=l2T?YzIb)HMPA{Y z>ABoDVb~*mNuk|P0o=cu68>!kQl_fG08v!JoQqzM#+U2<4}lSr&De_X!}=r5msMhKiYrk zdIhxi$LgEq20m7zH#FWCB*ntQ+b=JRC!ahFWoefH6ji+ZJpyfknP8^YbvAnE@xt{7D_+~(51>|e@TNZcIeTEN_ z>-nOuuT?>ZtSiK=yW{jhG`CF&7E|QC9K?hDEs_X$;f(iQbWoSK%aS+KLdz%et_iiD zpY?nm-#H_J^-?RM5zLg!O!w&-$|v;bZ&RdG!lUydF%rQ<0Npsa{x}s2a*O-oMSRSdqy8rQm2Jd^ay;{Z ze*ea=&9+|5{f0snh?gH#3~4XJ)drg-(R?&Pu>Lb7vC1XnRZ}8QQpOO)L4ZrtW{o%3N^B_2`2yh4M?V=bs1j zMy~+qKfD!sE%%KKBCA(>W)^Vi51}Sy32=Xl;V;`g!1u4)+G6dd536wi7PiS#CvqM9 zlY@JzZx)scRpMM@2$L_5CL|vT+6+J7VU6ziMfUoP+lqzC;+-L&BMK^1KD-d^V$?H)LA*^g5^%k>*TeBXVF>C* z)C^f=jC5A8L;Z&FO*03JWvdP~&|c?k>0VCM@GeV6xu*05C^Wap^^Z)+Wgg)ZwwP>; zEN*=I5byC=3LMW7Jh;LZJEzI&ox~xY9fhB+;#f(mQZC$cK1qW6os6pt7go1K2`Bc- z@>Smr@~x5X_IQr}|7EQz8HPEI)qx~)i1++dK?Ah62>G6J3P&FSk5?DAMk?tMJ^Y78 zH<5MpCj@&=AfGT@aMVv_C`%KM*qZ=n46egIiGuVbcdA~hhx&k#mX!%hhzGU92Cm<5 zB=X44zaJkFUJx~IJ@?Dj$BaJz3a4Xy7TWm1oU}Zd z$#ZG3GT9ooQ^Efk;+3S~%LDl|@@>w-0ua|zgUut*C3Em6hTfAJXNn3NlNGiD`6hNp zS6GH$VD4$NAAf_RokFUHp(Hek8_L%~;9dFraumxA;td?-f%7$S@ne|?L*5@R1T_>o zdg%g~)y<+P6t@fhJfDNlXA}P})10vGH+awLk4>S-?DdK0-8eAtem6yu$~13QrKLO} z9^t$=xZXEBev;L6i+q)$kuC6%TSz#7maM}ExUBEw}T)aiNp+8FMyE5Jlfjy zOa;>_kF^FD{p*J`i=XEIUqL9k!UXpduY6j~iMB72LOW`M+r@iCD+o#F5X`Iu$*LC$ zRMb5(=RzPJpVBoro+C^L&Fp>`8heiG9JxbrJ*<@-Yz_*Lx~y@xf%Ea5%3b@rROuUf z^nuaqV@3p*^X(76gn#qtDQ#OJj$R`8ML@jZ&p6!$L6zZ^6%FwabPl?K z@p3=HN<4(U)(;JJCY$x})lI6r=i{!t>#A%&0Qs6p zn@Z|uOp3%et<`>!XU%jM!^z)Mp`MLjL}=jqV~k~ILOd)X3$Q*%1v@9Dh}v)MZWZ}c zAlBTE^Ij{&PA!XUm*j3;z|%A;mOVa7qW8ugME7EY;w_0chgF7sr(%d%()Zjm_R}~U z;=zCLdI#itV3(FLU{LTNfHUWs-!{BDduzea8t^XJ`GlJn@NxuX;a(CoRiy@WZ4O`5 z3$sakNCbT2;ugIKOkamvQ^?GNcNh9}Z$-1B z%2Qj3v8%W+U}Mq%@mz{r!26>}GnGxbZw9k-jTXN$S6)oyg_>pI^T!UfodxiGArcco zmy!(;<42TWv{*KGgrNyxQ?cTN)8&NE%H=l^FRn(2=h*ljeExB+ld@=9)jkL97ZCk9 zubWM_jO}GHboUTgkC*`Rp^i50J^y}_893+0&(nu;$@7xHQag$|4Y~ZqDO);~EpiLQ zBPw4g0oq$1*UQC?Ac=3S-)OQ2FXR7#T;SlRR=MoNM{G>Mdp`Z>DdqO#Ci2d9wkD^o zVDw|J`tIsp6UAjI(;cG~cYg=OgDZNQ40zwwNmiVt`rGN7RngmzT!~C}TvjnFI1-Iu z?!f-bthtaJ^*b!gl*4{U|7CBKD0?T3hyBE^414dgT*@fOtOw!|8!ix6SF~B=B{p*`)d>enR zqUBs1lJm&Hn^vcp$dL>aOxj^>F6V_Y0P%WyX2A2Fx+w(t#xahCgIHztQSm!jGimZX zZH=@tR7R{bz!S;xk~+Cm%~L3G%iw0T_`d5WRe2;aCA3?`*-tXAvBx_D@rWW2!Smk; z6)0hyZ$4wt11K-7vL>28>cN*e6nz>fwbj-KJa5+z?7#o|>^WaB5!>NG6@(x!>0NyP zWxHH|doJ}24d3q*CA2^k2EEQYlQ`C4VeH>n zu)e+Z`3+@~)3<`C+9Tu|xg(h(2hX!L@-@xUWTig>e~xJn)*)UL6*D+qdbVlmenm;! zhz~DIbvx_nP2rMS28a99{J~Pd0`dihV!K~1`HgGf+-W3?*5MhgTW(gVj*7jH>U>}3 zGL-&m8{+Y0V1Vb-2om%>82-MLyRY%mq&>X8wApIC<5RmSk)-hhpQq{SRH1!B@2{Bp zrI+%wGyY!lndB(i42hC6{LcGf5Ranq6<9AS5h~hlfj1@lJGg%qy$e<7_w%`ulLLind%O_1AKT3` z^=|SKZ56ueFX^~X%f2e=6;hL)o@vXShOaz*LW@yLJj{qiAa4)7t{;ZuVomtuN$I71oAqCCku0I)f$KNv*S}j&<8rZ{Q*P_0Vg7t9h;*S&y_|V0nI8SEWBI4D2oK`nI#wA0?X4W0 zvENG)8txY7GYu8w-I_CpxpCNT#iV_`oe1QEMQL$J2yqtrd7_9SRKs*$(rOuMR3HzN zDpCBSbm^pv2_NDql~983%fEFuHs$$5mrK)M0^@Vd=AB+VDRfh(M-I->EC8MzLKOXP zHL7T{;qH~!v$_@TzQz;Ifm-e&=|L&xo1%1oNFbho+XlG5=F_s5H;f?mAkiz7udkH5 zH4gvfSoGXK^d1gd5AY22bs`w-#%*9~>fhF=1mxqV&c#@2HxKYr^J|Kn{&g0hfp~=G zuepKt>Zsf>{}e2WP@(lo_6w#`L5P;+!V;0f=vzER6TP`J>0J3=q$|Ocy+VgZeAjBEA2GOF!wQR$+>(=O|zf1kvd6h&inf(U+jtZOZ@DCPh zZd}ka7sOK`Qe_9c1^L$}KR$N(desk|P(;Wr6i-X(z{^nloWuwQpD&x3S1+VGA8M4h zL(UGL6N)cS#RbwbNIM9(g~0W^($E zgHCZw?i9k1fcX}Z4==HZ7ijO=g0Iw8{>f4T3$dEK9is5w?09%;ipOC~A6`)ur6 z6hpXz?KhV}$<3R)DbwU)w}$?r$D=K=>^_!#3qu6r!O7bR0N(41929c3)3@x}BKiV! zzaJk11H;nQ(_a)dGJ^HC>&59DIms|wkp;fj8|H^Uh|!Q^X+`H27f$F8u>ze=%l~;n zy7S=uQ9UF7Y1tN?5}`@DRb^#vyQ=WN0U`{0d63 z0K9`HSYJKG>&YwkSW{f++-taR@O zs5^Oxhg@m%0Q8?(!IvgvqKK2|O=8|9?L#iJIP+cV7P&68b_X3GpP<&r*o*zV;{Gf% zmVWfh38qRie~MOWHQieRR0{Ki2O0&4XRLS#j+gkT4MgMVjgpuzluTVSqa#~Hiw~L4 zEE;rwJ;C{8vBKYKjp5&vJ1L+3bh175-F;>3d=H!aF?%%ITqBbgukoL^NQMFKKP%QD z9;vP%RVOmD2L5_kKi1}gNIvJOs_g$^*bd0Y6Zf&Z?XEXAsqpFd?YH?>uY?acm`y7b zA+wji{=#G#-zh`#5jbId0@~|Q~ zdY`M>55068y{nc z(bCxCYgzkj{Oj?{7eA$K|9R7USm1cJgF#S4&=@<)e*BHz^-S_Z_s3pYFvh6r-}kz( zfLDgT#ks_YkKe9um-dvOgsQwY_UyOUQ*>@{hLl~e{LEts$p>?G5eW33O6e!POvC5F z{Q{Q%KY$~qt>IhY*t~rpj+i0{&ess}>yaM#d75c;FpNLNHkW=pT9+#_nqe@eU#=!S(8dtI-mM2LI0YJGikvGXb3)3VE%) zn4p&**kieY_Wr!TC|xww`jKIg7rf@ zT7w^41`d})suG!PJlj9JSnHwd^3z@VP}G9;lLBZBnLaGV`0r+#0=z13P7id5^fO&i z`a9V3zXdoEAcuU0c+V|(;C#1dwXQrIsp^#WiELNlGM|~PlQ5v8;axzbU?3cj4{^0P zku=o!@6s(STPvU72wT?&a{nn$-cha6tE!jQ4KAJ#kAUHF7q}ijUwXeHjYhq1yrZX; zOTvxYhAYDSj_Xl0fEohs=eV=}3aR*FS(!s>Rw5>UE^K9x{aG(xs*_z*Rn2%G^-Gs8 z#Pj@#Nd|a3a(tNnvk@<(gh_b0VFL(oRZk@Sf^51vT(80NnT_FnT234`k~U27P*L5F zl4bZz%bN2JGb9a+zAh^z3q1Z1kC@Wg1MnpMg*)EiJJ42>m4wnZp+yKcp;BC_zsa5F z{FVIwKSMRydo&`6@dLA=x zdv=nHgD*7CQ07#}k%M7nFlOW5FS6w?80W$u9ytO#xZWyt7nf42;rjbVL~^{c-g2%t ziMU2JpGwCVy)F>&U|fFwh=py7Ows?iyCK7Wrp^U3oporE_ zf&LRi6BV~XwUzn1+X5$?stE+Is+a!SefWINnyOZ5SZ(6X6D`PEdUngy*h*9Q!wdGqs%$+_H?M?#~dB20!D|>(41W3N**I8gaA)LrW5zcrzuawwC z#X8Ly0&l#n^^4CFzUDg=;Pqg;H`R)?FLqjfL+*L7Zp$)9;A+0!Sb0$Mr?#-M=vUC> zKaWM`7~CI9M%HV#ZBUuLXbUlGFMZR%c<1%8#=WnBed5Fg$Y)=4#Icb{gPB>)@-fj4 zDwma^sllRSw0-a(kSMs0e?TVnfcJKrD(pzgUubilYXpanwDf;W32aGA-_i4ALp)NeAaFj}G!>{Z z0WIwwhrJgq?O2NFA-1C5%_s%)=Yr!1@K(?o=gBaoLf<`os~Rk)N?}suLhs1=u{A++ zCL{K7?&Zr|BrL|D~;WtqZ{O#)om=ECnq3!I90_!(> zx^bNA?Go{aAyVE<|zk~PwQI+IQ~W|f(&)9+rcU?EJf9pK10PTgUPpCYFKBF`YG_pi$#?5%I6h={s z@wZN)BP>aUJ$`w$6yhZou!HlVK{-_}XT(asbJ}9L7`o^1)fF2Z%^sZBLoFxZ`eT?i z71L0@VYS$ae{G%px!ZB2JjWt(@q5&2xI6D*HQ^4Rg^8)D05A`j;0Y(i8ECzZLTvoRF|_ ziZe=xM%#*;K2y%I9yT|<Y&urpJh-X=j55CVi(j%L) z;q^VBc6ChSp`!D`; zKQyAtNxJYkUBm|9F@;A7k*Wi3C({YKEpUgp5h!Xd9iyg}!%r8oS}HGWD+aZJi=3|H zdSxEw59@mnbDn9*WsaX`(Ahev_^mLGvYM=l7>h}HehcF9EA4>Z@PJVeCHss~*w&Ip zh}6Z1zl9@5)kfzQ72g3^j~O-_Bh8SCrSlryC~O)xj46{=zv z;^FM&f%AiSp?Ec$BId3C{~Sf?m-WDxQndm7A1Qw-da(z(fqWQj?lblD1=59P=zj}> z{O4%TD{#U!r8%b3gZpf8sD4-f^S0mr|0jX}|Nq|<^6qc2dTQX&RdUrp* zeLs`bx%sA=^8n)EU*=^2`5t~!U7f@PO2UR<29dSuMNi;1O|7rA_9r8X%>f?1uTMdo zB#Ijf7un=QV5(WQi)bV3q1nCXHJa3Y+fu*MKkxr{DA?X`Yq5CZs)r)(+u| z(brkJT}4_$4z(XX3HAT;I<$u(_QO6*zY`uBdF(3ieLTu~s-l zyMTDYQL*593;7-IA-7ms^EM{wmaSdrl8w|hwjUvx$+_2<%qUqab*(tp6tmvQ??`#RGT*fC-T2Rg!BzwFwfulPSoC`> z7}sGf2HTr4(YO72bdaGgkw(HD+<&G@6ltc8=P-GZQ0EB~pq~IYl>f4Uub$O`(oDJz z&;4-l2GU-*73&FL{B5%JJ5zWgurVf9RX%mn$@ZV(H4!{;Xs1+T!~yxTVdZjEb5(Fx z#Y_;2B>Uz_MJzDMq$B$0W||^8Uy#yi-$J~)sUxtxc#~}8T;y{ygbS?uL;;WJ-SkOE z8N^2DzFnMRfLBbd@OXzMt$!8?XDd6+Gu0zyJJRIIJd3ZPod6w>XYv+?0NhVJ8Q@_B z@>xuo#`f7!NNVNUcUbkj;;;I(9hNp$^TjzfN*3^j{gizN$^?H4J#q9GDvJ^`Palj|kC z3xiR7(KGNM-g`4T@cm{Ghh$LZ>IS2g#hcnMEB$}z6q({8-AgRI8uL`ZyDH4>`MzsLM`c@XFxY!wI+$->tmmJX>`MiXKXEf{MTZF)*dTOHt+~|ScwBMp z%|FSs5c-U&`v7lKRQ+TA4ko3Mtq?(r=l_THCJtu^@t2?UjjzW~#J{ZW5km4|B)tLm zvx$#++ZXthukBTpx?W;VjSQ4VEG}-cV?$NQ8UY^ONM5H2)$P+>|8eufrQlIX6rGRa zi)`{Iwt*gIQT+0+BoL2a(#rw3zEk{d;vL4*uUyeENPlN5qoAs=`u7A6@j5cSKnJ`^ zTSS$3ZL{&$q$vW1v{RA3wnmc0i%yw;y9p|gmWp$ds30EHodqZ0wVxXwG1g=gUa3Fi zQYviU&WD^2g^O%NFd=Dy&#SQeBn*SN@^8GzG_F+&SEkvekr0|lk zVGSSdw58(fC@&)}OdBVXnN9fTy)Hum#|z`dektYe8m#L?N17Q2SgXN;Gr2_`&nEMZ zPZNN5^-gbVHDjwVlC3*dV<*cMm1}hdd--RoNC9C-iGw0hJrg7!^wWes&|YCfTBg@V zNEDcrs#5j`Y&r)u^O{F0D*ZJt<;eh#a@^$OB0}`Dg1HA$FR!vT_F*Ebe3~J{2iIH} z9`BOyAFm;vUB51PKJ)XPy5LWg&L12%@4D7`Qd|QZi0X+Sj9ttpvVsBcBvl@M@OWVN zYD&2}PMQjr?3c{e0Oj}EEoJ5#q>>Ie_n@dRp~x1Y8gDgllvTb{UwZFU=bB4mZ=v!J`fl+3+DTn~WzzYvwSeu|T~3RB7<} z!b(|Cz@d*h$_@YY>+6Dm3zuH|MBVP++X0uuG$7wWQ|08(|d<2o_dim4)%#GccsO@~sG8X*(F?4tJfw=Kb z6yl{Oj?n|2=YI650AA%pkK{t$j6@WL7qJlb&c@L&d23Y@;Po3!|F=#%Kch5 zw>uV~*umQnD{R>7mt{?eS{4?Ac&0oy;P^|^dRgwz2Y^KIhL5b(;ho!1)>e+Z>( z#A&U3!zeT@=I*BP_9GwG8KR(*H6e@9g|xTS=sXv#Rbuw0YY6 z>+w@(%m-xsH)!2$|GZ{IaqxN&C5YKwRn4Bk$Y%3ao>N*>mQ)}dQ0r`Y?snM%`JOq2 z+V;kg;pGHK;AV5?<>Zovki}=~zrrGK@~vRz&zagm@-enzvjFX-pK#Wid601LPs@2G zKWfp;JoSZQ3-jEqdTmGmc*8L(3~JN)4+0IPVYaJ+ojT`MU08a=HMb_1i*V) zuL3r~9PkpMyk(nT!m-SYxwD#AR#};rb_=!qq*#`hQU>3bvmfjP1zQM@1vH@|aHxwU zy4@Dv5DWDoki(KJ(UhOWmZU(uZQq1Uz}vw0rLc8Dz@g5r9idcCqJkx0iWZPy0+LOYA$d$vhTxxF#O@+VNClGIG_mWkEc-HC3>F63^w&irP$v z@07{dvKE@vFb_4Whl7Xg{}bxh>VQ{RUCkQoiHf6Xom5jOxt_UE_AxdJ3nOXFBN;=x zNMCF}8{#=#t%K`ndSdb2AwhA28-EiLR`2{7ITn;r8edBz8Jzz=u<`$Y&odiT4l`IN z_G({`2c@Oj9>zxw^^mGN=>nqR`*!9xFBTx)TAB~I9u!EK=Nv9Co>F>A`{Y<#fU!Mj zNAvd4GpIY<4&09=d2t&r9tM+b?E8t;;d{Hk`nU3(w>6jP#mf1JaHW!5R67u_?t6v^ z(0^}qUQl1~7R``<_}MisZ!?EB)BE`cUz1kB$e}NgZ)NcCQ|>@Zq+*BIaM1fok-ho& zFfZ~j%cipeJ&sid$rlF@ub0&oTrbR1^fFX^5SmmkC(oh~3j8H6*zv>4vqdDdr?ds| zZm(D=(O@e^2==aF4QEL{rc7w2O?G@JQ`|ctj)Cdc^Spw1Iv)7o`5Q(6hvQfIjlYpMh$w71ie85N6N)Wc}LDU9(AXY3ql=|aq_f5 z^J|Ew7p)5JUlmTCkHq22SMi--^wh2;SAONxju-Z={VB%Q4c0RdWm&VwvkEUG2hMvw zw9vmIfvs=67mK8!#6ofIkI6E*+Bwj^@z(gTQ2Bk6L3CRxWTDrj0G8Q6; zXWuf93V77N!-9sY3~`$q*xyj6NPS@)PWo|K4TR%nr z*FNHHzM{n9Zn#Fu^|Drm%l%A8u)bvdHMva9{fOKQ9zja!d7A1XT zq^xZ|BgFec69MiQ)1OD&=4mUlMR&4@ALE$jgszl@PpYGdo(7$D1No%iSW32%6EZQd ze~_^YZ0x_!} zdpbjl-klm_13aqlev|!c$=p6it-5eov;uFA7E-eZb)lUaEDK7$zD*Z-5AoC%WWo7( zKi9~`_4Q)2pShIBb<$3DY=7Q$+WX2TmPlQ2ydazK^RZ>KRj4SX#5nCPP3j}|5aUV` z!m^$qVETPT`}9Ht;-!AX#{lxZj5XdS8@fzq_!RNDQ22I%Fk5s+2@A6C* zJ{iQ7^rP~VJUJ0Wf*ZK0!1{xShv`!%XSZ{=!C057T}3`IZljl~oWp(V z%tYYxIew2i#8cgq<2~F-#So&TOh5fgMDBnue?3)C)F>>G+g_MKJnm66aQz{hd9KZ; zd`LiGCsH6F(dS0GuE~VVUETAlR}wrwLN=`m`WApr;xd_D^ZWak$Un0`^emzbx5_Yx zUqpx3^8{E!JhyMY;QAwr?Q^Ignp}oMzJ|pLN%`T9bQg&Tej%G|)zk*iUQ`sQMk)tY zG6eZ1T(-z~;`qOWUdTvJq^RhmZA|@qqP1$&SMeICb)!1hWd^_RQS-Rp>-rKl=r^3n*Pbdw0<;pZ@buZiK-3 zi;P#gv~rNwgtoug96l1+8s#OLMA>Rs>q|b4yP$`wKD3AE^wDOM5ibd*?2Aq8OZGk5=obVEf+hgp!!ZEbND3dtp^_E$v9ml?-pBVD$qAyhm)B zP6OOAJFqXJmjSOqS7KQM+50Z`YE4q{FN%=*pyHd*SM3IoOujXmh8qnVEf7z`>*gKc zacLk67W)(1Ri_1Oy|zeElf3$_+(~Hes3n#SK2JA4cjpWIIULMX45O|j)5LB4;y+Ax z%Wq^>2s5f;bBixVK>5N_U$`-gTWwYRr|yQ`alxoVJr2TowogDOEVhw$NOrt;U3BitFp0wUQ1{*c)wl2EQ-YxVl;}$C@!DY zC@v0eTbNSqFsz6E`BevaJjv(Ihfgl!{gyc~nw>9(;>Q!x;>O6!E= z+ofOzug4qG{JEME-Ui)It>rEoNpMDD!LKM1P@mYP^?U)(9R0_-fwAHdn%IYy+YD;a zTUBw}wvc;b=aK}sk9qW~ zVJMz;$=; zf1Z~!GrJRKX6NJl8pLtY_yBo(Z_B~+FVE%)HkjPHOAa<5g#+G;%ARhWh`$;_e?}B#-7ZF7BT^4E9TTL5HH*vn zNlCX=!H|ISUB~4HaJ@hMnmQqN|Ne^}iOn-B&nm8~E6XMcg1A;Eb4~=n(=cuN(wQ9! zkKZS|p~&&P^3w&ky>3m3)D~_%NzlT7aLvg*ukjL0p#kY(9?U~ve z#P~L$wEru0e3&xeWxB>9HEJ`MXUIeaTHjA}##Cakdo%Oj1lZg0nLkIeH7f@#tO~oNj@l}cbb`5z9rAwCn5Y7tMSzFURy}2CQ)B-~ z)&ATQtB4RpM+R-g{2$)n_l?srmKjfGJ7iE?QGTr`_mey~5-eM}Qc9LJ})Ugb^}ARZRW+%nCnk<`t-OZNxQZ_s797JMop8>QS5$1NA9 zl6~j;*}kHdQhV^(=k<&bW3I~oJ(^#y!2XZ$!Q^#p6vkFntsve5Y=ocOal)3P@Y0$C zh5bvQyfSlNy}D^sgCy<;`}v;xsV8#W*TUP1i4{js2_Q4yVJGoI@geq}gU^fNkP6Ai zYLlxmrV`1tj~CpcSn`cWEdJxp&2;>Lhk+RMMM7R8D~@^Wmzzd=x7$;Cu4Vzo=c1hNB^Sa| z`yGwG7;6>lNr12FeN{Fs!uVOKC+Z2uI}yku4nG3#qkuPO(0CI5nqrc`^X;LCdb&pb z3y*;>uf8F)H&_9liknanVzn*5^9d-4f07(>WW(O358NcC=*ZHvh0)rU7}{TB6{7kA3atuU_A$ z#qb>XT~+f#-**?-smxIDCx;7Nz5?}^ViX^9`66ozKWVvm{muJbLwln{H`1qN@}{ zb9V^0wR00-?9QaOfxK4c1h9WLr-|Brkxb*@5wAk z+Sy)f#i_F;(EGH7GPg4aoJAfbqtKT8Tqs|8shVR8dGt3r;CTiNGDrS2!sH<(id4x7 zKkfO+7z0Wp^p&ZZOb)Pp@7{~U-*W!DjgG{IJ&)$`%xxqbPvnmWd)^ZheCsJ(n!Eo! zbG#5}zN>CbwN~wvhZ2d4Dr})YTBq=x(B`GEuilJ75l~)t@fGodJ)<D%jMciE)xtUcdI!bVrtb}|e}5+QpwcC%TgDPfEfbsY-v7BF3+&u}Chn9Y z3+^ZP|Ehi>S>L{P+2Z{gPoI|M)-Gk7_L$;oR%HKC>3e1No&)3|hU0|VI1ck z#QCFi!4dLoyBNXuEx}|bInzngU$G~V(SJ#DYX4^2Ckd|2JU@i!FW?14R8e{EbFBnLy9 z)yp0nM#(RB27rgxbwvACcx~Hf;eEXPQ+5rqvis-7$#Z5+3DPx{GsR9H{{8;d<0B0D zJ%${Z&k>|&t=+5q8D!?YmHF;+8pi`E1pQ6|?l=*j!Vd7P^QK|kPp#%mX_jV|8Ge2& z7$-D`A7kII;QwS9WSOb|>3EJotPUWOBsZ@y7SftDl?-vRrnm;nlowZt5a zJd0bJ|MKyL?RwWee1MV6zZ(@c@|}wyPijUB{C-Bgn5z_BTGp4;+<}@S?Tfv}Zhrop zu+trhIIB0{r4I59ewpZE%dpBdIdG z;r3rWZ&l3-6uh4l|Gs|1g|$$M2!Bc&`2FvFew+r|V?u;AQaR>1yVzP&=GW@g-0{yB$F1}o4hIYR+JHwmBU{^+ zG5`dZgc3$BSKRj8 z`<-qnh5*I(&(ur9gX1&(K=F_o_MF$f2q0zojI5A@|94S*9P)5nNx=OXrie;agilLE-d{dx2VV8` zBJ=m`tQ~$*KYEwx3znC*+kjzlf!RDfKd;wH;;4w?sWxrac5wagb(&Aq#N+}0du=c# zVEg8?@{D~|_+r+ipzvI8hCKBXk9TD9)>)4tG5ZSO=_pBv`VO(W<}{QF{Y^!Wq5b+i zd?2HCHI{_i-7xyw8tXh1A7eT*m=C-5-iG51+N0wn$9(%oU>9D#f8cn*`VodjxQYVs zG@Je0R0T;iNR%$7+|wS(P~_n!=V_yv2u~cwON-LcR2Lx6!tpyeKTTh+xfTWqcbns}&5&_N+tV+9+Z^^cF|UX5hb-W|w-xQY=5p96rPs55cby)P&yvy*5=Q@Uy<4ANa2vyVHgFNyhVsN~KldQN= zpgu+l#Q1wNLV=x;a^%h&x61Et^^Ac4h>uuBd{}G11}SzLmz4LqoK8Bn;LQBK>9u2A zKB9!fm)5*}$kXik3AQhKz-n~xoRPJ{8Lj~m4&uwXoAuxzvK5PI$2?lV>x6e&ulC3K zhF<#qtp<0P*9F__RL0=CckHq%~JkJmf-}hn8yJsl;_{(X|lM%Qa4MW{+dIhGii8nt_N$BrXtKt+iy%-`x_nVw(|pExqS&2y(Mm; z_~83HwSedEq**{`oIKN5=1#++yY8%D+afliQMW%QvFX_W;GqTfkFaSS2#1<0!L7Ge z9}?ThOKS(+QQ6k#h-9)J@gCekUa?LeSbrZeb(HByKCJNQKRs8Zn1%m_;f#g}!$#CR zX&?-EMed`8Z_8%yE?*Sce&VH4Id7a~XG{K(ou}Eh_xQD#@0%$x($x(U#ro8wQ>_G7LuoZ*j<1Y#{n(?I5js*d5z5j)gU)TL~Tvuc( zR$ryzz2V3Vfzq`R%+2^fs@IXuTcct6v-AKlY;X<;@o*1 zzHH0r^z^~ea8cfpZ(b9~XAZBoR5l>ofo zA)_cgvsU_a1DF^K3>6d>^Bx>eX1PKhV3v4CpJZuEVM89y4ma2ytFmwduaSy;|0e z{apHtkE8wW_?uT^sVdAP9t?1U#_ z&C%d_$9q0A=f&>fB}^J88dgo1P_r@o?IXt&JG(Wllzeo7{cK{$3%rQ}`+G^>Jgc)N z%3+4qI82($1{(#XM^snuGP1kFP%5CjCW`y1_c*SO39CM?t0JUJtUe2K;pEl+*O)IB zrK9Gl(?}uDi`Es4?{JG^K8p-lqX7pGN5;oIYtx38kWD4`ZPeTPhF zlZAz-ZQN+k1rT2~cEQ5}pK1Fo?cP3<6*n-43ddQ=YcLv{I zfrr(wi;X;1T^+$gG>JLVvv8f&+jOnrW4w?Fz{@X!J+A-b<-~ru_D!eFJwB_7)u4aj z0~Y1Pr$YjNbMfD7koQKp65Kyh5HF^qDOvnT-A^N@+TQ(S*|qcVmXyEW85I?L-wOGg z(1S|k2ECb@L>UiWPDH7wPc_5t)rt-2yvq0{^7Sb%h!67uT}FTYMWI__3mpeR#F3EHdibw~5RBMF>G)fP0}4J- z$kQ*B<^{Z6m>7Cb154>BY%ao%xpOAP3Khp`W+Pk%GC?oE>vbP#`!?iZ`9aHJ{7Kp* zV|`$^E;&2-Q^j@lD4wibw?0Y8+Z~7p^Vz%UT9k2-93@k6BOS;H4h8<(r0+o0F4JJE?nz0zAo%PMbOQG0BQ!oE7@0JHxe{Hk(4KmJc z%vKD$oX@ZYJo;w^are}1F!hzuvw`@K%zHS_0z#OYJrfN?1!tP}ID9llLw{Yp^b9F! z(P;9-)_}aC9#STtyyZpm*7%hbk<)yJhuQZ26T;#NcV++Xz(H$g*aEy`HDrx0#T0lw z5{tj8DGfzw1a4e;guC0@sm9F2ET>q!nvmx=9tY0vj|iG%7(AjlZ?d=r4E?#ZsL{(f z-S~P}Dhh8{0q>z>;94p#>WM#n*(=HW$k9^1ig&G9A3q0TWYLmE=U~q2LS9Hc6SzP4 z7U$~Ex>4r-$>&!uiK0+s+XM$Hc_ZV?^Yx!|0bYHG>Sfgod9IY8cX!-+r|PslS}Em zOg}N>v{pN$B(;|}!pzHaUt_CD_)n;gRB>c~sTe^XjKEWHzl_zX;>(v4zYhj@JY2ma z&-U(iBU&l-OajweMZtUy!z=N$W)(p5!2+_sjne# z*CG#`U!|2aIKel6{V+PnxvA$RDT=}uH|@y;^Hu~^{sf4xOX4Q+{oh6Tc&@v(LY9l% zjYDAx1!CW?=Fu9gl4JdNv;TYPwHRRk>@@`^QdT$49r;u`h6=6O1NHXutw!_KLZQJ) z8Q=}QmDE{6&gC>{F)Y7)ccqtz7mM09b7~a)T`uK~{G0TUH&A?tfys2h^WxVqhw>}i z2WFyMYk-vANQt)5`-d5E)_TFR0q7xe6kffe^Zx9Wq0q2uw4*Ga06lZaGg%Y_%R95jp5;7hT(Lbq@Kjow2lcl1-;Zc( zzH|9pN8bXJ7pW?sn*He1&YI#C1+r!_F(c+=1S5i*hp)}N`bO3JVlFGlyH$S$?!QsE zIOO8K949*WBNj%ozVI>2wQGZ4tE`RNYtse1Yt+ZDL(hd-Pb|#JwFXL5P}Y-~!A=$%^AVM*A+8u$18(YY$>7oMPw}Yv!q|7Jp(_dn$AL`|F zC>T-EoFBg4xtsLe{RPBV{7(CijluPgax;9o@Pwnu5(n`O76ZAuI*dau71e&)K6}Xf zI8OkckMOTdNRfd@G|4fVdK|_;2#nPIch@i#XCl41N(tbp{!$l?38y*!vKqSJF2+e0 zi=brm%=NT8g7OrRO3oL-$pP|^Y#H@{=ViPkDe!o=gH{Mm;R&|{+viVj@DE2V5b2B# z0@?six&VLZ{Tb{>g@cVRF$tmsbXy8q@s@8#!t5k61?>@}eVifB{P7md=bUQ)yN}}V zORZAy!#939_pxmM5Dk~V-tNwbi{N^O1y1)qRdQ>C_c zstA%}3ht1Xy>kxcClRH6;XYhuuJDIS8D)E1T-wt3*TELodjKeXWWIl=qa?Fx+s5FlpErd>$tD@BAQd;3@*# zPdPd~yqvm7w{S1$7s9%=d`opO#v9b6eCi>t`VNTCe!w;Ujc~%xWd|0m#Et_~^H?eg z|H%NWsCa5tq=hwFt51+O#Pjbr*#7;!4$*Z0wTpGlLEbw2tm=q7`3^SQ+b``f;<_BT zfJgAnhNVMMh73hb|L#XKx*1s%*|zg9b6Vy#m2Kf zBBBLDo^Z@On7?OlFX8H6OZ?9M9QA>{f9pravzC|*rLS@7rud0~$AtFxoU+}_UFjjO z)wm`bgOPlVw=^RrlvHM;{5MaLy<{}xeK4Qo2I8yzcKh>%5fiMm{x7p#vihuxOI_;1 z-eEoK%XM&n;WDam{}b-=AaNZ6PNVyekRAt262azsDO~h6iomizh}?0IM;Z?c*53z< zs|?jt$Bh7^Ib|bpVs^2WN5e5Zf@#~M_yZt5Vx8ZKLRnWd)2nZZJ~$pH9S0|s(71d2 zEq{MyDzHmt_bw6gq_$AN`DDxrQ+*J(&h45CFVdj;Gs*n2u7pybC<@?V`~c$9`dIcjsUEmIe6(Fi-I})) z`?0LV(eGqeJ-Bdyu4 zZlKqV?Z9**l`SjrLj@ckQ!(gjOre(RO)0g5A zCL_nYidqBnO-}oieZ6PXbYmM)2|!e9B2SNF3Y94`}z7D9Gd`TGuiwf(g8)@d)1hP=PiCZGt#t%391D{q1A zB**rgKI2W(y~G8Uk1QoyFeLq7r5aW-Ob?VNn+qV1(CS_jXkSSp4NUF1w_XJWKC18= z3PP4?w?@uC=#bKG1GjGy@qLoA5HflOJ{$51iG#M(v>HF9w@~4sAeobVZ^MND0H?7(f zZ2~;fcWCX}N)(I7}{7pq~D-yN^MAYs-jRuICD0vt@@1c%{{Uxl&4n;#SDi+$z`ztxO3%e7GBX*)AB zW^h;eS|P8AY7SiQH&#gxbShX58qTNc%&fma%kgzn^60Q?bUZu+_ouIf?dJ&Ue$Lq$ zS=YGot;NZYshs;WjLXmotQIm9FQUHu-^;3?1oK1Z-v$y2Rx@TW#f);gyM;^~>IJAC zz8i^MS{@Gp@pVVJ#?UzsV^J%-9CQ0oN2(sv)$1vpCDB*<4p&q9PTc>0uNe`VUm-@% z#t2IrYE7NsRYk7Tt*)FM5f?H4JB)9q4CW*7s$?5|Zr+GFy&{BJ`OPO&I)qj|csK2oJwtl|(pmE{JFzM*)YG;PJK6PA4 zPwd|X1?F(P%oVxA9Z({#x14CAkm@&EKYw~}Owk2-MB4PhVE?kN&x_rK!#nLFP!aHU z(|^ph4{>k#8N)?aB$$6j9^voIj?K@@eq+nJ$bnIycz%B=aoZH=t`&qLauqln*$sJW zj|brUk(QxESt@?muDRohWVRHjMRj6o*fB{G*O{RKj+X-0Yk22@dppQOgR>OU9)%rG z+m^W{_&IYwa9a7RDG2ZNLf)or1UTR5ZwjAJ7!2__|DL6A^pjChRU}L-Rf8BwcD1b& zD6gHZhtvj6qM4l*Yu$rjMN+lQC*<~$B~jW;4cFOO?R2X?$m4FT1J~!arAU--wY!AP zQcCgOfA$i}OAs>py8S80VPkm#@Md_B^Az7FpdQ_~}kv zc#`tJx8?xdFNM=Ddgxx_-9HhAD`NS`a{pJ#@Xq#L(y!6l51jvvg*gfP3u(*#{#wwn z(&2mR#35ad~UP=fpM)_AY}N=Z1|r`+UdM<MUJ zab)u=y{xAiG9>tlfEU~pc&SnzTuwNHR}jICL zz#tcl{mjhFR9Cfzx00F8_kxkjB!Y#kA6#-oa4^IG#JxhC6oIp&*d|lGJ5td5iNH+F>tT zyxd?sN&%ifu*RO-DGmC98O}@z>oZQ!M;}aJdpne%%7CO+{2p`Gw_*$Oc2R1<`A}W{ z?{BVl<|g6D_!{_eV?1-ro{ehUn+anw2hBiy7C-gSken3c1wFHIY`B9nCXD@nGO7|P3_V4#nCfn6hhWm!=zsm^T*XjY@--uhk z(&b(*v;(iXS}E@XL6Hx01>_?09YF#L{DSFAz6X$JbEN~$4;b{TZE)k@@{(ckk8PvY zZfTp~B9>Mwa$WRB$N{gDs!_}zRWm66Qtll2l?;bMs2+C$wpU)d4f(<^OpA$uBgkvi zaRK)m#lo~tdGj?8v5bpxVHK?8i=C98xrbB{jKuhX{b|K0{GL#4Y*EUw<}y*huF4C` z*TJ2xV*oIeNnv7M^vkAVBXZTzm3x>4Pi9UE*dt4|a3KFCiuF>Z zh(Gzi{*oKP{^gqK&){;#Cwo=mk+dE>j%S$g6IoOoC05iEzv_Yb&}E*R^QOXi$<;ytdbaw%HNVOK~!28=DHX{?M^dLMT37f-!Z+~~o^C~5f zjGKiCR}{>beAMZ{kN2Tg;dH)@L{+3udb%#DhwOOxJ7xFyH0%d+uqg}~xF3KNG(``1 zZMxD2UQQ#VT~Ea}7=nFYc4FEYDec^Jn^qDK0P$&g*T5+lBOsSP6#eS!;OmoC^N5L- zpnb<-8xh{4+PY|j40+{zmtcRe9_>Z_W1y{^+$juJD=SwVd!{DiIm4@Uz(cdD zhe?r&J5uvI80NHVm-tm(e*S^IS&2eK^*hs*OHC98zy5m`wQFYOlCkojI$K zhLgV-d?sJ8BMKst$V}UMw zTPqy!{WxrRxW(4Ix;^a6{!_W%B_*I@E%#^B(*C5gsJ$BPxN(^X@~-keQvv1eve|oe z(egCkIDpvGP5&S}xczsO3K8Dywg(!RA7_n82>Kh9sBN_+R^>qdrT&Gf8!cbF)H$48 zq+~BC*Yz41S`c@us+I2~4cU={}g<)y>jV#i>2 z7aTN0D?LR?c#e;`=%0cn=Im-YGHiitl-oiLd5F_+;QL13JIQ$w_^mTWAbVwxpU!@y z1tU#K*XxR~wHb_0s53E#{uKQb^`ko{{rC*FTHvFe%ac4MuL9F6o#tnJS?#f_$WGVMEhYgpx?na9~gqDeZB+7kw#~03G zQ&nPw4#X#WPjD=wqVt2h@d~p&&2TfFjA}uA1 zlXo*flGDG>4|#z|zTp0O$pt;Sd~lUdCI*)b#vGEI9NSQ+{b8i|hm0yPpRM}6gpEIV zM93rSa!5lh{o7PbTx>B~5zTg=PTLb$HnR>v$Rjk!1NiZ}%rvFC1eRh|l5gp*&i}|%e%(6aR2Y?bH&wd9Ge)^7=Lu1sLKP=eneAY6cNA^ z=`*j)T#yYP%DNSE?)?*E^6Tj{GtK3?e_=Yfdq+ru4DMs)bCS4-v4{VRcfk$w`No}AX!#bsXe7Y(09sqd$g%$9eIy# z%f1o_j=#cVTw19V>=hoB;;xKLa=BDuDsP{M&e~lXo$~Ozd)5!DK=H-fX@c{YgdUgZ zmj|^>=g&3XzY0=>ZB_TMKZy<=fK~Vmjvr#IHKnR}aafzT3@mN1FURb~rC$mW{_8?$ zL=SXdf0fozhdhMhe@VK3@xi{E>koYTV6W=Lj7x|@`%|;YB2WB}p&6sg8hBoS{C9#X ztD869_>`}s;FtLp*^}&Rq^4!Y>^y!8x92n8nKdCV_R$W^zlev8Y3Z7s3K-1d8KW?t zD>|ilm2|MOy>962Qu+7qU}^{KIa7<{-kIrmr!ED`Z7Hhw3ODAs^2+Qa<|*_9EVR9X zyg!eE6hM3u;-$``KEsHQee&yByh%MB^`{7& zJ3%u+<&LsT7z1>y@%3KZa8 zn09ORg-u^7aiP!qOD7{+RLEiE{x|}7mM^09SLNwgdqVya3G$7Y)TMTagroZeHjqcCh6diR z+}^N9kxiL@{Zl!Co-wvTy^K(ln<&pGF(MVa5b&b(TkLvX_^ht+#OdcDSw@^Sah#WF zv%$XLPQbH>DeyhEg*;r6BQU;RDWtF11Jor5oDQ}@+hnkdD$KHP_>$mPCA`4*E#PIB zHP4#}SjA~Qc}v0JC0_kVjGunZ`K_uQ=4Z!drJ zI;Lf@{0;e(0u~)SIZxD(W^a> zCh$WN9o>6QbQ`x`Jm?%GGSG$IfaP6@QdFH0U4tnl@KDZRQE(^7DuuQ9oXw*uD`FFr zFxDLJ3VEIpj9`AFc)W~r>G|}W@5xYX%q70H8rFdd%t;5OIf0%XP~K#{sJ+|F;g%#d zZ;s_KnX9dP1GEZQ!E?qOB;tve!8O`$kO#9SHwL^PTC5MJ!a;7aT$;D~#iH0zJCe!d zyD|*!&+l6D0dIecNzFmf)Y#G->A120{=0*4(4+)`2^Iq7CMlKfpY3NJkVpD90sP)C z`;qJNk3=%L+!CE=S6j!Hh?v5cP2$+f3hq1SEdGYzw?lBwt4g}m(vHnQPl;k_OxgVYj8Y@C)iDm zj^>?xpU^#{HJ8F=m?AtIXCZXFpIO>`y!ibIxjz)&wZ{^;K2IxP2@`Y1WNsuhN?Be; z&nys~v7G-Q(kxFUn+(MF(2n%2;uEa?j5Sl1WYCKKT58P`RTWphSwoG@J2%8?=FgBv z_IDdxe~f-9)ngJP7lVhRopoaQoq*m7do+JKxA0}^G7a!HO3hn)P_6sprK;*J!UM8v zosl*2f>|76Ht|Eym6xZGLm1K7XpD1=}drna1aDaAq+i?d{F5Um?J z$u;GkooN#Q>JRZiVN!LPh4rJv^xAkR{VQJ5kH3w78&cUcHzp5AB4kVlGp0-l%O z;#kubp`7N{=5|Ote7QjS>m>TUKIacAf_Z*$|ASRsi>*PwVXC3=&6v`Y#fPJzK!SoK zoN4%t#>@l?=A!Hr$n*J@0?wb~3Z(GmuKn%Ptnc_e6Qc9T4*j==^>1}WlWM{J+F6Fg zHg@~^oJFp7XB0BZyce{GZ?>m$KKq>ca%-(*{kx10@^C}8!SgDs2|*?rUW+Nk!2?x# zZw2OlA;r(5oR%lw-k`h!%IiNU__(}BOsnjn6K?;!@%ke|a(u>11EcgAlK^~D{WEkKLa*ds=(srU2!4Im?y+JcHNhifZs;4sg za~wkqcttDed;fkR+ULoyeW!^@fBvEEUcP7AJ))>@&(B+1L#FSWAn#e<12f=}Z)mUI zRKFqatvV6!^ze4!lr{{PSz``uZMY2syqZT7o!R!;^;ZuA5Yj&bZCXVC$sY4{>Vw-q_TGK=iZdw}?+`dESj?kH6_sYm|(Le>m=&NNXD z6P20I%}kau9Yw^+W*6iU)LhR2^@qMoP$&kc+81PkYPRcb5d17@^hw>_nn;}&pEclp zKV7^M+WyqLco9K@n2=MnZ^TSc@W~uYG^e)p4cx}m*Z}06&KZL1a}rXog@F@Aw-nzd z*_N$UEYVrK&zNu&QMwo}O#shEFo$a4dsHP-QCfXK!_~@z|2}cf{bxy*`1S(9RL$I` zA;?Q1i~-jR3+OVcm6OAHlwXip7mK|qy5Y{nZLvaT?Mkg<0Wa`jf!MuZJ!$02=cNo|;0q*6 z>IdPUzRp5^0&juxUXj_#G;d$f*PXT@=g>HX_r~d4J85Z8b{b%7cQMH}e))To(Y zf2I9SVm_$ke)=_0jv=G>Rt)Ayb3w68%CPr(19%=}ZG~ooQ@4{pvI_6w-&IK)#6!am zm!85|rTyWqtzCojQU{Pnmh^ZI#AmX}=y%Ry$V$4cpP^W&z%$?XGSTNKd@-~N+YpEk zq4Ei=OkT>5H&k+=N|xvE4zI0>-l)I$iNemQ-u$vXPy7V(Wao9kd=68^ohNhQq5e}i z#yZ8d%5N>9g9GNM`P$V^FCGAIP%yei*o#v~*clhYMb%}yw6Ko!*ks#fq(eLg@uI>7 z`x5fXDBptTUmR~|&m7Qu(gXrIla~+)m2cZTQk6mu5LC zR$j^i3~biFEUe%T`LK72GT657uOQEQWC1)sWE4pF%IV2%%UF$;iOfg7)!mubw3VdH zisfI{ZUGPGOfx7P6=BIi)uqY%*(X8Gy7N%2&CB51B(*+EgKtB9caVqIF$cEqMnfCg z&N%_0l#0n;R>}^Ae+O?qo3V@VB*)Ky^HY0S&uTjSeS?Y^G%BqCZLe^A-`HEPi}aYo zz~isj;<50L|9h|o%|Lr_{FdLLBede`zpZC?VV7WwikqZ_?-(Ut!fF8Hi*A%uPO#;8 zJ$f}?vLi9Zf0#?bn#B%h_Ac68uYtFmD-M<%%%8?GJAnBnUkQ}X^Yjk;>d`O;GU}M+ zmmj<7f_sV)UC*;qf#ROOi`rh{n6238;0`9mKq*dr7f{e8XlEQ!Whh1NeRgGm40%sV zNR@&3XbmJ$Ve_XW=>^4D+}b+WN4Te9-Wb~$XHCjb0p8L2uyoDy$z$b)-?l>^I*nK8K=oyc%zR_n3S)35S_gAhx=HCKjY@dF0n zwGriS?S_6p_I>S9N1+?s^~A?_Rm*b-zOD42(LHGaA^U%?9y0>Wk53U2is$+r)(7p{ zxFr&|pLqTXXQoelI`dB4i3;$P+TxZZaA*QHW`2I7J&s>U;e3x_S93|JF5%7f;n5no zIZxV-%x%2!pLNF5MaQ;F@+=`>Tayw7%F7t%0PgQ|-LRn>aAt1@lv||^REMzsl=YjG$@=@- zQvVOQzmT}v7x@f7;XSPHa!ELjT;K~^#jmGdZeR2;&~FI;lpAlthP+u73~)VDeE%38 zjyJeP$S(JnV^}6kGb_eMB$Bbz|C=i~e_q|GA>VO|2o~)OOLOeh&3Kq9UTG&5>1@Vn zJD7-{`t5)VdESBaV1M6v(|yG6%w{ndC=&O3<(pjrw!wCMDE`0GMeZd)c@G_Uo!;l~ zYb5Cyd_*U4+E5$TS*{{M!(bA;=Tk-CCyV~yL%4_T&pwR5RV{as8-B;4b>O%Qf9mog z36@QLU(Cy?93Jp~2Ciy%Rv0sow4?uBm{ERCMdQwv*oUe;E2V;5j9-*jf(OMniID@& zC*N}~$ZjQUI4k9aCrLb#y}^~ks|tx?-)Gp;1^0hnlZrbZNul-B2u}v%4Xh($k&yK7 zu`mj%um3TvCTca~#)mwTPK9gW`OD2AG!4#9D76=UkXG8H_3Ui=r3t(7p|Ln8R|1Id zv*2uXPh6ah%=@;?YHVBDur$3H+Cr~?-$f-02AL7A%n?A|IVN57(^mD^t2!*)jd8H`)XZ3@DQxz44d949W}Ah!3KHa0tn#z07dy7-Cnf{?Z4Yq zORdZ<^g}lI*C^+D>bc%mjR78t@xqNl-yi*;qctucVFzE+D=Q={>SBkGtF2Il50*(u zoRDWfd<5oqGrd128@SxLn9R3lR($3fH0n-tdwX5IB1C{L26$^_oHjLuCEra0X$c4E zyY-cOF$$K>jtucl;aewU{?eidLLL$pLoU$1ZvX3!ID?RA;U&B9A4ah&+gyV2r+_{Li_eGX4g+>Tk&-4Yp}#FkPN=-qt^p++XD ze*HC<{KNSR$P*=q1N-MUYyv_KaUAZel=myM`gH7a@HVbfi&GZuTg7LnB_4m1wm&|ta1NGlsx$3s@7VQ`Q^v`Apn2X}_FbRS1 zntTl4m31YOg3aFWmt-G$M<>r`aJt^|G9k6?a7ZUMuByI26`oPt;)&slvQhYJ3e5$-Cx!2Ej8XQMmJ zBt^)>b14GjJ4x$ZE!_S-FuiWva#G6m-i?)=1#$ImdRu`Q+z&+-b)8u?v(7yZ5h+VQ zOT!X7mg!(JzN))1Wnsgb$2|F?^uPCc5W)Zpl&PMD~#0(oahIpBQq5Bxm> zcNkTZR8r3g8I8;EgtL*Ab8x^{M-&rqJt)~*k!7onDc4%ncj3}UK07$Qhiai=<7en! z^H>{z#UrN*dC&Xl!TuB*P1FBPRc+sWAalGvV~Ve`Zxc3i?yiW`Y6*caF)#94#9ZnGV-xg{t`L= z9dC)K?-B-%B0ErCYIfqDYtAIGQwNd<33f9b)Jabz+r%hwjUV%`Gdz4g+h{=XsR<*1 z?Yrio5E=ZrCf%6-yPL?(ma`G3D9<0#Z34Bi+ylT%CSX4u|7*-AFo^MnD@hPz_PAK8b_)z@8prYim&ER^kcK@)R$08zWZ|@r18RMc2 zc^((@;PWT=Vys-*jYMOGa;P>%4KrxnY4R^Rk+C-}`L+V!5wr4cP_D;cyUqEvbIn*6 zxwtUYNGg{Ocg^l#^Qy0tn&?9w!o$I9pg)+4`EhyP>gF2l0s0x$s6h;(;%htesffCvZ(NOuc@q?B}{G}0vq zNOyNhcS(0kH{Z9--(224XJ3W}lELvG(diS5SL4@Kw+=^d^Da=5ZDN`0ypfZZ-#Fod^M%dkzLJa! z4i=0m^GQiBgtsfmrJrXq%E`2diydyO*_j1&A+MZe0UAGVcK)ZH~n{syGacokCdGZ z+@HbX$lxIq#kM}({Z-WPRp2va3F=k7C+73l9{2`;$4kwiXn9>$5hAldHLURzS=hI* z^|AqeO1UP8pz<#Y9)%I)u~|)l^CQH$YqkrnfwQg<4g(lr5z=4tn&|^CNyVKLzs>{R z6#MS22@$2Z6lH~vVQeAkg#JMs{m94Nf_F_dkt?bOn#PbvGL6Xx)Gvtv9H$W6eEKMc zjEQs)>;irX@$ya&o?>|V zWe$1k+aBQi6^I!>YsanL z_?&hK%)d%K>>PEpe`0w}ou^d$S^vwI6$$1mBvV|#|0qAz(=91^%)OaxTF~dKY})Y} zCL=Eg$R~&NiDd1)by8;3s6@=DcM6v%PZh_v5bPXsd^{K0SX1~9kY{%71KuyCq&gJe zTU*j>xPQK)s^ml!u4pLcr5R(*CKwC@yzsgQ?Y51Sq3&Mp_?lf9h0LRE#_o4)wY})h z0{Qk|mALF7Pef20tdH6h*%oh`f*DtovM-#sJxy}5&)I#{-m7j&<5>Y7+*N$BZb-IM z?f(alHv(&m_ITQ(I1pDz&F&2q{j#5|H-CgYN?S}YpZ_PWJ{Wyh_8V&#(=x5_8OpzJ zSE%soaRxM>du-tXN7JG?A#V@4bMEYvx6Z7nzq;zVxqgZ03wUBKrYo^@d>Dj|K_qdpq5}NGA#!g| zbb`k@o2iius??QSAP@e7?i%~t5@woZI4zS#Pl{E<%@?|Whg9KNk_5~O8^EyVwM_0^n;j~{K=p{~U)>$6w*@$8Y+?oBx4jm74I z{hRx%o*}e%Bf3Wnx?|9ue_JDFDca z?%wINRLUre86NP(TCI;pQ5?1UZo18FE-f{!cHhH>J{s~6mtaDH@;;O&An^0E8s0G1 zmuYT`s+8!>)xP1i^qFG_1lMzv0{RYQSF4IwiO8+0a4RwCAvhZs<-fqY$lk&#iiS~4FH%pdkS zV1nV?-KjEWOuQn7@Yz&W8o9ho_-qh&Tf&;2!c9nMq3*@d!B`R;j;SUTdBb!#@{!Hdsl z0smlR6E@G_*5=DRXEFPTFqN)gak;@8p3Qm}?zfSEM0Q->^!EH_5 z$5Z#>NE~yZ=>H$+>BTO9JOYlZ7l2pxoI9N^MZYH|0Z&{j({D3uNG*$@fpOOj_8tfD z4l!!rrGEcEj&z~TRgP6Ky+UEBQ|@?{a<7J+KxC&!qF4rbIfMb=eD%{GJgUzQ3365R z;&w$oA~7!_$a0l5&hU~a_`&n?*RQ>(nl}q7ZrIK3%NDcKHy9LZxJg7$^JpEK5ZkK= zq$(i~k+T6jKQu7>_6;G*^Qw;+&uck`ErmslUCVVi+AlTamhORk4ILytt~0l1@M6Nn zyar3|zCTxlOU9)<1;_b6UmK9xa92UzMW8bHyiuGCf77HL8^*bv!O*UIwb|ojk91&Q zM}a}%Rt9mJa3$@Xy;>Zw1F!zfN|( zqD-IR&+f-?yI+nw(Z1HZLez~yeYNBKCC>WEQtLjhnu= z$L|xo4Bm0Ch4QuIxq$5-@z}f+b9hm5^?T#`vK2=ov3SpvT>Vr<`M0g$e)k-mZSrQ@ zHTp8{4=+0wbRD`8dR1%qoapi1Nh|)DpxXXA$U_bx)CB5R+SIbnE134=@H0(CYmDE% z;9#OV(XpIAGw~-0pu9x-2Q)v^xF;e$vycwP^XhzT$y;GbN@rUzR=r1qrzQMQ4|$X~ z-r)0QOqy)@z{qSc&BV zo*Gs);U=E>-{uBUOE-~+Tc3v%oCx7d))HOv(AaIlWttYqJ2`9zuiyIYAbV9v*UA~` zmdjTwE`?8g)jrgSLS3cYJ+gr3E`2)3e4f2+HS=o2Y*%@b@Uh?v1Gm`9s~T z&jfs6w{tSrd}8bzR_>N;`hyu_6uKb~KY%?R@Kjx;CPvBnN`nvI*cH80dUDe+>uHET z)Go%LtPJFcj~>Osy^FNw_F?_HSo{t7-9fCw{k5^ zHQ%};mXB|Am`qnZ(PlK~Ru#s4s;Vax08es_k+6g-^*iI2&2N`|!Zs>L-mcnRdr0|B z&GI=?x$4bBkhfgb3Z7rP|4FG!`%|GmR4{AoHuiWz@hS|{9E&%_#CZD>@T$lRXE`Xj z6&DN&xRQ{BUl~-^m6*1r{@r4bO+w#7`CT;udGLby;P+Kr--mOj9y>O|Nks?UQwK;U zFSZ&PhByhV^k%aG9^*ZO^WhFn3<65%4-1-Dm%<|>Rs{*J6B#xl5mFk;$+aHBU)uY@P%!_Lr*WnuRIAst5HQsoMX3h8|@$)$hv{VHbd4CK-N90tb+WICBnIq(@KOJCuf zO{#SFGsw!V9KNm6{-H$z*PF_8vrpei=Eoxvm+`$K$q8@VOXc>QL(0u!~^%kgQ=A|cBcJ*G!J?;D!Y#s!zd%0p$hiz-XRr1yauBR{%Q|5W0mB-bqrE`*-Xd=AT9nh%)+tbzN z(xt#c!yA(mq{DgKuzbClCBiWkN{NBOkvoCk&NTl2y#1+e@cAemnKPIA?K=D5jDc`; z*HAX9#cj_FQ#sguJNXFYo8pFBL}7Ds*C8Gi{Bb(iD$?<*l0j73#RJ3PmXk}hhWHlB z_kAdg8py|T8F<7-pLd04=P^aNknPw)nm@nnOg8ApQsfVKSS(xw3Jb-)bz|I;o%-sP z6;qTLhSf_(5ju5+4}Tc6weBI06s6Pz@P;pfOoRO%OZPVY-&$A1Tc4I^mhx%$JYPCe zb^tuCwiL_|!c|6nIjQ>3gt#UX^xag}x?Wfp)#7)lSao{8A0f{nF$C<7oFANTjmwu5 z{k{mFyb&jNK(U)x72{uFB(6%720VZH+0oJ|mmpO@!rA|9ZCm#P^%7BUQ-or|#=_IHj>_A32# zSG8YVuGVJz4Svt91d*~)>GUwc7?YxG%LNZT<_LA3f>gDIr(~@XVcMTu0s+c*5lso! zFRJj^hom?$S*5y6xn1h@c-O{c9*Oz8t(bH#K_DNcYW<)at-E=q?1y+EWsSvE-^vUt z!pZEYTHEJ;Lz%Q5{&|BZ=iv1_vrwLkqPa+ESMa=4(M%t7k#2Bd)tkNx>&B)BJfhzm zSek|f_HBw=oGN4~Atx`js4mNb);l8K{h}AkxF|)2^1+oE`vK)`3{q|U6o=t5^7+L_ z9FMNNuh*Y4Ju-=HQQf7%^CdJ-KT^haa=1)j^y}B739{9b8de;;@9nlH=j=tOf6B>2 zfxOJ%F0em;MHzlR66{7+6yHfHjoOMh-POmvQzosPxT1EFiBqBa!$q-VbLS7p~6xd$5m$rW; z_C*)T;%wBG-)Q`mSFj&Zp-q}x`?B>XaQ)r{UK*@sa1a_p$4Y-WIZbJn zf}M?8k;}US_IE>o=N0jRJ-uah2iI%4Mf%U|BuhTr9Y?w7$g@r+3Upz%yw7-$cU7$q z?$2O#_aYd#vz7fw&r-_$|97^{G6{yN$23CEX)jIzPbST;&u`F@kVFZv5tGt&}^zV3^%1_@HQyQ_AyL(cDe;1!#u%ff~=E(Td zs}VyU)vqzIem~fR6vWWr*AvCwlxE5pdnJF6rTe0h&_=`{zXW&+#BDdp5tm(>^>NQM z*UJsPB&}~ELXIsxlJaKJ@O(=z|9M-_hrs*KWA-tOW%@>W5o0`|F-`FOOg*Osn@F(P zbFpObe%Zyr@{nY${D#Falr=qxOt)&A6uEqS*6~LmRVDG+_EUBeC?C;1k~mPm)P4%l zE10!~IlF~<-NQU78aj5Q1I7p@GjxIA`r5AgPgZs&({#H78EwHmQ-tdP_S!h^mhTw^cK;_l6iAF$Wv)-2G866@XsPH9CCB9E=U&JVdgW+ zM|^KwGxWW1K;G92@SY7lHdu-Mc0OuzzKQ))1&25M6&{9T%wvzUI_fH>QBjr=@^GW{ z%z=DoN6tZiRq*B+0z+Uo8i*!i8-D&7m9*HVUUwP=yaQJ9uuT`aIl2MT>o(@$)0*PV z09&a7vd^3RE6?Rpg?QN^Pg!l5Uph}uzZeUmC+q8eHV4k% zHfkLR6<2c>&G?$q}uMFS&q zclhIrS?^@AO9-w*JUhaA-gx~S{W5iDku*O)fgoFR`R#eF{m+FDG3QlQXd-%_jtT+qMHQ~jR_RK~Pv66R zeAktNmF{vc_b=q3eV-*_LP&ATvIQWIKoDsHC~x&h?}89#MnY|RPK6V>F$v8`2&sw9 ztDLZ06>$CKuG9Ubw7X-twQcYokf_`{9drfM~|E>e_eXqb;_X+KcH7u@?-M~B$>bl$`h4G#W zd|pcg&!I_o?fMGx?C$8n`OG-gS0w_e#KK1ATfCE2JL_2XqChWU3WT3TW1fIV)f89x z>PJ8$fm%fYYrhj+u4$$C(>j5{OC_w=a8OScyGM>{epaM8?8ze8wkqT` zmVW}r2UB7Ut1_D*{T1psuLZHt*CJ;SeQEWvB&4FA83NvMQ_>Dhq!&AeY5cj^8|B?88zCxmt0sqLk+ab>4 z8M#n`9^|2@N96(eIH&Ro$#-I&*sI!FIXbCiJK&I&5mZ+azR~iY0LoiJpmXrpp&49; z>9T$(!nvQ;io2zoX_@CzrGhzH%f{`qUgU&A+Is;608q( zIl_Jk!@}$(72VFl{LrCXIUj=}McVC``+7To*Zb9xY2fZ6@+Fsm-c5|IirZZs`x52T z_b=J9I3!T-;sz}skBIPA3@GnqEbqs|oM6k5Z?&mNxoD+{9JhOS7RzH_UgyFA9(B$Y zT;-ffE1EFl)XV=rfS>y%4uNH0@7zeBC81a0-CE6gHei#_HmpQT#&kg})a~ zIrd9)Z5_^&ncz+&?wmdO2<3}YD8cyUR zRQu=Y6TySyU1ERCwAm-GQ3|;XbZxkU_D+5f-Whl>Uzhof5&Zw(!A$0>DBSjZrRRH- zWI!$VY~O}Fcqy&XUPRfAQKFf#UyRB9U;TRXf$QT<1MgoZp4qWg-TV!4jVE!FQ$ZgI z-(lH2Ta>i{yo`+NcLyV?H+lpnh!cWsO-qx$V*bm+>4k$t}zm2xeAF+74vf(RRYQ#0JDG)c#< zzR=IY2PZoqYVHSl@MDF+!1a48f?paZ_UKgdxH#QSa%_Gkf~(5%hlHY~8a4#*-u0I> zJyoSaZhCA*I}YuLCDLD>8TwpH-DbY!WxP1k#1sN~_WAVS`_nIk-DTGuNGMiFY}Tkf z4G3&%k*avvEQd!hQpo@hbqltHIJPA>qYeF2Vi9@(+~BXbb_YB;$%6%&y0a4k)Zvi# zUU&{1Url>dxHJgqgsrHgl*}+Za$>7hUW?~cFY?)mf$Kx?Qj_W7P9vDhvTt9E2S{BU zeIVi*>x`_wJtUwzABTIi`{ym7B7yxIX9@bmN(Z z1M)qqfNO6|O{C&|;e;}|$~VE$fhhPhf(5lIWlt>7f|-2tp9h;z^ai+oR>{)YKR2SI z%o6vXOXVpj$oo5fIle%wwv0T*pqq{d2~TW4}@;Ej2Z= z#FRVOpQOvCj@{^^>9|;$HRu0^4O%UXhCG5(qevhhCt{A^(^o0UdjpLmQ6J*gB)z+$ zoelgHbc#P<0{QZ8zxpW)nIqk<-Hcx)4w=h$pJ|A4g=;p!N4wzK{FZnZ4|z5^bm0Cp z>_FpO-??Tk<=3iWA$nS+XvI`<|no z_g2~S`$Axnl3Y!}KaWee9em!Rs`-1r8CfPw%T2Qxq_UY$oGRa z-iMSGSKJ_WPZI8Ah$kE|$|m8&Ur6V1oW$QSv|%|B%7?I-E(w(P=sjA`fe4A!+%tH$ z#PuGA${nTP6IvgG5U)vaKME7`L4ssFL}HN#d1=S8Zvk&Ve+zqWdEKp9`ISDBSn-aC0EXDq0 zn*II%{~0DT)#7Kz&Nj<=zm*%K+wnW>#{*X05&7BWrWqn3hsYZDpO6PbD-E{yK0DnZ z5|0CXIN5SY8>kgEx5=5a|IZg@PV3ot01sj8>9Re#a$mF;%qydrA@!-b_@?6YJK0{Z#&wl4)xzQMm8;PdtW}7H%?TFveuvF4b$C96~O&p-t`t{@reZ9%TQD|jFGOV3SYT5 zjZ%6#olbH5ypjj@v(oBg5l`3~7KmE!RQ;~UI;sD5ZoqqQCJ; zR-9Fv!e8*pwU$6B6is@#vrHyKuo?2`apJ-8?vtiOhvA#LKwf+slFIDp^kk*rTsxmp z?aJ}QX|TNcN47QN@86)>>$I~nwMxqgD!PB$jTk^HAk3&}a9?(5fjolKI18XY`fZ;{ zHL3L#j2mG7@Tm}C&vZ$w3)mw`)=dawzvJFqS@?7%fr5# zS!9_uIHHcULf%DBAvizB7BU|k=j;{6LSV14ExhS09)U5lzN>TTbyR*16o~lkC_U+u+j%kH&s}G~ z+}~PJ@_9_`{&oBf@GempLf|Tk1CbXiJti{CTly>xS~><}kSOQ!42A`14A%M}kCvYX z{GQgqY3S)WtdCHu&NyyvF8yqO(Nt+DjoNc+@#qhLhm?EL_i94A(U9ubW8ek@+SGPF zp3L@?@R672ZVQpDdPhIx!PFQZ0oTu`r%o#|JGFY%6yYb*nkM-hR#pK_`^|EjF-Gux zl0l6K_eHr9efLPL(`1*`>4QB$SS@ZG+w)N__`G*sbH;pt2)^9~jJW7Tb34zhs zYxSjO+%AW4X@mvRH3!09MBw~LRSRarf#FeGD(CnAhaM}Z;&c_*5l#vSzBPLZl=kje z+Dt-TP-ztS{B9vNqQog>%dQyj9q)xNE!BsGotnSz})Ce92B_!RC_`5t($$)T;IEYEy|(m+bS6 zL*;`RDJQ^-$VfT}bO>A_sQ&gYe(Uy&{KsMTZn@6#PyIZHhWiEq8ncjR*$Vw$;0uv~ z^)&w3C9}>UI_9{nsnAr0I49UOWS&O}7Qkcgx_wNcB9$#H9^F_Z4|2vyyC(k`d-)}s zTYIi{{%wEoBILnu6@l;DV}#nbVOFa7tqRkAydZekW$EhYU)AksaJ_Z-9{A((;6|tO z&KdDe$aY0o+1E*U7w8q=Bi{}-QeHux9IhdFo{LdEx9mayIrrWzXp-v%&IJr8YY{je`z8`PSc5%+`!vQ?XpJsBY75k60VX80n--!t4xF%#IR2V+` zj($(FbVW3%yo0>&LV4i&UtDHNC!(!lNcaxr9$XTWePK)ytQcHK0ZH|;IpFbEDx||& z3--SwtT){<6GL$wtMkRhbj%TMxJcN38RhMH4|xdX(V&O6)moqxD$*3J+?qfmgD7*w zZl6U9V~Rj5*XjUxBVHp5O+4Ihs#WCi!um;Na>r+PYMbd)+DSin4W6^z6g@&7^9nrJ zKJ(aV<*wQlAl8Of4lmu}IbsJp>bkH#C1vpI0q4`v7F~TrW2J=3NM&^S6ZK>BHUSNX zD1UV~VTM~WUd@peQ6un03`px$QpMiTBcB`s^#y+a&_^F8q&IvDd$9ql$ z4Y|-DPxp)$e13fmjBM|$U`jeBwtYr-@cG>&6xFuSNH1aN!Pl{2*4`j%R>iDrV>lz@ zIC?T6rBD;he}&P);jE=sDn+Bg$j5}d8=M*Ne)%X|Q;-*jqx=a+1G~;Xjm5KzCB?ex zBQgSy-jxik0o?1IBG@S50#y`L{=Hz4%^2! z;rFgy!H;*LB#=kiCIXJfv#d&x-_ZI9S1uWa9_sb0dEWXPddlcc4n_HZ_a8Iw!}OQ; zhp(|14bVqAN*xX9!^<%I>s$st>9+Gkze>ZVfV?i%39!B2H`LUn>tYu#Huf0sFd}H3 z5!n7j%^+0}(1jle1(Uf5Kc!rG~|pVror#Wyry1a)sM|QcHsImQi%Fat8~xFVkL&5 z#vL3>*2{Y1zjCORs9LZn9@0s5_JaS)TZsM&@XYUm?M>FnS&qnAB5?~rUctE_cpgcK z;<0C)V&>)^doW)7^!O_pBceEr^Hdm&5l=SY>15NCtRu7@q(2!)c(7;o{QuLTg-&r6 zPU86LTaHZhHrk?)ciQI;wpTNbr>|Dl-9EpF92H2YvcKJL7a0qm8Yx+kV#xr!MI95$ z>9xYT{1ycs+ho+ZVKK8VM(+!Z>ZeaH`Lr3Ct^RovqHJKkUpgFwRJ8reT-4tc7gc20 z9tnE&Z9RED`0xu0Nc{$IdB`W>cMi}0*54e3K4y6~w=ovIP{>wjy>O#*g4dsJz zy1NIiAMVEZmZN++%bwbwz1$wmS1B$W`kN$qUp^fiGXeQ>di~hgH8Q7qv`%25@pLLVSP>pDv&pUi9rYC)1KFz_FS*M z+_%T6REbbBpvaHlY*-CcHN4=!1-xm8JpD@y%J>)j5q#@45w;^9Jd7NXha)|@_wFSM zgp)!4JQ5_ae!%m^Ny+3L@XVe~!dG!QRz(r|PJ(=(QB0dgj57szjQN_Y`qHZRbC_|C z0d!S)7!76Ld|k2VvTb2}sLIKIue^ow9X;lQ`;E*_4k39}Jq9T?yNQtef@xh{4_KC50`v-Fu0$L?#h&b8sz;vA)uk)mgM!7ao6vBqHV57 z(F1L9`#&gSqwoJ+zx@!fKJxX3skj(57YV+KuJH|=Xiqb`@UQQBUxwztUk37(@T8d7 z{knJ#pH%(Il*YAq=>QkM;1bz#=-y+3V z9i(qfOw&b?!{WH)Z`1+L$w>8$qm9G9zyGYwXfwH2B}JPThr!W}GXut9PJ0@vs3GL7 zs7itJ!Ig5)Qk470DqVY$4Ek6uxp?j6-HZ8yO8Gv-uYh;d!uA`kzSK|p_d$2|ZZra8 zLc|UOoXq<1OE>Qet!{QlQ^+G(3w6Cn68jWF8K#UF9E+w+=reCxif4JHtYW~(7@(Lr|!0}owui};Zd;JbN zjQ4{29!Uh#ZiPpqRnmLC!@u7F`Hs8DiCVGVx%ia7{n6%n+8o;0AodjLir;@B-`70H z_$t>1^19l0!Sh^Bbd+(jU8$y|bZ`ABj*Xmr=Dy8f_&qlmZ)a-;Jd|>k=je?78uuc} z**!2`NKx;6kUr>Appc>-SZU-i+GBixJiCrv@cIonj57i*Nys`TloNEK6v(Tx`$McL0Nz%=qZ>Fs6!F>0)+%=pG zuL`i?lACMxhD>(4zXZLobQd*MaEN=ojckYR0D13rb;0%zZ`Fw$|75Vy`)QFbW?r5F z7k$m%Z-=NY>~k0Jd@-YF?bCpiI$`PAAVeQG+?(+LPUht-s@_1BdfBIKINLG*JcAu^ zXgw#PIGbT1^k!R%g~(oVZ&Sn+Yuyi)QCu>Q!38KUlZlzyqwUF^ku8FI$WYpp2yz<& zTM_nLlQ(`e*XALSfIE~Ap0@{F&&IR~wsd{UOqj7yY6`*wyfXP6|o_j6ol()LE=V^Q_h4tU?1bT0$g1#rt!luLtBskm7^m4U0U!imk|vw9g#I zQEy9iSd@wVV=^Z(`W&)psa>+U_w@liD+k8JPdPr}z>d4clUevD`kaH5F5$sv`_ zTK$qGWx<&eww?K)Tpxy37bW83J z7rst1INmL%OY$O*+pQPzjZ=R-c>P@<6b&wK1#bKFOb{{Ki`%i;5Aq0MN0r6`J%S3%l3*g)Fnm&S z?Ajiss07Vtf5;P1tpvySr$&f4y0Q1XVKg?Qy83J@__O)NLIS@Aa@tOw0bc9ger>;O znh5;hH^iQ*H-rcV-FkVQ><g^mY#=9@h zvb7iSCQi=$u#VjUuUqmC`M&+DssCHU`8=xQSA}wUg9&A}>>jEEF>t@&UU~#U9&u3R zOQ5`Tw#2Y8?ALQ;vffq2&jRvkghn&=(Y+F_^1ceK5=p z>GqfHTGmtTr8pd(yxWV-E@RKLf zh9OoACgAv<>O1^KZO4f~cVCESQGToQ%gA(1jw_6S2*0TDSZ#&LkzB}wE5E7%Jdt7- zEQ5^JS4P z2T!6tlB0o$2m$Fh;sZ`Kt>*Gv4qoUuc#+;91ejh6=3rb}4*V z;N?tRVr%c!Zg(j7lXfMTkq>y5(YK;fi6jPNQTuE9y^G%yc z^Plj7`+2_n`;^VHh;xqwB@>vhVb`qQ@@!ziEeO_ih5C4q3#LExK^|N@!vK)4PX|}+ zpzzDH$@|wO63Yt71h;m6dENFSEqCYfKzWm{nwtw}t~nmhW|ppD%%neY#%6N=piY+0 zAv>+t{830f40)=?J>YnwRbirD{TI4nc%r_G>Jw^DNfGX&T>10eIKu~1z z^=OvZvpJZjwt@P9=Zu-~+}z++DJ5|UMdOu$(z_pYDEGB{@uoR)j0BZot{W4OHzHjJ zzVG6BqKA^A?24BTE12)lm3XpvSGnT(hDE4=9ySf|w2#BrmU`@$Ue9QXe<^Wn71Uza zDl$^cOp{F1d2T3Nb@9)`-&i9e!#zLNwn=!70W`X-h z$~j+kP`C6ljG4WAaK8z_imrDQnb*Dk@j_kHWuI(~J!2BeC%;_>KEE+mAw}&lp6FxY zS;5*m*D|jN(VonDTJqI=EyyV++8nJ>& zs5%dM$g(T3K)#>W454j*G-f%4yjt}Z=GnS0Kv&4XBGA3i=wi`(+|Ceu! zot6oWNvxV@c5hFpe}?26(IO{9>pJ8m=xd7ro-?)et!(xDN30iXwm+u?KEeJL;b&__ z&9Q8Go(p*163aUA!TJiu`pv`N-W4B-%Osu2f49ilz$#T5WU|F9+JZdZeHCy$r%};z z=j%|s8sRICVqM{<<_&|eFR|4{vFOWD!1MFnV6^S&rOrQ#b{rP0;tkkMj#4h{Fa)@CLJ9)GPy;0-Ym=TxxI`^^EPwBZm$h#zg zelNkckGRhdUz=nMeNMltL}cpQ=U-%(&2#vQrzUv7_3L4N6^bL8v21BgS9t!6X{tnb zG`5=b$o1|H&jhyr5!vDNUp{e`J|JJ!GI{8)(v|tF8($`5J4+JM{qKxCYsIhsbP}Qi zUaM%YrTUh!u!osh9Npf`PKc!mi;S$54(|^JjW!iJ2k#rmBewcw0(hg}m5rQ(%1>1k z6yv-~`ZEHa1+$yF`v~^Wqk>2{4`H3 zB=&#n-5LG<19_g!^={@hR8)?8(5 z%07-JX}Bf&vUnB^@(}$p!1Eh1JfyoR{6T2n=9I1Kxg-~4J*Y^=E)JQ#ZBLN`9^&dB z-tS$7Q5gCD;l+A(5@!5=Y&#gn~7-iH)7aC{ZKXA*{nGH>U|kTs>m z`E`I%Ygg@|5St>&ntA~6c5VgF1t@Xi)vT5#&}WQXle8z&+A5!!uy#_`P!1#o-eW-C zE3`-O`MAl--3zPfZTbI8 z4*Xxpp6L2`2Bzf)VMARGex+c-cP-pT)=; zN8axSPXgteeNzs$FFb>cof3L#p>IAv%ctqEOgT~6F>FRYPK*nG1lRxkD+As%AD=c$ zU?C|66)>_R--=)ItD=gy+#W9uUa81NkwacllPy@kW<*a6J=oZ6tO^s;QY#5us0R5Y z-v~Y2nb6LG=Y2A|=jp|%?NHquc8nC$)5*wyjwba4~DQ14!|;mZq3pgwqXE@3{|Byf7;i{x}!23vX*&W*1A zVK1^Ns%fsy`IL=719{h<@WJ|JJCqYdl})KMl@RP8`o8vh&&{9GN4o&|4AB^Tzf7;x zML<-=`je7fYZ8uml}WzF{B~$E6JmgRb*3-XGd$sc9+G4xIRD+0u4!=`G$k7`kl06O zmcV8AoQxdrBRW}~vZ4m^eO;q~KT62UrQ-9yEp@kh(}AQ8D>InfjYTmub2j&mR)PV_ z$NfwhTptn$|Hw=+7lcKYyZV%?WPfG2^1Z3BZtB=3e{CJ$;nrz1+HBP5s#AoBUzQA9 zi_pvM+P%fGTy=0OmbFmWAZCWV)DnNNzr(i9f8{i6Nt=JY$y zItjo-jmYqqQE0R}-%wdvTf+CS5Jx3sUdt~ydeWDVA?uv={hwEkodeF#9kjH$2b-)_ zNLYMHV_-VNELaV8JKn@3)3}}l175aW+E#HEe)n&m*#^|fN0*qUZnDa-U`swYc1df+ zJ{&U^DBmeSI-_&tvG3|-LA&~&Y-utY;H@+0S zC{v4~cU%(zGcuJg!>&5-=`eAHcptAVdDW5cG9;TcXTs@Tmj^M&`S3uV zOx!N`zF#ptA>J|`Z7qSOW!V0l!QuC$DcM4osNjq9VX!^rSb%x@dQd-apF)CMH-w4$ z(?C3B=pd(veCPC=_d0y$r@WAdL|+5;M^|KTp1~q8wC+X#X48xccQ!tcRMZgHe-1z6j)TAAX|;+CMa+x2)34 z68PNKqUo72Dmc@AEq;fhE@vYe1|g%y0wbMqe> z#mn)+CO*5oGJXv{AC~TqWQ^E%72IL#3p2lImmCsd)(R^b(@_g%Edewz6JO9 z7k@aplrQhO>6Vgy3G1yFbLQvcPan;5{j8&4jmA&Xnf?aya2+1O`vs?==%XZVB9nPi z4>ukeyDFmEgAh6DXivGlD7Zg!5^L=xw%VR9#$Oq;h0L}btCfY^J40ulNbcV&lJn?I zqXv1@=+D64hwxv2AtA0gho(?bY(VH4wwt^9>x$c0LIo{|oDirFq=!`{X0h_m3&)9y zgrdKbb`nB#G2wjl0U zV;@F7VFo-qx>W-;MR#~~j?6!+9|#T)gG6_)y`*~a+*XvwGd`)}y@$MHH9qipYY*(2 zM6cLq3o%~|Mt>P#{M~x2?Muq0r}N2=Q@~3IG8+B+-29waujQA(fv&tI{xt(fJ`X8@ zjuR;XU3$B#9^^eiht&n@Lo~4PpwdGmQcsneTeWf>0~5|h@4QK>TA!`R4e&TJ1WH}E zuPnaXn4mbck_}w82F}@1gf{#LwS?PI#X9UXhCGR)3vm9nGDMeV>|uTIBp@>a2K|e% ziTK|q`V4hZ8n}ZgfM?0i;UC%ED>6obMStQ_5c!cPg@q!*S)d|yTW%xtWzB>sAyFJykBn*!1c-Jd1&~a=sL)f{FZ$v8%Lf*miems?8IuHob$l* z7SAjqKa7)E4fmHT!{EjQri=@#$Dk*)Qdl!#7>FRJ#(lMgyu(@}@VwNJmGW}-eRP#( zhEHg2Vc8fDk&)Wy5T=3ta+@%a4>#oC5kt1pj*STEgzxKS1^NKayi&N+<*8UH>E>A1 z-R}>Ox6=!~Z~BY$+7EGPwOoDr6yuFXSl7;q`)9WwEd}^ACbNJi4#$%J`P7AjX?Q=d zys3fMwo+!xF4A35wM;R{g@ap~;uGW%2rKRY*Y6lB!>ibve{%S(_p29;?FquqdID-* zGO)rYCB6qd!&_8B>kwnFYNBK*S)vS~x)vg#nCHCix%N$-|FLwJQB`bV7=UR6N$C#h z?hvHALAtv;1d)&q=@yUF$=41`(vYy?18(eb#!``%UcGHFF|tUUqwWL0+yO zA9(!U{}Cm0c2jStjgE?bQkqrD=)1uY$W%X?H|L@bcm`$9#Q}K4p6U+jt~p{kCJC= z*QeAR7WE#l&1G&{#<}(Qc7ALE-Y3?do+b36mgy=%$D354nI(?1DH$>1#N*WVmH4`f zm`S0KCrQ!40(kr^FLU-{YHh7)lCyo-OL&c$e0ZLcg`5*Ib%Xm~roKJHf0E}b=Ri|d zquT}hwlnNXg1jX|?RB#TJ%HO^sZ zVXeE=<`l>$@@pL-WxCWLPJ%R9wyO7P(5LkOw*vAg;ksqoLh@|~G9n?b#d;ZhKkEOk z&s3LbJ8Dw@Z{uStE=e4N>Yi_!$b?KT;qic%qg{X2Y8RO0mlCKH#w*_+XJDR5_UdVC zyJ(7o?2?vkMl9q#>IZ@2t!g)WV&o4&8=dTPAxZ_DYa8vzpWzQ%R$EkAe*@l@Ly4GG ztO`4VtKI2A=Hl^)XEC-9>z}RjKOBSUrw)7t36MvSx&zMd((t#jjq~>ZNs_ifn{M^T zil`VNAR-Bs2>W0w4tTMJu7u6}>ZFcRW|I%XYOv?46d5@`@lS6JRr{a*^}tw4ggk$8 z==*v&r(5T!!5sUsazdz>b^9UW{aw~Ix|(!{`2s9}$DexLx_96A@%|zSrKayKb=12> ztkbPM5e+i_oJdN;VfjqRBie9{2F^!^?ux8_KU^k`Y#-@^Fb;uTE?4q>Pb@RG8tr7B8PM(16GdvY> zodCSZj*#U@>p-R*n+Qqz|DVti)gyky{|M9zdmb-4^R(3cZ^YY$2ikMg0&y~y0#jcv zyPJ-#Y}_4*+^>*F%E4&}96$S$szWh~=LFsR#V~l8zkX6Y7;;gRQodazqT2>Mc5eK$ zN%~XULr=tEb-9+43X4|>3fuAWVYb7a8GX)C%uSHz=Uor>pL4cHsCtPUF+Mi%QBc17o<8Ea8E{aJP zne*08O$d&UsG_s6s=3=g zDWGb_m~Rf{@c7GkhiA*y-!?2 z{+;eQ+%*Run{~ODgj)JMerd&kNNw&LYbmh3lBeuUitFrXD-qBMPQmPE&^%Kq&gW2U zAz(gV*!+njF#FHjkXZwdpXx(00?*MT{T_>dnbm8FjWRI>T-UA$VxySfVE@4O#*~60 z`hB!6ti9b#8I^k%3V}plzwWN9$rCIsI=2mqQ79iS!b@=eFSYYRFKRz$vYdd9lYXK* z-G)DGq(nJu?`gy=*gp-VdQ=V>>tEk(&>y*HOaF!zWF)D1R#Dq_BFT`uBJiW-pI3EQ z2#!~$o__XdGpQ$N%H5|&CXv{4TceP}9(u(u;iI|;oZo;*HTK0YtDcyxpG~k?H3yNO zKkZ8j@3_Wl${JQ`t?Ghv$t6BvK|r@usLg;X}dc~yPoF{IU{vHAn*6II{5tX2zGS99G+$R zoM}WeG2hYe^q5_hHSK74IzM9wh|x{z3VP@vW_p-+I!6g~3^VWDb{)9l01 z#qo^Fvr-Z&Hd)?Hv{r0&^Z3%OFE9t?``l8C0^Gmlw04zy;%4r{e@dtOzVeua&e(UW z*FSla_s|DE&$oN2TVCu6eMBU}N(o&$yoTregv>WC_d6FhEzK+ucyQjz~)0!?Q8&3qL@vjYf8g}c7guwPHID6gTJLYb`Xr+>rVoyU08vV}B0@18q zS`fvy%n4V?$TF1AEZGEnp1TW1Gz-<*`EQ58Q<_QNvl7lpQfN5(&`)O=f%DJ!lqG*J zA3h{L;u_QQKM}4QuBcCVg+-{^J$FGMUjS3jybgJ!4c=KmzGf7WSKe2|!Ga#7=>3ED zJLIB*^&IsH))T$POaK22lTKb5*gpDs?~eGjao~LDFFsBGV4GG#BSOS%cU==-VY)5I zo8OcK=MSjD8;w63P##{=54HYkc{cia-<4S;UPp90Vuu>=#K^u;PA~-u)SQqpy?uA* zKPJAf_MFAVS$eyjK%2{U;{Ffhg(@C%0r`TPbe>ut9%IC1^eGllc@?9g$>ewYItLA4 zZ&3nXOuJ$Ww*kV20(Ph8^Yc;`2^Yj;9&>HJb88zoZ{xqx<_C~R5fKGm&j)taer^1X zZ6BM{MmLdCrhTh?Nn!-E?Nt}r!10I6yoSErTY}zrSGIiB2p64vb1ZXMRQ;a0x~GY} z?L1g#|2$+`K5+f5a_+gTmXA&R%4$H5$4%b{BSN0;7YV6s6q+;Oe5XJmMUQxV2_{16 zY18o9BBNB3*v8X&UCV58L0rw0zHD)O%scojnPU6vq^R@lLaJ8948rb~LJ8gs3lgrnJ z`8x_1&HsPtxz4PW=Tkh=b%4=3vcxhLs#3sPe33{%vx}=A7I7BLH@!FS3yXDldRBWH zK9*$_+c`=za|-1PBDn*{Gwx%BzN``}ih2RK?_?|&^k^N6?0pH~hJz_(1p)8bbVuii zts72w?Rbdww`a`>e-qPG{DU~MhyLG%(l(}7bq0Afn+)K7pRNnnx_Mb&@88@v(v92U zFu7dRN-WH2#xsj~tAID-XchE&xjRa2;7n&_{u+jMar#pynarEx7q2qJDHmWQ&LMBm z7y3TUW9SDA4E()V-R%!7KAa@?7!eH>Xx>P;DXCI_0I#4kQ|ohyQ}W=2bZW&{mYo+O zL@Xr%qR+_nQl(V-B!8q{LS8hv2zWhL1wPVHepn5qh%Y3KBi>CY&A3Am`k6{mrT*R) z@ZuLVK49*14vhZ}2s{oF)e9*8qe3u_Bf{opA1d!7Doz7K1+J%7*&1F+%#*)TEJ1Z89t9dx-srZMWo+i{J7mD?mh@n3xyH$Y z^Y9(B%%ola96%Xymct24QKxFqBx3c~1Qqh0?2uOi`GQ10JO4pof%E$|^10Zc-tkaP zZqK(Rrv4g!9h}dp_g>L=Of;&&6!C%G?fs;3g{Vr5$GAxNVJB6iP?zW-7aj5(LZZR( zK1wV)L0#ZixGh|&`oq8qno<=ELFTb2zwfVIDS>>9@pgd<*MgHhGPzIj?dO z{pQ0coFh$eE$VlkVME^D4{5OdqjoBb{=%tmkNl*btO99nnFoKm)zB3)@K<#^Ip7Th z6Pp)Ye9G{~NRYsZ3A>JQ@J4PCBE5dConk*N#Bdiu40$-6!ZSd2SFOAq2Evk`^U0B(S%Re=Tc#k`pPW=$x>GavW2wUXm<-R9 z39HqMLI!)5rYj!b&!m6#>dO`b(EB$`>ZcJ9xRw55 zj?xAP81--KkHrA*I`8X~(aT79FPz2I`Jp$>1+2zB!d~h(OeCL9dX>9gcCkX9xv?oY zK3cSM&6Zgr=>E_WI`bVPeb4axq?E-bsKMEPatrWydpXpUnbI=Igknh_mWfl^CZET< z9=Q4ih5ub^HWqgaPT_#RO>p`l2x|05|v(DH{@R)B|+ z=`;F-%GVWffc2C^m8!zB5~+J?spU3R;Hi(>8D6CaC*O62`R4i96I{=^0Pkt9POjbDh(V_|=H}3+;*yH24n;*4eg#G z$V>Yfg9aQw^15BM;f#SO|32-`=M9e|l#;XWPgKuT*ZiG&0gt()fQ7`;eriNg$V1r> z>431G(iJxoZP38wHK9R~)j>LZ%Z~#E+i8vUkEL z_>|HC@A@QrEyQ;Jf~Q7b>}O&(iu3H;ZYyp;u6*4^6nEULU@b4?{nSqY`}auddt;+v zBIndXYc1@mmsNPL4SW!W+}>xYnHT}yUrgV-`}M&IE>gYcrlBSU^ECz48^!uWN!=r> zNEdHB=KpzaF}`5`FZm+39EMb5LyYL$R`r#7RMv1ZdiarPR%5v^I9_-fcI(HOgxq0u zygh4#h8numW>xN{h&6taLm;|5bfiPc2j%;&dI@?4PKw6^TlH z2#H8{5&90U2W+@VV6S*!r9U;Uve)xEA##=wd2PlV*sZo@Mg1kT%@eR3pA#PEIwRIy*aboH&j4N zS~v|_hnB4>lvWw`Y~{v4tk78$^2(%O!0|#`2NipqvqpwT07iYS z>p|V9&Mkf-$%UIJ|UihZ+GR>;DfP=FzTx7Xyh*%tHU&hIO@@0JVbe0(8 zC09j)_lMh?qLZsh$6B#Ii%Gp;-L_056BiAsN1Uy$viE?81@o)nt@ryf#sWPVO62O* zWCKQ~TEV3@#*(3~89rN0AxX$1maqQ;)XVnKWWkI=a<_Whf8R&Dz{_*#=I{i!JC(Ck zoD=Y9Zul~oh4NBDjuB53P@O2>A{2P(b7(E%8z%k0TDtDhl!ZLeVr6iCgZxWXH%^Qu z+InT=4${!M(_fo;JaP32Y@>8odBB^uLb+i*m*yP~@)k^MYi@s$&fry$o%C4gVEB36 z>InP2Hsm4k%1s0L>`gOV!+(_c>WB3+7rp-O#OLxhGB9>zn9igFAMnVziYdBYX5?vL zj=~^kx-9TJYnoNP3|Y`;u`EsMqJK zwQc6SO|C5&>R|0x%kA{gKW-)EQZ#UWED~eNJaesfkk@0^$Oh!Y`lH$7wJ$*xa7oh9 z>(f&4?4he+-}v3ZQ@KCj{tesZD*FTqL@eF=a;ojyS5|ci5oOOw8^gL)k+BxOeNQ)a zfIO0?yH$XPq7@)qC=iTMt~~x7MWWz37p)z|YOBZsJoh$v>bkZBF@NU67%SS8+>4F|_92Tqpe7A#q^2>4ZUe+%O_ z)HJ32?C1`8ulFCo_GPhLs@pn`a<6dYshJ8E-SD(QXhiYs3om#-du-0N~l>N%( zd38Q_^YC1H$wkj-ubg_dJ_%inC@&7z%nS0c^xDArCVT0$H?F-^l`Hn4ai3m`9k{)p13>Z0XJL7rs09o313rt z&Dg2afF(m15_z1uxn=QE%Btf5;<^_EZEs%^)nPnMbmB=~#Bcy$_YuDx!SKGL!ewB*_G zb9_F1{!y^-hlvewY`h^ar}$I|Fc_QNv6Xm_Mwr>``~$!nSfldYR_ zu$F@JSMMJ(O@%4?LQu@g`y{wyKlSvXNd4d%>ttP`JPzo9=YkJ~Jd&wWFyDOp=!G$7 z(#^~aYBKTsN_czVLf~5UC-0vW@<>2FmF9OlwB3trn&LH|c}PxMX06qpo-a{XBmGJ! z?rK|*@B8PCoR?r4Fg$qft6sPl&I@#A zzWdGf{3SaZ`fDJc5F$^&@+Bj;2K#r6jxRA`hC=tM2{;0!ZgmaF_ziRnmjAqy{ARG; zg0W3n6|C#Ww<15{@e4!U&N3fft&p7V2BPk*0ABkG=JqV1B2>1&9N0(}qw>S7;~%Fo zmq@jh3Hf>5N=AN1LHY8wvB3V254Q*6nm%fEy?@GwDcj-^93tvV%7<*Zg8U%~z{6Rb ziH5h$=;*Lx2mJPb4jbV$4Lmau1v|)jGr(X^0Ltm!F&@8gue%7%F2#+nI7yF z$EAkF1E$GLy_WFG`;!5$zgAA*A|Y~jRS%<>#%MJN#p5bh9lkBU`gAS3@4FlVOg!Wv z%+{O($B+F_%~zYYhJpE{nU=069H4gx2=!C8n)T!s_q}#V|SDr42%(w{#+9(170Nui5q`yiPy;n{-f1E9(%O(7Zl5ptV{Gu> zjSSu5FwwQ*?)z-W8&`1w>s1ZAqk$2weReHFyi<;-&R^J2F*z2g_%Z{9WdiVwesqa@ z%44u(@-`ljFeW&UTl|^uIa{Uqisi6rI8`c9p96XF3;f{o!({5}xnPn$SCkUvf%-&Z zSN=YS&!coUmvktcci|<>sn;$0VrwL9&7AWtE0yc;?o^RbFfr2SL!Rn8 z1kg)I*1L&8&WlxOMjKPI!CU@CfI3S(c1P#2It#E`-*6pmeYhhssUB3GUgZ73ou-jwD&@{b3Q=6 z;)T$8+ebk^S&T6QiU0qT`Y-ZH{C=!jn%fVvWPxNO*6x4aXl@6zpG!!0J1yro>V!&| z#Z;nKrH_Bh%ho)E7ZaiElz=BRH8mYR%H^OCUMKWi;jO5Wn2Uarq1~I;7p6XHkHJ`+XhiJ0h$CFS%%Cl`)N$zI+uV?k?aRLp5R_RQfqZ`uRu-HnJLt(s9Qo~i;TD$jyF@H*bI9)( z?mN(A3?!8Qd7&scVE;6qKfxfy;KxtTXk(0;@j>(-p;`F3j{W@ZKf8|rkA2lVUPHUc zCBBa<1Y5-P6?w;~z^1uiirxTyfU1qvflv*UF9zun>|YVyQ=7$pJsHM}k0#MmHg@6r9u7lY!y|sz;NCnjkmk$?4;a%Z7zcg1x-&l9PR;Jg zXR-ISb9xv$-)c_k8q~f(Udz`n;QlZ#Lx)yr|LwVEyY;2t?=(z9)GvNzeT3=B+j#}< z*DGEl zhu>czul%$I+|TNQlE}lfyG>dq-|}7dej><8J2)r9cV6Bt%@kZuW`6nqT%K3CD9%y9 zZ`o~;4Yh8=?Ana|z-Ky9q@>7~>lq!8x1Uf2&PPmao!fon?wKWQT#ZorO3rvWYJ5^+ zC>@WY!mj|FU+3O64_!D;QdUygsG)xDzKzg&nyFCd3gdw{5k=`S_e)*>@~xzR&yOeT z)k$o1$4yx1@CS(Bi*^}uK2`?nw0_g~_QL`^>y(7Zy6=-OneugpcPzzO-@pEpV%FDh z;It;u`HV_kV5S@LP&pI8_U|?ICA^5#t?o*oCUe7Wuu#@+1qRWTAiaDDj9^l zuY^LlfJZpQSwLhiBzSJYyTpZ(upX7vC06abV%#8{VFP&MuYSL+u8#=A^;c?nv#=@m zQG&ExU4=h`L5c(+UfZVEX9V(y_|}sE?`neEt>1DU2DQecNca!!A)8ETIoA|ay2pBS>nql-R4ITEy`FfIfaj%^)m!cRsV{D5??x&{FF6l+=45MN|H^a~CghzNi{kd-G+)k|!{TO8{&b+( zT4a&n88|zM#kv29KNv)aoc!_F{a{=E$-(mJ)U8aRG4q4@M}gSRdCh!#ag1DP9>Il>XIFim~< zNip#E<9H^xmmm*CN;U?l_Y>z*0epqL1flLV)z6JZ)o1%gL8@Y5($R#0-hk(U@ORAB z=o_mH=Z9YQnq0fDFeCCd4?o^*P9A*SzMsy`{^wn1o`L+P`+<< ziQw}iSX}i@4o&e9L8CrnbXQEhG^%@QLE&euauW|Tz>7c)Bt;oD=-@DP`u2MH{dfI> zcdz;t$Ef*=2GWv+o_FkTLmsi;MIcb`@C}^vl1t*p=O$&>m3}2CRnu^Oh`|a^Ovh!F z08iS~mtj~(`a+4_hJ5EIjh#5BC;EgWwiCscp3|oSqIjWQ$a~TNn*(@`FL0b`x1Zls ztOWR$CSt;47tAsasl zSxNRF@9;Azcz%@xMmo>JbRP1x#%~O8`s}v%+3Z%fTgfRRe$4}3Z2M=H?c95v2MnX& z9rbe_Y@#~`d?if|H%ug|=FL7s113*7W`Z*_LoU$}+A0 zUji~$z(c{Q@IPm>ry|ga_L%YPQa))VeD;T#fWomjvwqrcqF(P0l+Pm89c=Flu7(_W z-Uo->g?@ARs zLWNQUz6kC^9{)iySg$`~IO_FN?lQdzmCsE>%5GuvC? zK*j&m=1TFzlF<1cY2JnI=UU2FJQHPd!Wj8n$qyc3qJCPe;%mEhMBB9ggkk^LhyO6 zW~7Ag+OS)5T0oJ@rmCehLB6gti!Qf*&K&~g!}M#5fd3{%8S~UN=+KHqW6}EAk)e1h zJfW7xm+IqGwkOAsx8tD=dT3;MU()Ppt<@K@Sj+PSGKpks-f10}C*6MK0Qb|(yy~VA z!1BDh_(CbV+ zQ8~UxN#lp-PZ!cpfO=ONu@K{ig>B+yl6=IgmFS0<$p}4i)ntuKEHNWr!JSZ@LixPl z4Z!wvO_&Zwf=hRs^!tI%BkdcT#6lcQV|bRzA-{G^z$-jR4iG*_`yI-OIJt(C@Me09 z9;QBKX8H9&sbhp?;#2w?$V2)t4bD%ZaLQ7biS(!aMVIiJM8!hxmf>bFi?lvvQThSS z@1~&5P!->4Cmxdb6J}W;^pd>h+2cU|^-14)3NQ0r_b!Vfs9l(4 z?g7fzW(KDIS$XX%W;lS{aERAd4#-lt^+WiD;rHWAqD+|j_VY9;B{h>>{xO-5n zIOi7@z^l?SFmF;S!nYMH%vZw0+0Nox{FBr!eAap#>BtP5yI~1K4X&@Yg$;r2AGNQ- zU-CWoDZV(e+HGf)AOpP6ce?7be_EE$u>p@a7tx9cR|GfODA(P9`_dx^5BOu zc!Bn`^0X+M($(Zm)f3D9nz2nkZhFnSpRjlhT)Uj$e1s6Ypl!uPWZWm@n-+0x?{)*b z-o6A38QxlX!uffdcT$c>kVmH+3-<4Ig}+aKZgg*%`$oo({ZT%TOxj%`Ja)YE{rhb2 zeZRSID$N4|r~G5tnsTek=!+t)716J;i@k5PUn#UBJKYN+L!O0^G+Mx{HD|^x31J67|+vOcr@%_pB zN8Ns*KpxydI44lA0?FSU;ry6i|8E+_u(8z$o|6-IPBLe3wAx+h1H4;rgwW#YW8eOV zoDX`>Hm_S>7Tn!@N49*jO_jr!8tmzX26-^2DB$z0?C16B#trkWqu^7KA>B@!nU!&X$;Imaa~^V;mRxR&+Lk{`MXg_ zsh&|suMQ-Zqv!s4WK6i=@pBb-m3{PSzM*?JP3GykhJ`^OIl!aYiqn899|Yw4!eok0 zxc;7=)dp3K{X~(7qD!-^5GHj>=V{Yis$b;>4>6Rl{p%Unz6gtpoNy7Q#S2+1vnYzT z)C`z}*lT&(u`!T2v;baQrK)1M^rrKl^w8`k?bs1pVTpM?-Lw0p|5pg{ux<^+Ng!{2 z-XFYPy3%8j=WUY_te)tGX@tL55Xflop_EcT&!Ka#0z52BO~iX#k5#!b0)^@I73#hA zC+>K|({RIbM6aSI72*}hAuptXAKWj1d84C@Qi-RS?3kn35UQmv7fN*yUWcE zcxV}aZRdZMyy;D3U!vI+J32j^SiKj_LsOEzg(awsIX|ZScRno5tEK*lkife&Dy+Oi<&rG4db286$aNsh0;X#>VDmn^n1zG z@8t11uSEOPMSD%=3iZw#mx1kK68Yc9yO4?Xb$Q$mp4#2Q^|$ES7K=JTv5xR?mw8`2r&? zZ0+dhu0B15L%n!T#?RVd#FuipSxtiY;@AH_!_R>LX&nFhc8#e%#$3)V^}R=(*|2bDx|3|1->N z=Y7V#$4{a5)8wBsJyFwaFO9pV7?T*yfAMs7Ccoa$;Do$9%%@=g<&he@1{W5it$Gfz z7rpb;xw1ps@m^4-F1N_H2Jlw@kX8PgU$QR9bUO5OLE@7919!~V^yRL`Gjdi&3VGU! z3-W%EF@WQRj}KI2Uq5BJH+#SQ|Kmc||8JhJ9aVikzUeue!3TIZ!lzcGBUZ$&$%B`> z(|z7K4YlES2$an-1f#FyMa*b4cpxwQ#Upq=blwxuue^FTy^f}FF;;d1S45FKF#ob! zw)J!p0q_vAugl!_{dEJ7{rO^E6Sn)WZ4)}67SQrc=0<;S!-%uvgFJ%O&*1kI@NP8) zPGKd9Ok-nW`wh-?MiN zntOgx>&X54&tr15rF|r3wy^_FZD8{Sl#lIv0UYo5Ts*9w-MgelU#A^2&6X_; zTnA~g!Zt6!`8=lvJi@FxY5VSpo{g7=gN%{Y5tFL9VW!`{O!P}Q(LFoPWP2tAc}QZv z!2Ut4=NFf4SsrR7H&xLZSGL_`4n%gBD*Oo}kDN@v>+Xs@;mdbRdDW&$h|T}zW#VDM z_396_k~QDgPY*Sojk%%YIh`F0S?GF9*g8Z7TlbSC)lUk<)3ev{=@PE{;`6KSUPvr&Rc`b z3Q@>Aq+|g1i+XeSe8bz6yp^FstLxesKGf7x*Cs1vCnB*(?E$N-M6Cf{xU?21_P z^Nx06xX7LVt zHt`L zJ>`8y6_psj>J)(9o4mlt3Ti&@(}xeRE8j&?>zYvB^phPmQI<~F&pgO#yjF!gn2hBz zpk5?Im9oTRerLUx1d%PP{_J6CN1>E-jzPf%p$0&`L&#;3UsQb>DAtcDRwVJF;SD{V zJE;g@NlWM1>P$@}l++>b$)Xk5Uqju}pET$rE6w@JHY*VjE#i4j%cIZt={lUb6x^T9 zx)1k-D9z~by?XcHHR3aj>OG!ccGbztp^4{kaIIp&-v2y#?QHOR4*7hENcPcj%nQF< z_hM&4V`yJYdMznjea^Td7|3TonDE@j__ORg9pz;Du=_{?7IC!hvXBS^N93k%kE~2$ z4JaRTM-n)`)Rl*yuX>rr=k7r$V%0+08z?MIg~y~8A)wPS0eFp8wxua!9KGZ9oJkaM zkM!Trw+sYQ0g)Ds@^ zZeJk*-qx^`kR9LTdFHMAh)Pd|xB2vbX$5yost|za^X}Em| zMMNuUOO7d#IgO@r^9X$nuP?U7VhG-EpXyWD?<(!(D^Ogm^|Vad>lXV_BF4YqxM;k8 zBhKZShHeUZ2*Rof!1>jj)4nNfDaDp1J#>?H$AD2HlV8OXatOm}U`+(_?HkF2_h-{^ zO#~{t$03OtvS7PD*R)F!>BOXThzWYY7qWo7vo2%s{j$``b+XGN_WI~F5;Wo1zkR(G zlPx&+pNHCW-%tP^H=AL-)03j>h-y`Fzp;>4_#JK5<_B1{ZPkbUXDp2ZCI z*W~3g=d{Cal`ihdrF{144q2Z`B-~k47oVLZ`YKM@CAndg>L(^%7_o83&!2Pz> zK`tX^S6=uZ@I2TXo6p4Vg#vwIWpeu2`a#dn6`24+8k(}6GJoNdkf_rFB z&^#G{zl6Uxy@`Uj*rpp{12Jw z_#=xivqK;+c1)TEs8>Y}mXa0`Hw@3lfKzkz4?!Q+^U>^$6C+V#K5+c2HzAJ9U2aiX z;{E0(O|A$vCJK>{lYsJbZG4!8wqtecT`1(i$13Rq-o3mU@#%ZXzT)adT;+aFr;I^Q zZ9A*d3smy{R3Kku#Ac}~p+3=(!?1V~%*~3F3~N-z_r#lCPwMQkt7R&!NXSzl-3Bi( zt;0xHM3~C6j=DKJ*mvtUKGbhVX!Ly}a)!wK0dMd=Yv9qPK#}<~QO%k;>gWKAM2aHy zulR@q6DF8mw;aLukVp767`$Gb4$XF#i0@E^QfoaIbOL0jdxjfCNEyETs@w+mvxbcX zUBck5v4lF_a?kB~ItdbxQLQxppo96kyUGQdsL+xGdB`yO;QbceK@qj!b{pZ8_QB~! z6UjxMmdfQhTiulbwitN*3F!aDJEqH_Q)3lWekVvc*Ws-yhk&O1y?_ZJMj`*ImiYtZ znRwVg2aX?!Biq&Le(I2oSikA9!Ox&MbC26qW;Iw0Dg$4j-aq7HSrq0hAymQl@EOZp zehk$o553xs^S0Dc6ZoTXI-DgE&8mTz zx{U6(@KunfPOHuVcqJ+@UE~zHM!7LKA7+Bhm}i&s=v4N5K3ZHf!5Qw_^KC`w-v^XiJ=t<3q@OPuAdkqy5WGLK zQ%i{C^;#n8gDj>cC#ifZ zHhMn?#&SDRAtr5a(_Th>#?Pq zhC!^_H$kmk7efy@|2%O!W3azgHD;@FZ=HvK#Qpz2M-TP|aF&^&K2bto{zdnj8K@Wb zq&EI5>yfxJs+iVOZ7hvvxR2lMYbuf~8r1OaNv;Z$*Pwi`?9||TUN(QGr`43_1H(Me zBrhF{!mny?CpfQccWf!`FMt=E@%zMwL==%jW`5UTq`-$<*S{z3>1Jw zI^_8~6@%Ba>NebM9*ue>_K;o{8fU0V`u6AbeqS16ar`T=f5576ASQ&~(e7Z|C{zCG zE}u0PyJ+9p8Evvqhs^lhX;{oZPxwy-Snm^7vpKbl8Ivggi{4sZBTvk%H>Glp0)O5z z9xnm;E}lhtoULHLGie$W-YRV9(5EswywQH<@4beeZW~|%qp}I*I~ghl_a78T4eyxx zGTL80#K7u`Q`l)(4#zi1#J}7xO901jHovO{7rvbdlRT)j6aTFb)2EMdBAlgF$Imr^ zDg52z#JB}{%L}bHO}i1x;N>6vJD@Q(iq6WCkGLTfc-+5?=ld z2ZQ|0RqBr|-N#O_yc2?_-wt$h(sO1zsE!~nde$1eUW~pYAx~Dg_fZ6^le|fl@}y8s zYszP#(@C9<_5!@R#oZHz#Zo-?TCarIkw&7C4>vqy=PEJm5yCM;9n=Y}$B>6#ZVS#o zD>`5jSF)R7v>4EeofWhOr}cCtU`G z7LLXT&Eb$lau@SXA&+~O5p4g&R)`(giH$0Y{oFcs_KDD>&Y#3ZtH_zkeA>YRyzOK3 z=J1HxTlU6ClEWCA2*JpKl2M-BClXO@jF^F40|8 zXC!(fN{`;9cH0xLJ{17G*@a&oS`z59RI-&KSjaw(8hi?kr~EzS=K@)zIQU#@vzL(P zYSjYP3yYBLmpZ?XcqrnDzRR9=hFLn_$ux9XN?+v;w)gF7VmbA#G9RVz19hhb&H{XK z44;nZRYY@19M$momR)?mgFKR*W^liEz>=wT{MvqnN|U}b_UKI01JRWg`*ESWKoW*CRWakop@;bdT4jx=jUmU&VEJw{9kG5nJjph@79WuUhbUs9(f;^^Aw?h1Jd% zOFcmO%noJ1`z@HEZ%?jcfZS_Ka7l|)+{N}52O)OME!Azl0_>l@Cl_fQxn)*WMR+xH zo^9eHJ9U!Kq69VtIH#$QB@%D^@xJV-D^JruU<%BENHKf`7 zk>jHYK)x1}Wu+#{JN>9vTiVk z5VdkO5Q&2v-XUhD{kHd{rqd!vjGenWuJ(>Wg1k+oaY~?len+DD>Y0BeS5X&E7-gU- z0lUfL^3j3xSw(g#KHzz#9Yi9O!5>HWBQOceXJWB+Jp;O`&P04&i26cncRf8Lk9 zXz=){pe}of5BX=cKk)D`B>mvkALr1CW}bDe;~sPYyce4x%^d%KKsN*lyPB$B@7AmlY4 ziV6~cN&tIJRYr2@reDMNk^&7NAFfS}z#&~t$3dN)P+soL;D=m1qMVFIuS7yAP5ueK z(oa~B$82K?K7SM8EV!smekdfW?V!BNtZ2M9dyMFyyo{~s5CG@1TNvq-SK~LA>bJ@B z=@=O16D9;HRcrM;Yv9HS88H_EB5@!uEvgKhkDatQ8Hf#l7ZTXsePj!{Ep)1!6^yUy zAG_N~I|lOMh`D+$AM2=O3jW?1<<5Iax8JeRTSjs4>l0GTEgy-M06ygP@j?612leXM z%tIZ|15X#V?XBp$2DM{*eT9UR9Hw5}0p8i*r%w{ylR}O^dv+cR#iq_iW-P+c6_gic zi^|_bI6hH6 z>Y?u%^vEH5y#E$Y-!NK-PLS;9=z?6m$=pN+c`W2n;CMk@Mb*|cBw(Dd@P`!DuPow^ z$uxK0_^;Hk{`fBgo_DVEa@6Mi)1ZU~`T0tzuUv=Jp=R|v`-X7QgZr8lmDp5}NBCY~ z3^>0d+51u*F&7nb=RZUunbevJzI32I^dJtj{$K~+#~vy|%Bab|sQZP;e;Rr{99%P7 z@RbOQCOd4!Q@4iYvE&U6`F{0b#;My{Ws&rsHBhP)E- zO1>uBzj_4`4}f~<r~BdN1t(Z-A=s@lBTn)ga8n zDVb=FPPdKzWf1absoyPS6D3Z_gMoEf0zC4N7_0OhYF)U$Ol$~Gb1-@XktpB3 zJ9s@FXE+RaN4F(3WN0|b6S+RDWGN=Ja(+oqvO^r=sn=Izd_Mod`}@y3&7=m~=WU$f zMg-cGAQ@yD_zY%B+i`K##7PQ0D_qHIRlr*}j9{KCrAy&=P7R+47;STFV$nU5!pmE- zALOoberXvX3gw$^msbVyaYu^>^emG!_s#P4S|~DU7bH*|@9T&r%d66J0-m)cf4KD5 z*L$5e&jgsB2Q1)IEu{bAc_A`{FF#AT$My;wuba~OjKN`zqdz?RE{rps&;{h% zDkP?h$;o*k>XT%s*!H9zZq7M|@U?fKPm)fIMl$$cGstHP5uQxlb z7UVT&V}b2ono91WoFl_{ph4d)4}6?rYJ_hwtJ-Z0u@Y zQl`|$9O~zjo!rFc2jzuFxrKKBJX|t7@cU+0r^*Zowy0Udx?|!`B^&-D`8lWzc5}+ek-Y2FQz&KRIvh%17<-5ew2isHI_W12z zyR&%&!g7C74ehf;!_|17-B{*k5|%jw-p`ZufRqy|2dYiQ>Kn^T7)rLfL*%K@3i3gb zP<{gk`BYuVBSi9}0vxnB2T8$qHXv{dW(u??XK@M>yqN)E?V z{#F^1uaqRurfVj9kkky89*Hz!m}u4h`!q$>yqQ|$OehHC zbn~hfkO!-FwG8Cb{n;IE^jo&dNpJ*pj#Bjpxrp3UPBM>)jO@G5K)zlkzdx`0;_s)m za(h&X?~`z+(PmEL`>dSn3mjgMc(@PQLmqDY0GKbei=a?g8cj0c#EOYHVye96XR9a4 zuu=M_d`s~DD3D{FW@+qJ!AMW{t-h$z-U)2Cb1&vf$e_fRP!LuowQ+zvn_5Y5zk-jj zjBGV;-@HL_c=7yO5-r&!A8QZ8IUTN+B6vQL{xy?AcvL&arhq}GRN399DwsG$i;CGw zKKeGQFooYFOU{sY_|qI8C~t_DK-~a&o`SU<9h{DBv=+u68Ld|_Rd}V_WfMSo$mA zio)Rc50cZWm4oS1m}ojN!av?m(xv^j47h#uD+P}$f&uUdS~*TjZX=F@r6OX~@FWsf z>g%v{`vwdM>d$0$o6)jz{UA>%^a>nrOtPOFM9x3McV89A5#+UG!u+%T>1VQ^cJ_e< zcwQ>aI+#A);~_w--L%{YhH0QO34y*sZhQ^?sD}PiK1n}mAmllZhl2M<&W|Abrv|Ia z?>yjNmPPN2#VEeNQ04U9!3-Eb2J+z|2#Ag9XdKC#$_)sez*!DBe7sjr!nk4yK#;l{ zJXS~yfxN)39dN$Y@tE!K9^Y$B@*DFN$xS5%Zz|mm9M-H1I-W7u9u%0Sw@RcLYWlBq zFGrRYPGsu(zM_i#)*Co|FGWZ8m z;Wd5U>ajSGFJGe4rL5?HK(-`R@4M$xi-5C+*7DMCK4}Eae0h(+#MlVPgUQDM-_N^D zGEwl`5)gfR@;-;Wb13zTkC!e6O8$T$zu_q0&3}>$M%KML;agmZSpCX!3A^UA^~Jy7 z2O$MFX-O}JoNo1^>9=8+|}Fx%#)|zj&x+E?xO%NFoDi` zM3*G}1>J0WQ1pVFxND`qE@5}e$7c>FzuD#CqM{%V3yT1}{?=zR%-O7_3L`pyMNs#+ ze0ZPkVZ7){%AIyV4i9*QRBu@r^cqpO^D8+K$F_!9&i`NMJGtKFF7V9w#(lBA7Xx_@ zeK6qoYLbYEGc8(V=<9xQID=8zM^k*eBk3$!s=1sPFTndcU*%aXSkRJ&Wg2Dq``MCR zj^;bK*A)UWU&fY*o*ixW#6e!mgAsVW==WQ6MjT$|VXyR~uqqCA zCZ?huQ_u^AP%w}bsE3J{c-t>F08j3mi$vmetT-1R!}M3t-xV~{f(jz5xR-m`$Cts# zSAh}fkoPP?fd}XhFdIe5*ozocl9AMS1+&qw^k8d}=h|Ptu`Pz)*FgL}-c1?$O$_-d zEGPa__0kMQnOfVeGBfc+wovM~%?0~B$g5=OrUN`FIHO#~GSuhd_p z>XE$FHP8X#!BA^s^D&$*a7@X2wky&jjL+22;f( ziW6ola&Bg|a?29P!%Z|30P=Av?qqnxh`TwEm?n=3jPS>Cpg*P9|S4@=d`;AGj<^}c#`+}l3tvZvqW6@b!SSRkj zdG}GKvfs;-u`kJQuzmG>qG}*ds}TCW*$~liaf5bPO9Om6j0aZk-g7-G3p1I~8_C2(|c&UN=jm_q;bkQ0S^^jK+{{kHU-StP9a!9yX z#KJvMeU<%mbHh#lW9GOkfgA+^9^e(mSfP~)z3xnGwcYYLal0lM)QHtXi9J%l#tHi7 z9QvNB0rGlgjlkzyfpf^h%fxispJ8ozd(wx(7nO#jc`B#Y=4R!@fLDN^wPNhu!ehzu z<1W6Akk2BthdU(pm+?_gWWZniZ#OCbyrAOupqCu$Ly;v!5LR!v-8-qvAtZ~PoHwv;cK!F-Fw)GBas){6Ex#gs-V+L)OGp34JyT)O<; z=zYWn{$>kJngZbM-iFqNy0t_EAHOiWOqlB&C!`+M=pgX=@w@N4hvj5jU^A2tB|8TE z9)RPRaqiK(=3f2iSxv8E|A2VH?LQ1i0MtjwKMk zJ_>8v#O!V?hdLSk`P>0{U${oV_1N8~f3KiQOYQ~xbUdNa%?HP8 zpWSoQ7+2#2-adXTTDm(4zLgx;$SP(r{Qlf_rcNBC(60yb%BFh2{(0Q)39=|9Z?lvx zvwZ%=FB=8d?3eU}6<3Zp%i#0P;=Ha=5m6#Fi(?|jd*EA^W@qC(kK2+(b^TM_A~=O5 z+kVK?)0_sMACoym?4GR2@RZUE^RNDjwqL`vRwUx@vky7TD+BfSn=ELBkg~3io1pd$ z^92%$Roaf@m(9JAJD=8oW82~d;t|NRGiCw5r&TYh@AVz~?%AL%v&x^fiLd235;ni` zdOHGywqn5cxc2?sUz>+*c>T}ot6!|Nw}c16JwcEa1p+<#tRnmsuGwV$g~ zxn*_9kisqX)$?^oblw+y(-R&aoAbx`0`Rs^m*9p^a5!*+40!*#r+PiPsG44;+3)5f zis15}|DMD&0p)`ai3tb#zdN>}QC));6kTuE$ekTgH{3|in0o8SIT~n6ud&j@Ev`O&!84 z856d=qh~eJxU1Xb3*^heO`vkV(93_Nf3YD&_^>6Uoe|2bEQr0`@&@jiRj0$){6CKZ z862OY2edZ8^h>h6$iPm-y+lOu^<0psEX$=g&)@~$7uv$SRB8UmxRZS%=!*ek=k~Vm zxj6^?o!_QY&ESGAclhcez7#ZY__C zAmY0WdFk-D;QTj4@44Phj=th9vuSCU&ScSaf)k<37$?^*B{~M+2`BPzp>oq(GuD-V ze)ZYU?U_?da5AjrwN9=OB29)h`J=YvKb=15cn)Ejy4>q_79KXC3 zRQz^%j(fPL7e5=Cs5{89L3mV->cPU&?K$#+^1j#B z#`OaV%Z&l?ko`XoPM#6$uXI(z@B@(^*%_r=U=+sK4fv?9D^Im#rwpmCRRB-kdh_PU za+$T}Ji6$Mcx|SA4Z|tfSkooGRfDlh*5%^UZ75$!W;1xdWwoJ;!02ap1~xGvnvfR# z|M*;nhlllh>*Ddy3V5NL+AZmMTGQGWX?^M(XdSb#?E{=FdTi`8dGf?Zd_3kmkZ11{ z1J3tTpQjaypzxi+>>~C4{ypJSg}-L=Y3M~xg}Rp};Ju|Wy(2GaHGe5w-d5~kewu%4 zN%po@LR_c6ek9b_DravW@`~BsgYR>mNB$P3(`gz@tdSB4B)XPYE9wdhF?s8=wBGv$ z@Yo$676c0N%2rcfb_S>tXI%c;=UJisarsLRwz*-rKpesyp{QTmPP^G2;_KjHdmfA9~%5|RJu2mwd^=#=bH~* zvrMOu2j_504_q(b9&bbOWIEzJ*R`FNkZ6$DzVQ~txrcYV>P0^Ryn5-KQP`9Zzh{($ z@#hm>N_z=<+i7eF`{ZaLSO63`|1St2`?cU;50~RHD&#k-U z7F*8kLYdNMnK0Dg{s)yHDOi6wK0Cw~fS zs5>Djq}FvWC)U?3^Cvi8U0HJ_B{XVIJNPDq5dYzKP;|PDIC%;3M#(72{U~QWtPVWn ziCemX=lPe;X2juqt|-&h_A}}@Xu-4Q_t{=ZD|nF zv>mIqcK>-5OcY=~Od&sst6&i%y7{&Wst*&oCMJZjyz*ZqP3xF2xFm{)ZAEmM;JC3a*dEBUsvqaWQ#h40JmGyIYT!Z${SXpq-B*$w8i zp7-8&=be>zWG!gNJ@e2@&xn}`(#uNP2?CQQJLBfBF29DRbo)hlLZg1@V*ySAV&82^r z@;37_a2DByeyAnpMZLoI6&2(mJfr3S%8Pv#&%^P-Dkg0u&;objXR_4x!kWYniJncG z2XKGi=5rT$je%J%kyOy8R?1z_ z{iH2MYo(@fmm7WJraqG>c6tftO(#&^T|-v(&Uu);8^fy4ud`Q2{;qcXlH#wHwAuLW zz&%`*T)_f)n*^-S0B;4ks$I*w$W?Xzr{iY1e9ld)^5*mPj=Pq>X<$CDua7eq1GE$)#s&xY;@yIBduq>iBBf5xn{=%Lm zU3zr=wJ{_YTt9g1VR%-i6{-B8HRS2*TYmvQEY14(&H8flEN%glqs#ujf8MMn8`!>S zetz3wFXKcO_&yzPQ%GF+7m+Qj2H11S-NHTs<)y~D5-Va=YN(i}oT>6JH0PFzPW^LT z<7gFwDJJLMaj4D#4t8L*C-Da!fHqziLCaX`zn2e@dXDYZdJ-gt!#&$VTs2 zhv-(smj`V6kJoq64{WSyn~SS;qXfMIjT~i_EBPVsxk5e(P+klOws*!P**ePV#u<~SoytkPLZ zaxRB>*Hk23Zh)vwcO-pJ(Gf@qc%Ex73Fb2ZvUiD*VXx{4=#rEd z{FRmNZRi^>E(Z_CX+4u%v*cicRK%ft-!MAC_MMEgz}#&}GFcnJAsQ%k$wOa4s^3is zb?}x6i3IYA?qT)S1+OF0e}dBp4&`qV{^Qb+aED3oCA(sz8d2?>? zy2Kx#fD3>$`L0zSbvQ#c;3Yk z7tf<*au2?)u2Bi-5$+*;^{l1qB&JZ9NQyd20rDQ0K7-?pNS8tB_o}S;MM)?}o5Y-> z4uurNVMl^P-K3%5{Cw$c{3c>!Ex|0;>eN54rD2hfOd;;>AVO{fmJDp#C!0J2tZPF6B~~dLCK|Oz!#7 z`S0p&_|eUi(ARY7DXL;MA&+y;5*$Bk-edXYg{U;{yr(}1(fNVL_Dui*(KlMW&Tugw z@Z{g1(hZ=I8t1>8VBM%L$AX_;ZS`7EiG>~J?RvoZM&YIdc@*=;;QW_m>CaE^H`NpD z_{Yo(b89RSdpI{C4p^$w`fK3x$UN@$?{KVKcGY{%F3BMfQAvq7nxOA@%55F-0q3i*gr@mlRx&4RF7|Wc04|r3)jb zfol!s<<`xYf9cs|--7uDl_i7kSC}5;!H2z<0_rb&keBs=;mH5M!aJDoCu3%!L1rI1 z_Y0LV<9!35yh{ykQqt$Q2Dqix)D2nlggPLYO_Yx)d_J#n8w{4ZmS=Eee64(z!_WnIwyxq;0b5)~e)-v7G4Zu7?!S9{n=>ZK zfggH&x{ZfhscZvz#FkFr_;1q-_xP90$~F0g9SfNdZQ2HXZj)YT0+vg%0yy7~+Ck6` z!6}oWD`bQn^0O?@=t)1aP^Z+*+%}bNP4djQ{pax$xq|bVKdmah${cx%GRzxCe{L<6 zjp^~!D(od!6(%|U0Qr6$@5x=io66(=b$B!r=Y571!KP9yM)vOPncv59oh*bzTPUCD zLJ-&y3+{XYub>M0xvw>l-#a?`3Jl_9tZoHctB!J&JjP z|GbMzDg5p8pbh`ryJ=?gpGVyG8|+`;v;4*T2%ON15gF~qUPP|C8EY+yr`8f_VON0n zM~)*-1Pg(Br@m8_Pe{fWMx8Mu&b2vCjU=*LW#p~lqFFmAA7YKXIM5!WuwFM&w|U$L zjxSNUM`+x3#bG-s*Yzc?5|@L4@}9#X?1Y(l#4JANC_tB48xwg59ol=aw?y~jvZH2( z|Lp4odHh^&!1>#(U%L;(6qlEm*c(1EPxZifsht78jVQr67A~;B zm!Iilx8Qlb_pRdJs|vS{?_XS4S7T1BiT)L@U)M6QC>_AP@UJ9FXsZ)NSj&wH#_ZPS-6Jmt4h3Mh8_#aw#Wb5n} za@z-p?Yqi|a7&B^Gtr_VAkU@F4jezv_nR}phmf-$BNy)wS!!%7Upzytvq$GV#zkEQ z%3Ixqwt}cS|MeNtPMHaT*}+P#;g4#W1n=rS&AFINoLG+-$iqca1^3ISp9{@jd_y6h zO&-w?>R;V~S!HRWFo=KBADG+&cml6#QNPQGCY7=k+*M6|jb@R?0}Da zBCMAHc}SR%XF&UE;7Z;zmy>yAe%@dfHy2>_4BgFk8WiFiDyBjKy!ly+_9!vGdKG^) z`t}Tjm~xs5$@^1WE#j!_XAQN{XhmNk?|}>x>|eUeI1BxV%-X5wE{A{7^tbeFqQr&0 z9j`q!9Bl%;iuB&9P_C)ZJ{a&+P02P&=R3~g2m0TmER{1|)%<^Yn`b~Cfx;hJAfJ&1 zr03-}opYmm6F9-uZRd2exnR0MhWhKHYkeEhq5D7|nILsQ>U-!@c9 zEhqT3{^guIt#{s+kO0a{5{yC_ouq7+=v4i!Ka)_52o8aVD?bRH^$16M);&l;h% zU?po5okS^kBhkDH$#J)?g1oziU^*b5zU3cNu^?8W_L<5ZWbq7@6+Yse!!V<x=)E&iYCXqms%I-2mjEc4pEHhDSJ12?>k#0%K^SsQ{dFY%bZX2_d?69d0jPv(}< z$Q-8=d`V6eK$Uc=N?x96vMYw8)jt!I0eC3B^&`)7&l;qsr&X zWEzAA3BCVc7=S#4s(0Z2e!Z{Y-ySO%trjP>IGz2}m%s9rv}F1i(3-SbM*wfLER?3n zZWoi6Lp8Po!!h=!b6Wb&b{O)AXwStSXB|aUKjc|=ih%oh7N*$@G6)<=2^6g8amEOe zf8TlCu&=xx*5jXu0KEMI8xu>@SkF%;dqQWm2y0(4TvYiV(DK`nG3Tff!pqqwAP=Sw zO95z)7$thaGUn;U)RJbh*BOl`9&m=cJn}BsgTJ!D???Rq1Dn4M3yxHMoLIs9IV5Y0 zOBn;kEKSi)hGs#?#m}|;rXg>qm;pThhjO73%ojj#C-`J*sd2+~MJyF1LxUOhmA-H6 zERZkK%k{op=$FYywSzaFKW-`cX<*_1A3StZvh(%odZ1&X&p=+$g(Wy2Z1WhS~oU@}7If{Q&Au?(vg`wZzhk_(7}-u^sgRG3HIhR=_bIG|$#OG4mQ5hxi z>>cxvO3dR)X0gsq$V=SS1?L|rhvV#mQ}6WhXa4YaK77kAJizZbIlDi%xnwT^yro6# zd-sQ$1(i~FwFHa@_sB`w!c)TLC+`K{-8qI|3Qg}o9vQhOSbvdHO0@BBC@^pB$U8~o zGdz}FZ>qqqXd*|=Pl3<3b6O$LC@AadA-P zNiK;S)|~U38ic~Nn(i=lF`+2a8Ugjk{!J3?0I<~zO zzuR<4?i}*)XLf{v>*WQ!3hPJgvTs{?Rp+#*w-LG|JL%$aJ~FgVt3m+}-XXc1WS--d zPAw}pT$uPKU3&CA48lVgDhC0UI)T5b^abSYEzE-FeZI-8;MzDFH9C^`pfRdg|1?<_ z6R40t#N#k?PzOBXRr{v{&+T8oyimV=lCwv!D{Qf1+DJ1Pl+Ziu4HMB^@XyPaY6Y*q zCw=s&(}Ec*drw0~G>UKkXjy4}ABA~1B>M0kY!CP&s_e5WF5yoGDqqB0xjxt=T`k`X z6*DwlFuN1NL-`PSB*FePYzc8OP$@&?r$qjzcjR_mQgAJ32|edynM$NTfP4vG zwicbU#k7JsPMyE+(A#_6MB9wN9y(-=FM6<-f-91EfV{^e63}xvM8p_SDmLGDD(SH# z78UfPqFlTT@5HW#RRs5=?CeO6a!aW5^@yoBkSYC-hlw+gzWy`~Gkj7dda4iq)%WpV zdzjgR<%Nqstn^ddNfMr#X((l{V_hvt95570LJ%@9ZUFKXlSd1P`C$_K0dQEM_;BDUOvQ*+|#4EOza zV*KEF?`|Jk;SL3y#h)cC)pPS$X8qq;6<*Q33+fC{`)lYS=@`L>2MAi7D&7YOn_P^I&-_>T^|u8z_T{ao)2Q1&lWepfS7E@n(#| z^GJoiI9>ba{n@qy=Wp^S-2?C**Jt$%+)wba^y9@~t`gav@|(v1D&T~l&< zndiN7-!b@kg3=n%u!pNstrp$^73N{k;u##2ug^detUndZ90AWMFBQYv6^Zx$^0Uqv zzgMp8JOuwP9u@=MVTjvL*Mr=vht1wlFBA1+%1?_kEk@~Jnw-H<%8Sg1;1xxBevAR?_xh+-T8BGNIgwmxjiPYK{a`JUPv*ESVk@eqQu3)4W3mwt|y8-yVu6WdmP^LVl1eJrew@nC##!$THP7ZCp@V>CNao|WUx;NIp zd^Ou4K!0GVk-#6zoi;t}H+;y<%ugTUbf*&fiCJ9zmu-(`41bTjF{ld zJyD>%C00#enwu`#f-C5Xqq7t%7S`h;}IQ8jbnI_=dhd#_J5Vs#mx^){#3A3S7qc1#DEg4w(?s=@uOSaU?df$n>H1nL7$O|nhhCnuQq21!^+FGvh; zm&Uhr7YQIQrv4i^p2SdhVvMFwmg1d9QAHzx^@tQ?2@L9Apr6src5HaNa{73`tH;xhaPAoJYN|ns4+h67RlFbji z-|OE*X)1i0Z3TF_`wg@L5;LR;rBq=8%*I3~T^T{UQb$8r7xP7@%P&b%UqBu*ram7~ ze{-iJncFJ@Ypah^tVO)r9bec3qYvz#uQp;7IT>w$(Sv`fXW{xSNS}}ezpCGt67mElg~9%Q=P&;aT9nlsO#PQt zEBM&8M`B8WMH~jhbJyx6AfH)z-K)h2W>cR?mb!?3ECW6o z$b(BAPyx!Twd5CiN*v@^Tk<0Kt#1VBoDgjc!GNw5Y~>Yr-eN3i>`A)*X`9 zKfztXSgv!T69?q0=?p0R(s?P&+aLBJKSq+`rVd{VC%x(MBD+lB?le`1( zw8he0=8v?n%wKS>oS2$|7&tvne9Bx6q<__c^=Eky zC3E1q=-un~;-M$-3!>5T-QhR5-*G~zE17_|ysmRcuP;8gYu?)LIP z`H&_v!13hx=sukPUuU-Bth^!2r#Fd$$`sRPd{4zY<4t}6o-1d<{P-S$SY}(=*IzN} zEm_O?%e$53ob8FVH5n8K+6TOlH?UC;6zrE~}(J1CaXnF;CrlwBd^E{1IG(eHm zAEhrjW%{PE^rnaGBBYltq`c?ljSt|B<@xFIuTa1oBR0sK4yqe+`0@y}%><#z1!mia zbUs%n6oR~i#%r*=v=6O!ID!RL?Z{%rq)+W6aE4Ku^)c5m8qANte72Ix)bpr0WPc-% z;(rzmXeUV;Z&Tdzr#kvjyM&Ng^1i_{g6oVDxW2VQPF zMRHu3%bksRFNr`N4L=3A{*pN29c&Xv?47j}R{GJ!UrT*+mlRzfZ;@=6GO?PvLm00>{wQ zj$x>iwneq_&4+&R2l##ky$Whr=OKFp@_gYNDI%gen4vM7H|0W}@9%!YR?8s%PLzba zp!{&Kyz1g=G4qbv1izcxldFqI9|U9)uuMnoHg^`*!Sk5r3Aw*xY>aNJ2xg|IkKIbO zy_%BWEGfJ#M8DcV7}qKq`RBn|(|!did>c=pYxPX<$=lu&W_o%{o$l4t6H3NvkxXr& zY@odEbh;JhX9Ku;$S+gN&vyDpr~{*{(%J75GThGu{r7SD2zI4{O%pMK^u|*CXI?`Ok;Sw=mpN zjF_{JQCzM#p8pv(!UAZI(^RU0hf3dOLIz>#g|-I~KB2D}f_~A>wo@Ga2$fh~DDNPT zXgA^!Xpdh%jN=)~bxAgcT29VId`ak$e+Thw(qfS3b4UZ;6&&fLZ*H-Lniq>OLwzco z-;Xuxz{$~`(&ch0ju75ttPhX}TXh1SAD18aPUT#tV63@V+xHlvp_-ex?x?Q7*J|f& z@g49iJii{Y+m$#LZVL4ycd^NqnVBMQfh^dV0kep1iUem`~GNQ_CR%~@|;C$hJr z?OCB~3VBpT>)`z+lHVDTSQu&Iwq4oxM77a^;zGdW&5J3aJT)9TARls~-8Dznu~&=9 zeTf2tJO4_q!!fs0eO+HNbBNSqt&O<_g% zD`<$!<3Ke5JhojleRoFp)jT|;&aT^$=@Uljf|PWOr!A2%Q9eQY#X44y*RG5LUN03G z<`S?Dq3OY$IIj&N!UuazV;i}AY!X{F<5~a@zU;mG);dGy3{y{ZI zGoefFnbRLSD0Yz7sZMDgA0=l&ns|Yso|5r^CquZZuRSV>H&EF|C-ao zs%76-*qjp0Ryv1xb@tje3SXfyn(+4S4)N=&c}K{D=?oeKu9tYMY|XP*nI^i3v2J8- zFBy}4&zp)YM(L?;ch&$;d{)h-`;lzvmy^FG`HoZ%rYgg%bzZrapo{Eg+DmzkA}7dO z)Pcs6Hd4!n3K(V7@y1P8iq9VqMX~Kf=Vi5Imp#+K^_&lfY-D?S{zFPejuva0sT9~e zTScqa$1J?XIQlr58VklBA&-Pi@B+x!?R>;igomptjjB|(?L{Z|T4O+Umnn5=jj#q> zzd9=){VZ5&SJy7{{|@dZy*}dmOQN;>M;ozhE1485hgh%AkmvC34LD!;n8Wnp18GN~ zwp_!jgFhx;M3)&Kt2~M~cz1Dkfbx=%S~8TBd9T4Ce3D3OZt;hSO}Qe;d~Mm|hBF@JYeI%-$I^UHrLykrE;QwVhj8;oPKpq%f)Ot{!zm=tGn{ zXF)=FPwN10SbXe5R&AaZzu%^;xmuG4ommV&-DdX3w}C_33nX}9X+DsLe8O-D)L&^n zg_!=|@6w26r|{QV2_N!%3VoN#BSqO?v4H*GSkiOXel6u!mUn-Rju6Udk$LdZI9Qm6 zzrSHZVuzs>5%h(;K15`2{GvMhYb)5v*Gf-K{`sd-_x->~GRGci#4}rz$d5oiM^>bD z)9iM&qx37vzy6h5?)8*f-)6pC8}CmEs698NeeVZ(+i54@{rj-PJgm+?eLs!J}VfF+vab>c=vbO7E$``>`QS5@(O z;QOX$<(8Y1o$9@X`3#}*6^2=f#Ir=gquoJ8`Q1ObiQE*P1VdhFqb|6=(9u7VXZZLv z%F)$XlX;7n=50#JuERNz*EpLW5s(kdrT+Ds2S@eu+k(5?T-NQ6MXku5C$$&LE1m)$ zRh*bSLLe`@VGyjpH0Qn|m1Aoaeha23VFuL2u@-Dr=A&^ZqAP9*z_VOt_cQ$SK+P~L zxnIZnz2aManYQu=6d3J(F5^@3T92Ga$ir1n1N-N1x>tvBN6T_vZ*gf*>m2Hh%i7)} z>rxSg5l(Xw@T^uPT+YPTfAl{y5qrN{H&b(-+;PZ) z-Ce|9#I^ZF!)PEE^41(bg70t5zSt;1wV!h2R&R7DL4_}|>Us6K!q*mCRaYPE@15@6 zn~+%Ir}%JmL=Wh{_RRkOk6?%2%~CR67v!rC1$CrUKweG}3j>f(pJ{$aG3ZF0Y1#;8 zsOtrhLHnCxX3FqnW357Py`3}PL`qYgTGQE$`?HTAHktcwNN8%YEZ#wda2bhba?d~| zhV`C5VuTqDLlFL`q|S~X zWfTIQ-W$0tqaq9Vq>8tJ6<&tab9$ByBd0fThW=0K;F(E%;j5v1hyexQ{eeXJ$H>>+Sxv72uQ4rf$I@9p<+Hm= z9J+%BX`&9`*(S!-7c^gJ7a&qU)Z?tmCVylE6jL)!E*v$yimhkiPxgjNTCaU)unNA_@{6*OzNv; z;z=bMs+GR0*?-=roWJ0BP46{(n#Vf?^(FeRyWeFlg@q>-gKO>+vA3;jJxJ5bm@J2uwypueEl|GZi=W{0sFE(DGavUkrU^`g|2g~Y z4zKfT8dbrEhUuW=pMY2QI&7w-iUWo4^Vi=V&!S5l{+Q(}A!fYwLw6IiQTAZr=zzRW zH#%VZG9qHEWNpSb>yD3zD}LvdpNwOB)h?L){k>5jxSlB3G7#{db<@cFCV|N>Y2*LD z?+Pl6O|nT9|9S{IYYuY==z=^Vwa6bp{m~8O;C=sPWhPS;jPHeOhZ9>W^!(%59o_Da zzGpx_yYWuyziFfw=U?7W!?@gQd>!zxT2e}a>zPqhR-P!!)arpeIOz~gz`GtJTnIcH zN93rKPr*Za#)kf0(P^y#E8*=0A-KNQGLE@WsmAynZWd-yGV;b!Lq7t;)813F{>1l~ zoc}?=ZW!`h?1aJl*D?_GhjcM+LAbhv;<-qA7hM;V1%mXS@9l4I4}g4cPt!jmpv>Ot z@LlmRyDY#Eq89ZuNIo;*pdoP{`fJYgA;m2*Sf{P@d^v&9V{PN^El6XTy22DuoZ^*;c)&S4% zmdg{vdn;<9hmY=-s|+xP-(EGs&&D1V)~VE@0^ayZb*-_5IF5^2h1L$N>-bGThMW?-!1D1G*xjvZIOPy>g{>SX)hC9iYH zgV_nzvom-PLFc1T)Xn6te%aLrRb%jZQ7t`?65948} za4RiygVV~0PS55JLv7>r*lWl$p3DHh7f$mrPO~N2yL>b9TV3;;iR9(OJQr%g+l__3 z-{5`<#na-kj4x<|LFSQ(?F)a%*JXm)T2$9@kpGOg^3ng+J->rI_-X>Mee-6Q#c@e^ zgLgOyhi+>T-%Cfm8^@p9wbkIg1J|EdW#@8}|9YbDg^J-{J(?xSG+y70@qUu3d2(GI z=*YkB1w#w&&j=LggYzS9R;e!}l{9_r)2OO$?P4zBVjuFExz7E9iH5-O8U^{TSXE0% zK*(zk{*20`>uqy_^~j~V-akmo%R`w@%cA~yZd*#=e##y8%9niYoLq8ey%0L)JEPVM zZ08y)xWUD~L$E!#Qw(f1U_NW*3P{cHS1S=&2GMZu@xnH){#k`V-DC|?eG26xbD;yz zzvx~-S;N_RpvZvpl30R@V-jyyJ`Nq<& zp0AXv*A&6ke}=CY=R}1(xZE~yKOiu?SHsL-F$&9ml1IJ6+^OBEuSqhmKhOTj%_qQ9 zdchv>*9*HGHPsbovf|FMo4w`bWUwuvlj(>x%Ln&~uUL?W%v-n)TrVWtqn3Pld#Yct zW-5ac_>^WdXtcB43F44GZG!8a`R{U9ExM^bZZZCU>J;^v)4jg|*)P7j_uuE82uk7& z!XEy4*q+$n`i8xd5#POFjtX%hb>(UaA{_XW&Kf z7>DP>FkPi``O5W^77jb zHX$fT$d_hH3-@-~+aZeE^x@>pKWt36Z37;u8xke9AnFdi%2^>ZkCcL0EVnH#gPFzR zX-Feuo>@LTF_e#3$POH@&7qDzjl5A36b!}VP*QtpkDskv4Ks{mqmL{C?oTtK8_B;C zXiHixvvgS-iJUm9O|7(RuV_LzLkr1ef*b86gS-hv32^psM${af|2oIvslEIeQrcGFUuTU!&?M*;P)ii~QcOodG9pV$Re0;4N50ts zUe6sOnWoeVJ`Gww>UTsUZ>YObxzv_RE<4|;bOO}@v-_15tJ#XtC2T^LLyaR-d9C`T z8Sy!1_I;h1)9$lie?J;1AMI~0u>Mr^{46z?11NR*D(FWe8GUy5tyyYP@uh|KyTJ8` z_wMR#A6pSQshHDFmkXSXJ9s|t)qknUbs%J8cchY_prM7l`BpD*K2sP_L$QhPpq{c5 z5`fN1Qc9J1-4x6UdyrfmMvkgoX|6&XT{ZnOlj2Ghf5PEFOo0~-z5!(XBtX0t`}SA zC|}1J+$BT&)3kV!W3sFd$20U$J|fFSU!Z~xIeGOFpXMWkO4|KtsW20&jO1)3iqrEj z$#_-@cv+ZF2J{grSZJKJ|Ni~hYM4te)ZxIANKuQnU(-07P+Q0Vc?vO8P(I4QxwSL8 zZljHIG4bh0COl+T6C3Rg0l)T@2f(YnOWA&qpKH<8(kJfiMsm}^vDLRkJmNFS*RMma z5iDY7g*|f!YX~_Jdgb#m7Yz2@JKSfOIDH{^6-}9d;srW-GsLAljzg?v~xysNAXTirnzdJ zcZ3Z)EORJ;C$u#we}stLO^%#`z+CpYjv6;-D((?g6y#kL@ZnbX(6350ZM<7O-a?^CcS#`NZTWK-w2iY#VcQvPu*gpA)WmJ?GIu5K zuy7#gPQkuqCFg@YBQ`kDvt7$Y5o@+1{he#m<`K@!GsA?+oM>90ZQeta26zNsiQ62L zqZAZl&xC}L#L(Bq?G9hbj~FOZXq-188XR`|C^SYzy#DpWQ^wNXSE-YeZ%#2IJV%!M0PlHkYR>tw4bf!~!o(=X)ki8@ z8z*-KzIr_kx`K?N=T47`|MJz-P6OV!<=%08*xwM+U!(`3IK>TU@p&Yic>j$KyQJol-ft0=8FO{WXDE*Btsz-UY6g{L#_%?*FAo#>PmLBRN@_h;{Tzb=yB2LhrE) zNOPqBumN7!iQB5rj}cxb<)Ys4N&4EOOPumS^;4J!zJ<7VXkAy$|GdT}?wh&|C z^p(%ZGE=E8l&_OL1>BE%12gsiZ@v=DyS{$DO$^&r2;ttHjoLnvIk zscm9L_Qz9E_h|Y2cKvM#d4zH&J;3#c9C9dJjM~$Mz}xhw`uv9Tryb_EO3g}32Y8us zz!P8GSo-x7m6>R+;^rWlkHiG&@jsUCGAfHE3HesCNDHU}j6f`Nr$DK&02N4&4}~(L3NLN8zrkLfTs7Sg$;@*1+|*kUC}MR=lG*LLFt!{FOanfVkEtGavU?7Hm^^|w$y#3BOl{!6zJ_hP;2egxL5Q6%0P zIS1c$zGnEdc2j@!4LE;sZ{X++@pxy7D*C-sokYT1w1B*ra(Vhee# zrmw*Mz_3;`<Aw?;%fm8<7_14?mj027TqPUt?{_FCLg441KBBE*#-@&L)ix zzBY27jL72oeY z-?1R3E94PJ>e&PN)F&efI-iZM7mJ{UkyekmL=u{}FNsYb%Sd|20qyNmh|fVH3P=}H z|`95mifSosf;teUX07H8E` zk;k_+%LL|(fG6cc{j`$C16L;E9V1!62VV0YBa)U7wXDpp-e+368Bq}*A&*VS1@z4M z-V%19brMSbbQe}Rl_w6>cY^V(UpL{wF#*Se%`x>ro&P^AiH{l^XFcv<^!Ob4qBQ(w zFmQ#{w`Gx2CCnZ2I{ntb{(bXmO{`(uHEsi`^O2oW#@>3j3w6e*1NJ z@M>%Kz%1&X3u0Tiwx|5o9a8;zi+am5=9!4~wSS(lP#!p5QB$mtA+WN(jlh^0G(r93 zrQYY5`UPRuTvEOZod1o4;t^QK*XIyOzoeKI=0Mw~=Em$|cv4}ghA7)&a8%6g3FX_e z7Xa&FdV)5JNjr)eG1y;@af*DU{rz^G2GfptQVH-2fP7+!4&tLi24_SSL9WVzDLUTb zO3C%!#dDZ$10LVTS00?bAn$s=9;|P?J>(rf&w3(|k9L_(7boejX6rHgI)S!q`Q0cu zKK~Y$P<<$j?EP~kksUGD2bk`3H-RN(iwxkk8Z~?sL7Wx^9s4ctc*?>lY5(@MluCH&kR*2rjq0 zDj6lgkoWhTOdRlP|HQXGO}%>5`LqH4j9N@8Z|_Ew)EFH)`>?BAETDOs3%>8yL)I?sLjW0lF@ zX0I1;jMQ#(>-L2~p5!M#uz!{7YcW##c%xc}Tvg1=&{dPHQ~4wm``b~dY{2uG*sR^y zqD~2Ijs;$u$J6q!ZEmYXFG=pFhny7_YzvW|+;GSvc=Ij@IDTlow9oqqKfj8Lvx^Y1 z8|^J|=HvFIUSeP9c?9q01`D~j-v@gSGvO0GnY+rY7;xTs9$x5HHPbV_85N^p-;IR4 z+^3D;^SSW;hd}x^g@hOBu>t*`Sl;}U#t?Wml*F`D{|galZ&uQF1l)ySoCa=A&iWva zlT$#vwpvp@ENT32TR-Z=2Eka!qfj*91oFjds|Qlo0v&8M7F_n(AX zK01A#=2I{_jVS!*QK!2D$4}=};6Tqi*tNMmTsH4vEI`kpx3MM8H6}z;3>=@Sv~l3A zlb`y0y*RUZ--qh+GO4KN#PC5)CW`!VG;zLq@1OU}D;OOAl=wu+vv90Fq-ycW6$l3? z{1~bD`$uugi%@A498Y6empElfEax+4%Ce9ytq`2jmnD1M(aI<($|@G3uNmfwpnL-r z&%xuTWzx)tgVjB>iXZZz7AS8)g^Dfp%~cSt$n5d}Xm5i+)>IsM$dx^Lq8-oiB9tkcZt?&jNU|rd<;e@BhTY zzpYsoyF92DIg5WSa?>mBcD+ssc<|*@W}ka*I=>bo8oYQ-s!rwb=`_5zHRtG?@!Y`v z#^p#OjR`{fh2iZ^@jP|p}t*NL`5qPIS+8g4x) zRy22>t0e=xKW=;L}w=Zlo2VNq9>mA_v+r1l( z4c*|X#k;?}VEg^s<{Qn{cx>tMhqO?q-F`SDoj%B$imwFsb43GN&3}o1`8iG9U zD=YAQXTA*F${mrm=O2fegZximZ%ue_j0eSAv(!~EuYi1Ck3{b3UVGVlo}&}-bAPX9 zS3Gi0WK6MI!dKl-R>n?Isj5~=cOHnS?r`SWcE!krdCD33GrMHTgMl1!Q{1urRv)Icl#@$5C-(NFs@Jah(bIr@e+|OOd&p(vkQg9UY|bMdD;>k zc!|C8a5DrvDQ04iHPY^oaVwFkd1mw-D-huaXWuBoK*Oo{($sWP-<*L4t5&gGPAI9FvFKhLw0QsVcmxyEz z^<0g=k_%<`v#iyasroz-eGu;Zsa8}UIkxw667p=+48is?{^(a!3N4Bzd5-_gXij42 zJMTl~*VL130@KMrz#EdCu(y~q{}u2ylY4}!m><5JS}qDkRs`8SW$qbDToKt6emvO=12T?X^o{Rp_&&p|y6JgpY>Hkk>o*72I#(ggi6GrBWC+ ze}1>m&D;~rN#evlRGT5+bm~I{cxt!?#yOoOTRNovxf6j657Z|z{wJ2yKR9((kuw!@ z%lWq;4-RSNIgsz2<%@Is;1$VslT{nILc~}-@pcjNwx{n2vR1kQk1e}kw}o7x<;x{Z zSqwu$c99236ct0s)c{6AwI-UM^oK*p%feK90(i5f8u`7#>;~0+R-e}~Tt&lM?OfQX zOcK9o*T(~1-ftWQ&FX~hq~0V(jJm{-3se-rptoT-sj$tVM4>PL{LvDG;nsl)+h#+(f5bI2=^y9Dbwx%pc(OhzIuB;4tTx5gzW zLyWHdc*tr!bTv%ic;#2&vMVRVA9z>J6lPj5s*`$X9kZnpQpq~OIwgjtjw$iaL(S)u z0FK|5@OL^9wb-jr^4@hb)MVcIQJuhrB3;$lW@m6ep|E7DyDOn9*ZPaG1A^nq--2)% zv5ihmGj7{FTko>p?o?eu`KVjd!Rw7KOqhR6&P0yz4SF{`!rf0=B zcH;f%LaKG41+Lg*>O4SgfPt_9X3_8G;!*sw4gSjv-0 zi2eQFM)WSPyspu9pA{#gQKBFXWVwSpO!!&Qi;1!GzH@Up2)@hN6+XH8(6C^Vx#{|% z+)$CC6lkwZmaUfQ%?wtz7iVeE?t4LWkqUc{;t1{&<>##UPHKJ&|2%`?cVK%<|N0BI ziq;7eWS+yGn*0qQ7#`QQru#BD{KN%ZpY~p)j^Qii&+?vI|9@H^`eO^VI5y&mTA=m% z^cUjq=n^pZP(E_$@e`nbO>K{iZbLfzw`n{oW7lS_@PD;qu|y9u^G{R?{rPH zT{`_ZKc3ScN-(LgpCq%5$TA06DNEpEOCTQBmHY|KmXUEIW zh_Ya@|9Oo6NAvfZYR9To9IZD(jWY)15#v!&1O3}+t=95x(2F~0`>Yr7u2g+4IJ}sM4BUOf(I*!C2?}sW5{CM9gcf$X+piB_pdm=4g$2CF(dD(mD8h}TL zA8jF@-KlK!^NrUIW8S&LK+H?xST%Kn-sp3{(+F2*)9ZbK4;PL|MUC=c7|rowfMIh3 zHHhU?W3emhqdhU?eV)q%>wnB^=@+lp2!oHmaMC1`KAJRqr<6i`?ZiXZP4oot4q+`7 z4ca$sh9$Z`ANA>7^D!hzG?bkncXJ9Pc#`X!aFG6Mud*z7|HxIgUlX))%MK_&=uvz` zl}qh#Fo>zSo5sn#2lrofp^lQ2`o8JIc90!JG2$4FgzI8-Z)IPo)|9+AKai*7B7-~( zhIVj&*dB}O8(ovjz630}p=crUoL89lPper}6`nJ5Sp)gX1~dLj(g>&ZJ7~=ypX{iN z&eO}k`&RWl0zOsVnZl!{0L~cOr>@r4Y?e!bN-^gIvS^(t~)O0+W^VRBe+ePZV2t~0MEs6$(s=^#(P$A}j27Z0NPo$ce?JmQ|$)r+VF>F^>>tQf%`W(Va$ z4Ss&6hrE7@UU2^M79)ON7n|n^N8Bu_l?OtnX_Vn}BYQvWq-Uw%@f(tMOegf~p70rz z8ID)>mEfGfd1(~MSlO@fMf58I!8h$EkZ1JS3mmVcw#DqHe>FY}I3qj6TB(zO30kQso_#0*IG)c!&%t__J&yEK zr7)k**JgNz;WLJQHr@!o)lltVP$G`|v)?06}l z@eJei{}t7#H)|m}TKqshJKlF_(X+@Bo%jbiT0?imVX2O9qV)-N$x_%3-I%k#ta3sg z8KQwC(7y%^@RV@zfj{iu{gL7#nyNR@h(W{2J7;0c)CI@;GEY1b??fl7Ed7XjBZJ+D>$oBB=#d_rA6PJrx{Ad2FcD=ob}bqOcIj?DDb)>1llG;J z0qb=%xqkS#;ka2R+f7y*QP>V^3a{~U-!>Z_yO8X=F@*4F@j%}002bK4{G~^njGKv_ zAr5;BQr|gFZVGgVeq*#u(C9XS`wwXRNnw0*;?@?-Z?z^F*zY z2nIbNY^-C(Ps_|mS+(m2fu%fqtyxu13CJtf^99G}>TE&Z_(6HnfJI|GRr{IKj!@B) zbZ^9U%T9?lz{BDoCE;7I>8ot!>uhXWI*{}Bfm^;7`{PHQ%UtmW^#t`9-C?la{>9b%$$cCxsND$e}T^mY8)vhK!!$M$UKV5;P$vmu6Nc>7VjJKccrE7JVw z$>^2;H#7yNvt!9Yp2m|=uzoNo^@+ps=>l1ez5M_)R*BhoSR%{xRuEy1-*7+RS^Twc z_?o%rmhzW@kg}1&ce6UkYxhnDCWJ z`L8W4NIfct{GGBhCzQeQnRzIV^UbTT(u_nnivcwjG1R@}kH}l|e0B6sk1NY~x~@$!ZCfKT;^F zs+8BpiQDJmOSG3vh4#uEx)zj=iky`l@cK5p3w9Uxv+tGM8ib1}P)vDs1INsRa5W}L z-~InH%$ya@#3h>yrO7+TYGK|Hs#C!jtQparStVQ9$kGh~hM8B8*N){$f^Mc1W^8*ODZEJl8nlLN=Ab>YJ2MRN2K90*e^M6_cpt@erAY_WxQO=7~& zEW(vAwnsJeONsHh$WBLsQvMdnjAxodo0yLnm1z+FU)$ zFP@#&#O2AxH~h_(N;+QWZ22coY5W21!)wSx%7;q_+AEMe$7ow!I&cwg72vTftglmT z&x6X(Xa6#fA6(zBf6rVT*8}H+M@yH5x>2-T-ds|snW%KmSlMPdM!#`3r3ZO!K2hNK z@_Zt^dNfeY#LP?9+mQ}AqpM&ckIkOw%bSD{CLkXyOQnrI3X9`_g+nV-WpsQWhVA&H zfSj@PZe;z04!^y_8_1g~s{qHpecAA^5xa*c;h!elB4gk8;CgPqPZYXxLzGRc13ctE z=1%59lSW%BeJCGa(!lcf5sQ5y354gkk8JJ9R9BfWfjnf+Q1JbawojV5!D|J$`wPtY z!LvoDjK$=f=*_Q~$I~Zy053(tyotUXS6$(bX2GZ0oPpq1ReQDT@A^pGYdck3?9OBh z$ipo&0r#{144!lgH6vG1yWUEikPyL?!}j&^NJ8bS`}PieKH@o3U8-OUm(b_l#PMUxE=>f6e87d53INqU#p_@SAspJhw}7a6e58SE*~u zWn9Z!L_gW#xigNfxQHv$5i5C1WkJpvr7UKhZDZEVGu`>xlt+X%uMF@8ziU(erF_ox zK6=|fN6&LxpRJuUqTw+rMQY1V-A@iDYLF4J&@JdeG|*t-b0zx^?U zfnG21pW7cGfa^zsh}t@Re`GM0eCwwh`P01q9*B^^$*0`95Gz#su!`dUbcMY7z#Ooi zh^9hYZD%p0|N5*M&lumy98nW7@2ixN8S~l+^!$OeJeu@=FG^LvxP^@OXWbcL0dbAz zQ~M)vdB*5T%pN5-$n%ce1FyG(s<`*$kN)}#a_{7CC>R=3xy6qyp50k)Ovr=#haLx7 zHyhdrADxM!pPVlx4~8Wh3_DvEkXZ&ZFs<2)cRGH6Jj7OUa6je>!(6OHm2xl6JgOtC z>RQFuR9!kG88|#j{xz`vqR7B>r-7`Ub>^ThO%nBHbX)*I%5EcukTh7j`pE=KAfpH5 zks#TE?Y&@AOA)EE{E||0&+E`L!Wz!vApA)KyT~tN3ap2D$)zypmuHi==Qz4V+rz|u zEGpe}ZDzcsS|`m}{X=*7(iighFXzGYrIndC-L%_OweD3|>| z+5Z2R3miY*(SXe|lhD-EWzrw|$$%&9eV>?!7R)0kbYZb8ar6)vgu{PSEOta@kX-ed z^T+z~KQB;j6s-R-2&>Em)RwDmnI+;S5Pu#T;JEl3hJdM;upk7sx8&FBJt-tV27*-_-Cx=11R3I*Zi8NZ9jsbe4cPz;P@i6huVMZu{Z8bE7yI>M9qgRW{4-B z<58aRwIB2X&ei9q9P)(|f~pzEN`GQYrwIn;oN;w1b-HuF+oI(VeTFHk zMT;IAs3$&KW2!oc0{1uhKKcKz%-=V|kJtvzmx@t_4o}UjlD)9OIb7XceRh}3Zk7aj zq(u$jewsv!{+JVZ?QGANhr1#d)eI_myj)=>SYc+#ddEOMULs^;e>ha^$g+{hDTlQq z-UhD(HdDS{j)gbce9+1yMf;ccuj_0Pv>DYkZ+PvY|Tuvc3#b@~YiAFAB z9+CdxKks3h3mgw57ld~koC=5|dT+=|X#6xt;7h#LZ9KyEI?7DI_F6n0J>!|f8r}0| zmQo35!iVO8GrLN10p;+joW;Qaf4 zQ@V(jg{9gwbuGB2HC9v|_p&Xh8fZkFhOY?d6zetXc_q zKjO~7@B3urBPuR$^kvTR*a^CODu4K)VJxLFgfT-tdsGj2M5`RajDo#uB1p1JWF`IY zO%PNT`O|DN)HU)cq`#8B)2V_yBJ1Da^MV4?fO{q4$*6ALb9f(T^3PoqdH4-JsVQg6%w^v8=An$lkw zwEtgjm#ioCU(U$cjK{M}>ZsCfri%vh@m#vNmTKcWB{GJTC=YH%$e%vKMLkPbPVX1% zmx~!h&Yli?FEA>IZF<*VlJkqZ_N-5Z1tS=`%V>^+ z4*mQ+hd`CL-k8=aJYBTIm`xQjWvL~+7RU?GodEYgb2@FfAl&3|$(t($VLv58v~qGd zO`AZ*+OBZ|&p({RjK4(A?+c%6{TQM#|Cr>ZLmo%?O^i(F#n<*`{l@E(f8I|cIPmzP z5qRU#l0@Qow|l_I%St>WcC|QOnO1@$zOV%M9~jApuZPxBVT3A0ny$y2ypa+kgGN!fnH`>@kz2r4n|N6T>J3AWvk zhprI<)?Y%pICKYP#!j=$RJ>r}IGxKTd(VDjHEql$5X=DHtX0EvYXphiYIv(5hF$_w zX=0?NBL0}d^*T$8!quI7{$9wF{`DQKZzxz^drx&M+U!b8BZo53Tp74t}!=f3{f&OC1aP6%&YNT*Wl53;m&Kjdu^NrBIoo{TL1=?s=1 zx~Kniyqz0s4&gy{6P^t``?;gD3FNy7BFH`L_*+-xuDOBDKZ9!+D5^6$9W^C!+{|*K zp0chv2zg(c*g=mYjNIgL>gv682RYp5$>`P3ncptx4!1|X=(|(_9-ezIx1i&MK0?S# zmtNL6H0yP54(Te5z;sGdI3BG{pOqoVLteB3_p@e7FW?M0vtFCbh%Q`&?(RKNM%= zIb~;Shx|rg>1tME|Ln4#Xp$7onpGoW@dNV3ts5yO{gFuWODn1xR@tvT&at?RT-lU2 zi2qiXAR#sJWDN3PC&}Ib*PE9D;r?Pe1Xb$o)^(pxQ?@mGKenGe5ihh5MiJ$er zz`GlZ_DP96pEt<{7T~QUsSD7@IZ12Az`eFlb$XYP+H&wX<#p*cq$9;RZz9b+4|$b# zsNnU6npIoH)E!tdruY9pWI8U9ea6;PEu#0@$St8I0lXnAnRV1myz8V1&vFc;ReCg{ z1U0(=J7(@vcz-<@>B#5>$Quh%1CQSW@lJrH$-B2K6W3_)hBMU0%r5s6s+xj*?c-~J zXI;4&Clj30*X7@wSUHZ>U1*XvqIl$yrU4uO-iJd|q5YqSqGi1Zv^S2|6SZvVDKCwB z8l#%tJ0FL&CrgpOG4Ui9qb-(?hLceFtWAd># zB?bMU{p(+g0oee%^smp^z9tt@|A9QjSKj?VzD=P}_SfQn4L;yRWw~Hpdj)@cj2OL% zLFS3}odCQNKE5w@oSTUs-#-3jAryac?ySPj3fDo%RK!D?E-3W#{SM?IH@hetW+_Xrv9w(mW*hN<jBgF1ZC&ZqGP|0)DY`}Ty~(30T;{<2 zv6PA0Kl@Uu{rwn|%z6YHZ{h3-JvCC_DR@;IGEzz$FRuUdMh+Ul`-e^AAP0|mL;UQK z%l`Gpre1tMtpSDK;}m5Y0)K&gGmI5x7{ag=A^&OX|A5iQGdj^{fyZUt|#|Nir$?vx7*41 zdJubjrO_g|dz;YAY>kGBox~-S$Lg^D&s*Dv-Y4l;G8@!SHnaSi?w1wY@YBC3Z414W zp{I}FdK`RTTs~}L+hk8~F^$AzAe>%YmU68@9IIEiVsrM8WmDpB3n?6wPqmpJ><_6) z&+ej7m-8#r%Ol*9S>$LuuPGfPSFw*j=D_iw(C1f`D&h&!ZmL;i$i(xvn|7{eccAl(c(3Hq4*f%;R+nTrlR^} z?^g`i)t2Ew^OAF~kHo()6T{PgzOjp=*U>^eH^+dy3K(}L;C!YWMi5?Qko8-vahTz{ z?T`3{dj!Lh9iWw0LnjY-`Ded6;eS+As63xu!d$;mkwaboefA>>P8rqFQc&_QNh}`Z zp=57>`@OYA3>0{$PvKf#HZh+nqB@Cn@68B3wKnP~i3i71oiNkStXHIxsjBgL9<*HF z{iXernl8@hJP19nmgpK^R}w;APi_)8A8!>*NEvnZZ}VFkCYLnX7W9-Phc!x%CdzyN zmJG;;c!J3q$vPax%j}%(B&4uSLN7`wGgm`Q?F)y$cJUXNlLGP#W4Bp>_OcjntGY?( zF!a%$SxY<-7;$bmUzSNsehAV}0{4S7!VMn2j@EQWHWVEp#7-;U8V@<53fvQqnVqHH zY5DGoO9^=dzpKIdIA+u9$&g*zzgbT%wlFiqddBV3#x}4EGSl~u?16mwBMSm9)>wU{ z8kNqHXscOK2Lrr6ar)-?yu@W0>xb$Dd@8*-&2a6xp9TN#y3?fkSOFzF^|l_F7QRKkutfICy;+ zMAIP(EBu!0Tf}!jeBC-uOSO8)(X0IxtNIPN{t-W6?qDgDio`z>H@0=>U(qc>Fh(HY zBi=9gTe|HapR1Y)%Eut|18ncTYY@|o)f#N8x?Qx&L~QPF%aObFI({1V_VXp6y?hRt ztDLCG#MOcGxVk3GzfoI6a@r?|`l?4i7FJL#su}V^UceoU5YS#4AF`6)Q5?Mat%45g zuOw(0pH9X;$>k$ea%lwTLt@Sg?CcMJzlGK`KhNvZ%B?r4u3GNmoQx>>)hDFV^3H(| z^3?7%!1D#|YLDV2HlM+O%An^<9QOKkkx@k@3-2r<13D=npWB>TmO=ldnNm-mfQl{Z zHLQ%rWM?A(W}|E8)hJm$oQeSCEm1?)?-M4=kV|jj#ARk$gaOX$cb3kWi^pY5!PXHKZQJG2g)Fzy%l2v%uahR zpK9PgTeLRhO3|;1o!McR6hLlUE2)_9HxLK`D|&&nPK4E*oF>DTVJ@0Uj%zV=M0Gedb!^ z!WTsj_a?gxDevH)&I|v)jMbA-1rHA=0p&wH#Fqy0T{9fL|C&)Gi~aO7(b{$v2Y&=@ zonueotkK$~7U03+U&L@!FZd9iHveUAoN67qV($iVx@ zle~q^m~A-H1a~R)<>gVr(7zLQTLv#t#(cMZ059r}$w+4`JW||iQE?MF+Hfo72#2iT z#PrtydXt##{r0*dZ#CsI zu#?oG#SL92zhiBTguwnCS@^^w8sLm$$y#|mraf<2(Z}c+(>)|lKmInn>q9Vt*FW!l zvlcl2JI1`$*XHt$RKsH0jBlXg`u|J9lYZPkUw2ErF9!0NJZrKc+{-imdV8ML`xLIb zvwn_}SmF!+IFkY6I5yV}+zTk*V`d##Ph_CxnN~GxnkFcX=kh?pURue-MMC(PF8_kV z@;%_?y!_qPDysYB$D>9bdS%>sc4~sowO)U4uAsWn1j+Jh_CGIScL=Hz31i(v`u~z=hG{UB7w{5kPc*u~o^#PAiL~}?EU639t z9ldx;4a&EX76m?k{5{>}d1_kPoF=_~r>_-B>RRH`Sk){RM08n}N%=jt{r=t=yd+-E`CHP`=$b=zE9w zcOkZ>fgU7CoGR`6hBJHSAFF<<%akI`uxzXYUfBm_YL@jsrEY74YPH0k9#Oy96GuN8 zJP6C~p8O&#)_Z&fdCin0VEr$V_S5IANYM@aCT8zL4#ay6#VlDPT*m{l9vUyeTc6*& z^wHx=`!0~GPFwB#%Swtd48hy#nZDfH=6mbG`UP#sTe2tv=l2w552joN{f;;B>k_m9 z>@TsG-~^}J$hTc?WwQXUXTc@=xLDaNh3T_*|E6VXTk=yb={c_&XSTx_Y|@S-KOM;9 zI4uUxzn8zdQHRo5(|M8UF%$fsmn5tO2Q~6o8GMs{Z3cL$cw`ClXertZ7x)p@f$;dwn?BUV4S#AsdPMjQnfu3YNftB8%w7fEsz++^N zJl}&wVh(v}p4Mc5Cmnb6`~W+!x%DuUr~O{ch^U%^%!G5fg)(v){JwIOb`6zj%$)=k z&iQIO5;pOGKisj`%cRQ5@EyG0 zYN0EoK9j1N48MNW+Nx%(WAIA}STmfzB2gulvG1XL`C*FS{_%z3!ix1bm=Ym7^74$~ z_dYuA`G^S8*~Vy0Nne3{@C?qEzc$iBynI*b!ZuDBvd(tcnqI|lG#H3TasNJY7IT0+ z-fu$S`J9|!{U|ebC+6A-16yFsvW4l*rHMKACQ`E`R~7IgwEN~p8od<%DqZQez8yYZ z_u365CUm(sF5GfHGx%Gy?+AIKjmOaZZ#MJ~+1rYaFWz5^#@Fk0#yn@mIM2O4suR^8 z0Nym!pvAY^q_kdMdP8jq0|{P{cHWNmla&CiONz7w86P(%$a`yM23{XAPfDJDt{5^T zO~;T66dm5yoO9+ffDgZ}dr2jU?)crrof*ZrgS_RechWY#U)2T9&UCx%ao$ zOI!AaJi_mqT)_E)e7XAK2yd|2jL2WQS9x9EnD=qE6lK>dB77StjC(+ zh_U=p%y>4J`3d9v0O$N>47uXlcNnB=%SEu>&O50B|H4ddl`YPS@pk7b@3d`94~wLi zB!m51C~8FM%&SnyV?dz+k6)H6U3BkSu=A%NK4Kz!Y`r>|5;QVZ8g1rm*&jfAm%oh{ zvu5Qym*PhGB_u+vaWGH+jpD|xx4-n_4JOmyUAAb*Q)!9-_uGE_wP{w@Nw}|VO74aH z>J)C+?(n6$bRb7kwTU9&!A0juHs;ORO@!_5n?BvLjq+4j9VksxC*KcreQt&?N1Xhx zy$J(FKz|fHiBR9-l%(P_pC^1i(#y4dkM;ioMz#Jtwp1wK8O=n|^|*Z>T5RbxZoDm2 zWxnDXOD?2vlUPSUxO^AZqWjPD#hnG`2T8O7(WMdk#WG!gWA);vOTF)tS%#mxgb8$(=)9+PHP>H2igo5LNN&0^og?y6eD=?)3e# zQY0vQ2*fhYTOJ zkpyZtn-xbJ$|5M=#IiPc{Nz=KpWFu$XUQM)JMK52&fA2FpXh~r3Q0<;2Mz}e(YK5Vze)F}hZ)iRlsbW6%kzcv`v2s;VEd?7MEp#r?ZSKE2bx^W#<_KkJ<=Bmgc zC06U-sh!IL>OCKGgrdAz${`P~822gAAk)aAU>uq0bk)qW#(R0Ur~W}@Q|Ucpx1pq5 z!hq+|LsYn=I+$#Mr~>@m-#HHRP$Ud;`aW5{H{rdrK1g ztlg6~CZyW1K}#;IV0WW@T!cwAz{@ex{#f0&5D8nxDCH34K+TdeW*$W+^(^Uf?+Z0<5~^zKgzE3AX^`3_uw`_1BV_Md;m^oZJcigRK7s=dGgq2G9$ z`dfv$5xfJCk8=ovf1wRNkfC`|g-_aM*yCjBxiw+4W7`Nj-gj2YN-r|DRLc(0Hfy zp2*&UZ-hea%<-RR`J@{h52|#9Pd!S1leA4*2G=cE47}XLH$=S?Az+%<1E06jmkO7# zqAo@k>FB%seVXeu0yeyvL}|Y~UOY8Lx(G48ZH4mTk(7bghen)jo6MDEi$0^+%JO{g zRxk#MahJ2slrEB7G>|WAT;I|6&gI}+nTBkAFx#O44oshJ)>w;c^+5wByH|W?8{~;G zJb}jN-cJ-ku<_RgNWXW8X`7Z+lp?vvUc?95R9@Hu-Wu1hm5BvrrbZ$p#=my-Tq`}u z654lfk|pgYh+I3UG6UKnkCN7fIAY90HiL;b@`g2CAguU~=d z$-N%v8^lYtk@@JRfe-m2`FgIVEW6m^9_jVBVPMmi4j|19HGrKRYvkn+eQOfd&*X$%>GGe%Hi>8pYE&bG`5R!f(=yCbWo zczNF?im!Jfl3`lDMCw5|w|1BCaTtQU=?GGAd=Vl;$V2C|V$ZBgTf$oOBEIX@O@>Qy zjE9{glm^`AB8*(`xoHzQOBW* zR^?BAOw2!T?Zqd^@@`H|V6umP!18}f1@|j6eS1MgWQx~4G-gFkt`)NyEWG~(E z4W4t-juv(DiE+q7a6|;(rxRu6WfLhn9qEKeA@Ox=KxeBf(b1wVYOTk0mH_gpNv5wd zP-b;!;Qk2fioq>m>`fp~rFE)O?aXj?NzUtX`~i8&EgN8aUqu(gF2>Lc>ErrKZcw$g z)PC7=-;1}p91Z#@33$nv{fLF6JO95VNq-}s`Ej_k}s9;t^CINvZml}hC~^!YPx zyW(2FSzFRqo?dpc)PvAqtOMTPqAaY8RXWH5L<^Y4@38G_`w=kk&uE@F>~6*KODWIB zDvZ zs`~NmbSk;sUYH5r!y!$(Mh6E8`!7Qt9C{k~e$*`z6>=j7L=HDGyoJ?EwGQOqkj!iPd!B5)!+lL(=x(a!Ij0|8s7QxFj zBRJ-rvkct>+1~$O6DF(Qoj+0urm9gK~^iO{I{D)RU@`rI%w_X{UEUH>}?X?li zK~I;8rRk5o)*$asJ0>_@^?GJx8hyCd&OBsJSrN7_T8#G&RP@5RVPHTR1iY29&omu= z3aTW=q*oi5Wv(#q7^5#<^lz@xbR)c9UnxIZhdg-FFE+sSYp9qjB=CNm9lpEzjpJ*H z@?#bqy-mrT`8=WwcEB6<=}cPE6Z=-oS4llfPdH{YW63Un8SqMvD5T;{E?8gX59GPU z?t}Lu!+fgUNYig}PC_LEm+kYC309i@ubDD(YzW&T08em8ApN5iaxu{ig|Areu%6GU zLgQX+{1U6p4nxV&)^ z@J55O^5H*Zlygk>9E6Ff{&Lzo+5AII8k;zR<6>kxZhM3>3ytLTbLpz-9LG~HoX^SS_j|@xxe9rZ~g%=%;uUhAW1x#ONy^UaVRg{7T z;le-fY;hJm|B~KQ)*|B}#^?SVq6>qC@Ae`kVnp*ftr4wQ0lzmQxo?h0D%8mB`|Gey zkj8PsLcILRV-BM9ZSH$DSHDl~UpAq9NEpTrK!5CA@w`(}cF@)Le=I+`%y-j7h5vcw z!xD^rrfvu13xCg95ofS{7!G3*7pY9b{ns~MJIf%-r5E9@^R%gJ$r@gPk` zhOUvUl@$5vmwUY0q~Z0Ly_M`o?qN9CCQZPLxvcIupiM(I!C7bZ!U$W%X75(r)czes zh8S{Hk?UAKw*z?#Q=Z`cO%zWxT7mRXap29jv(@{QnK>juhoMQ1u_N-RWWX!5RFM0w z=}lt+_sn(ub|Cml&bjvYjz4{1{Yxz|oHSC;UC1jzPX;~ClhB2bKg=InDZ4FU?F0g5 z<8nFra=4o)EErJ$?{zN1_w}C`h@W!}^W8!h_lmOoxG?p0V$B`un5<_A)iqBbFDY~s z+<%Inrs7g46-v|-suCU;arz6!#cAX$`pkf3UI09PA7{TRpP8y$sxxmVol2G8&%=nR zWGorhus&KI+6l=Ygdc|dz_5X}Q_QmkUw;-nFGGqAWSvoY7*$lZQF{{IgHEw7DX zNbevIB^qx7IA30K+0lzsccX<;IX77J!b=A~TK?54RoNE#cmX~Ss#ln+zd9WMdX$AF zZisz1#k1b^7EdymnC|l#W^C7|fhBkra6OMOHTMPJ8QBP05Dwrf1;4uw(#R6)m$Vn~ zCVYXpeZ|Hp4&>_yNtt>KUn<2)3MbT7xOu7CwR@h=uIBN&X_rPm^2GE50^~i5Vg>uR zTAEx-V-!BkzJo!xGl9WXC?AfyMSQC%?YI&N@S5aEG@*QHN1IC= zRl+2Ts$=2)KH`M}c}6V$;P--_k8!A~x)Hswmy}A!vV-^Lu3o6%;xR?@TlfstPoMcT zsjy|{29)PWkeF6u!G~B=!?WQG5PveWeNWKPLLr3;d7>fyU_G{^?}vNqY6MQUsu=E; zEmNo}Em4C@2S2u+Uu_GJ4~4u!{Gsj-J_nA?n-bL9>3VbWJLVme^0t?Q?wy+qrHg2g zhdCt%j?ZXv3iELqqc7djC$*{cCYzVd@ja#Yw-Zl&WZVF6$ERAXiZJqmBf;6|iW~L$ z3w(;H=T1phQ8wI5NrUfyl43xf0~{hao(f~Z9dO*8!7&nU&ApFVIH(J_rT7agj;u;; z1ny6ia=s}4L$6~9^MN*n_K8ukWY{_ba*z9)h?YQaFS_KP->@N%NR<2|(7$3$i*rPC zuLAB#Okdh8maGxxw7t-0jfVNbTWA5~`-@K_7$HY?fjOPgZNRZa|Eci&^@ySi!)k;6 zCZF9G%K#k6E4kSPk6*`oaX5Z~g3eW3?!M-d7VRq2rku;5DDovs4)FaHUL+Fc1B&&+ zWS-kMn{4g-MWKq0Pbt5`{^)i;sgcoi1-xV2h4m)ezMOk;<+jlMDX z^}b*~n0JF-4_uGWdz$^-@El{=5cQ}xz#iidO^Xm;z)p!d&tVd?E57_NI|1bF&E|mf zD=P82rtSt!I)XRk59nM!8MsVOW{5s4H%{jG!vpO-EWb{>lx^a`Ks?^|ZuKZ*BGP#I z;)!0;;^$KGK-K7#ePYNPUK0W9&n6bX)7CeupMSBrlEoPAS~R&Bv=uBSt+vjR2A@A@ zo)sGiIKQIkiC^`gSgFZyaVC3GjZ8`zlHVg>W&7sRfE4mDTA}v?#vbJqzT_BxwE2y) z6&P@Ex$qxNcfpoLvw#5@kVd*Yq(izyT3WihB&9ngq#NlD>5!66LAtwBx<|-K=P54E>38TZwW(lxOW-oocS=Ltv0{MXNw*k7ys1r z9z6}42=q#6Y=QQ6Co<6+;^9_^3H=Gq?Y>#NZ-upn%Hi8@mE^iEh?gC1tKVegK;y~9 z9V<#*$Jm{$VgE78nZ}y#cd1VoEPuy8k3#+>;FTv(*!Z^Q9tb;mHOjKlyV9l%W&LG2 zgY|9Y0p`2EVQvO?-P+&x_6YWDkV4UyYhz$ktJPt%=yaS;qHVetkb(JrvH1e``E`j! zDH=XVfA@0dH@tODkzc=p3I3C~$wT=Q6IlNqpP{HNpAk{@(p;_f)(uu*b6;g#d=BSOmuNTMo>6WRe?CasRmcN`WtduWyA6Z|;Bm_b-G|K10gO2u($> zEahQm*}hq=e-Y)rh!k$8X;{QrG^0;Uk><@-Ne<@2#E$^lZ$DOMtR{BgooSg-UzKWqm}0eZNz zBe9V7*4)Z+*K?2l^g`CHT4mf)9mwvj(q%ssDDTa;n&yRX81s_b9q;`GO$Dr& z?K)emSvJ?&j}_pooL~#+K`(kClo{d?_IfOveQHyU`r@OXIM}2S-2(ed%v5;Xc;~$s zBwwlUo?CKo!fBkF@Z+@h;YR9nRJm92^t#}S$hPa-$oJ&Tpoezv4UBIo%5}Cc4V{wt z$?E9st>wI@^4|<YM-gT~JT!AjU!2r&6}FG0fw-impPc?2`aftnoPDtfLT(C1 z)x2Q^y=)aCV81=&@a;GDx;!byT;z156g&CVjw9>j4*nXbuV+mVuSSoQMQw1|pFu|W z8+k_Lh&#WH-Es5AcYK(Wm55g^$=DpAN7!2~1}SgfkPpH}HB*#21FJhVn=Rb8zvb+I zeTWbSn%#l@aUwo9n+PtS_m*FGy@EDhHD*qTKe=Z;_*=&;{7&4yVgDrndUNtczN3LHd0Z=b3jcz>qgQ0I{ANKxr`JF;YuKgYZD8@JOo_#Ogbjnxf^7v&^f zpC)%a&rH}`o0XT9coBo`Nds3?FZ_$d5K0Y|vsD!I5NBQ7A?3|8Xk>$@z(hScVyYEb z&CK;ORjlcfA7JuWkpkBH_@CEr;m|u-tVmPBSPY$(HN017f;n3I$IwR=Jge8NXT?EJ zTBsGc?`>@HcG;=E)cN}58Ig=Vc3IjJ#;@N=?APKV!s?KGnU+CxM{F!;Lu8Xy8U$H! z!~27u6^d>85AedMwlqF^@4W*()beYfzvp;(?HB%*F=v`um~=-cdFs{)yVGGzC#Wz` z?G?m3o^p?qIoGQTTS_a*i;Xi*p5q-Y6F#MkXXyNq>Uf}xD*<{2Xz0NBHdMn{=shhY zcclj{_T|5CaVlXKM67Q`tFAXrE=%Uh zh&gl_bQ=+1$$$1vqiQ8nfLfc3`q{r={w$Q{G)Vr}0v>IE|;feoE7%oHiU zEK%iv#YlX~t=?UtJB^9D&7Y&X%-#{*23EMgWI+$nWk(rO|J<`u$5^0BEU(VYpl8*+ z+gw|`NcA#560&no&qK<~xXoxQe3#0^GnWg`Bf&_oxzQq#K=HSEG%sN~Unn*@KpymZ z&$@v72j-@qJ?K%9H7VWNSoI~&;=DDP?CKZKgnS9Q4k2FQDV#dLe6oic)XZN2hCs6_ zZmO{A*|C{KY}+x!w`;rS|2+PnOrX5|xe`CQzg1J%<|&!oAlOChJT8mAeu`TY4=yT( zcrRg|Y)O{+;VvA>m1!RMNz)P*H0x`F>^;g}s%*HEyiQXD^YJ(%1MNdFp`eMJ+~>2i z>g4^UsHVtDW*ydF6Pwq;3dq3v9PNz`d6;jp!%=svS4YQeFU9xM%LyiN8ka;mG+*Nw z{8nYqtNbGXl(#Wq@|#@~;@vlY8-rWbd5hxPP(0e2up-WBq7_KK_3M`F?B}=2q$PIK zcj*XXtE00b6_>?=4MXoOyQL^KB2_@|N*^>b@syFHs=p-kiD7i)T(I;Fh+ndU=NCnE`M(9_&K z2A;>GmY;M?12RRty>OQIZohfRWt{sV%P+FX*<>J}<3nacoAWS+&&v(8k7BPywB#*r zUJd?`xLrtLg(e&>JkkL@+UYxBetKo-P{c`aZYiL+M5^=9R!CCml9erpQ;cR{JqIbT z-I9C*3;%;_KJN|E68as+^2Bt4fsUGMdn=Vzm+GCRn-@E6l`4B$BR*&}`;~GIwHJV*vxsqrBiyUx&2n~*mpHW`r z&BN*2W|qM)f7}(E>$itJyk?^&H5I+yl)C>ssGXc%$n$7JD2+5-Y`G0p)_TQ#$qUoq9MKyAyq#50llJ_vq!vJ9Hbi#O0Tn4CKYpT{)J zi6c_ZiM&-?VIEGK4C*+%=R;EU)mdDHqj2g)Z?^PD(9?2x2fY8$Jzt?tAiX4-;$ALg z8}m(*SmTRlSBcB+Vzpv5D#8_mW_HHswQ0OO&hns zLrH;fA5k;I4l{#*k|S-3Ub3M*=&eG@0R0QuQp=OA_l1;W2g-B1Y9gNl`;Bx~>;?fE zIV&l|^Io1B`8`K_l%a)XDD&A>?0mZ4^o+0@pYJImD+h&WzUrR`N4RYWdA@y?qN(?Z zcR#U(874+LMtZrf&kw7U7wr4Vf`j zWZ^n^o1DOWi1yuIAs#l`#K>q$m!qz{Qu(A^G^Zilr%?IvYnBxytTl)y$(@N9%>||K z6NPu-jo{s|@QK?Yuf@W84&@w`9^4>rkPGNh2*CmEw_)dZol~@a4^^bZ&=$OnOMGH{ zeWU!6T?}=J62x1l_BsFSNfDMZv&}cTU?QT%q76egA}jdH)FD0AE7ZT!74%{`?t%5M z^s-6M!~E{l3>*{eA5O;>6#C6(vIC!9RmDzVz9t)elxQ5j8R_&u-M6&=&Wp0+zcIM- z!)kJDZm7+tlBsSF&~ueZ0s7O4u=$@M8uvK`1{(VCqMqpWa$F;`hNafOxq5IR`J}k~ zL_@wik?t;DbWb^_I-SjYe9YdWm7JGNO%Q`(Qy%pMJ*cQ6;Jk7DF5|B1gWeZmh0-S7 zN{fYtK~9>z=2wPRSb4zs>k!*Ecf138Bzt+MbvK#SZ|YejB|^`HtkmHIW2v2Y)aDO* zB)BfX{;A6+Sr+c?dUn48_L=U;XszZM7h&5a)617SNMVqC3B2v~Whb13T{|n6l53Nv z4ypsrYw_#YMH!=+-A`4oW`aQP%Iy@W&sTmszeP9^+yYs&5Xrg_V|^)>hlvy~M)gw( zfcw<8u#-B$av!95$EOZ{CI2W%&phDN79aUWbi9pVfQl8Q7y^14JdeQhApONn)ynn! zXFC9{zxiFtPTM2b5LI@?FUDf`6G*<-3TI#52-`+~gHe?Al+G7E@do_cC90_{wrL=+dTRZ6#mvgf-Mh=?sXL-F`HcON(7?v;Y!zYwq zoA~g{Pgu9uQ&!2bZC&HOdH&#suLnI=4CviR)B*RA@QHK(gylhhZbBx|V_cyW=m-iN zS&p6Xvu1XXg?MnH)xwSaEM#vKA0+!GC<}2jg9CN7N-f6PtKwB({&x#57W4?_;DPTC zoz`2wP-tDf`r=JEBv!QaBjR#Y;Pcg7<~R-qu)p^G7K2+ax$-5c^O88Rfz>ORj86-8 z&lhiEzwafKd5>F3rGXx64X*^Gy?x5J$I*y3DGj4GrxT<&D>6aJ%I%c#Hg!SUK7!<% z;On)1i%t%Y;CC{zFE#JOZ}wL*frQW`bK~si%uQuAR|e?u8CwJMp+`@}{WYg9eV6#U zbXb|_f!8_fJ1yIs2mTAIDiCig{wpP2lx`LkzOzFuCv$3SL3G&GZbtlyu4ejEMplMe z7U;c*dg6xU}$gz<60wL`3Sj zb1nBgUig)jw_vi*31x@IL0sTgn`W1fLXwUZP+uFurYfdXXZLA>Nl)>cY~b%a5vp5moks)o=mFLfT{x0p*~#$&Ln` z=Z(k+Q`>Gqbs$NK{nC{nGvXoe**MBWi0Y-K*@Ac)cF9cQBCY{bWY#5rqr5adpy;K# z9Ag)SoUCW!>LYiiDnal1LkMu5ck7<=>%Uj;73#NxVmzltjGlVh{9-=evgXm@(L=oV zv{J1&A|wRQG*{3jB;9TCJhD&OwYR@Xi0NK+n4~+CRDqtdA$VUt>kCa1L#@5Jc;DWE zz8yiEto~oO`Pp-1+?ZD2{Ee5QbhO#!cXJpeh1CugrEv(7-kBHU+_1gjAA*Q5H4?Ue z9)pJ`FuywBW%(0ZxF3$|Bddu=9B+qfF4&+YoG`CGFS`uMClx0wZ=B;O$2+OLwJ_Vx zW{%A^!hZj!PxFWKYsM#4P3P}mKBCreD#-Iifazu^QDyRx!zFKYPnN!U(<~<)hC(t5I8P|~$@VqjZ*>ZZsM zv^hEa@z47TPYA5{YeY-@;bVwm%7i>r-=0RAW_t;0z7vW)(eM-p#&ZM~ckaHwRQYuEHf3s2Z~!=KAODL2)&f%$m4jp-oewUYUbaf(40W=E;SGUi2(+3^~C zaW(>j-z7y2=${LIQiKOs66Bw7HLcrbrJ=@t6yRV8MEAVQX+ZiC`M4U>33|WN)PVkU zwzrMc$0ai59r4~sE1o7AbivNI>A+I8=~i@Ld{fOyja4MVEy5AR6n=wt_l}(IB7cIU zL|Bh>+IFD}jj8yb=TNE&Jm2?>Sn2q3|9zXypJ3Zp+Rfr6Vs|tN^CFL*q5yFICSyd9 z?c#ENbO>F{4g2nu)7QB(YWVa{*qpzv90dw~I*a`Ac~hb4~i<42oa8AH84b1g!6=*L5^HXYxA2KRAW3dDzJWxFBRL6aH?r1-lc4r#UX1^H9(?t~koqi! zCmC?ArM$r^&5%VA-*RF1=6dPFxP+W$8}os}f3W{ob!jf?W-o15WQAKtY zJtHgd$~)4#+TheE7)Ajt^G&wAX2o}}pOM{0CjUIgsb=7LL`A-PcyW?ee5T(anwXb4 zaNBk2`!e?vD?2@oFU0e)P>6qZeOcPE9QD^R+~jb%#z5$H;hAl0Fr3Ybdl13npQpkg z3wWA*#oW?&t$$i@W|)Jb8i@CK~tn+JN&48ElmOEOPr_90?&ex;^La+S-BI z9u>M3kA#k@`8qgqYYSj`H%e`Q=OOr*TL3>>MLohlw;}^2G}iV0u;!FZ{S_AugBK*9 ze6!))o1fA4>ds>M-`YRvJ+m+)+_rk83tA#GrXMaMcrJood&3j39#mOkQu*oABx?C9 zV(=0}Trbv&Ytr_qb&|XI9dI6x`7L*-xEVhF1m?(H3zy&gReOSAnWcbKI~7$>0xsEZ z*(X^wEo$G{F786rBo0cQ$>s57^QU z`J*fC;qFn|{mrc1jc*(@SUdb zyrq}Yxl}h%Tc-62oi0AtLOBUfnc~S7LNLs*$5c;%2+NHFP$0@`& z4(^S;Oy6TRKyTeN7MKquB)LM-s;o>C$TE`iQ1V3S<5fzF-O-Z|6O+_oM+RUx6|`|ReJf)!=96~ zhCGiKGs1VoFf1;=UOPd>`#A>%qH=EBQRC=WN_(6`^1UqL+0VZIO1Mgg+B)#K?sYtr zlZ-($R*H7%Le1;+uIhXX%qNb437ki*&gG49oSM~L7C#$3ML4_+&ZU=64#D=rZ}JBE zQ{Lwfq3)Bj^0-||vwX^u34JXRd%E}+AMSLEGpX5cZ<~IBo<6@6F#j`4B3^XkP2Vam zQ-1g9kW6;89j?zWgs_IkYzP^Wk65|H`22=*oqL9-WI*q6B09z8mBoMm3fIy>w_o?2 z2Ft@X=zX#-Dk$8FJOaIqDRBO`6zD86 z<-F5$WAlUf$vfgHKe4ntB~CGC6m1eXUr=ah{bIs2ry|&&PKo1WK!5I%>@Etm@``X) zXe2@}!YlF=^pIr1^UJe7G~q8=SHzyV2Qh+s!&d~2 z!bqfgl1UcUF|HRpTdrqDl>IS3qCgo4X&AVCB1Hg=U4e38;swK9ZPI+-wP{rB%6_`P#M@I09UuD~w?^A;Z$ZM@O!x>oiJ?vkf# zqc=qaUhfB_57{iI>6aA##n@A@fKSCIh^JrTjCGfG2Qk-QAO`t5Wd!CUrflchAIv0PZm zXlH+3p)e>$;C_xgQ#Y_)-5(QqI4EB>a*g{crTP2Mj_aY*QqdH}fz^nHIK(4^`NGeL zi_TDMCjv9^Vsu53;M_z?kpCLyI|FB8|DA9NH0a?*F#!D)1rxtQ;|AX+jpl5t;J$d< zo9K0}mRRra{`DV$?>)RxEtG(7u-Nk&#oMt6XCe61s&~3xhoEwY|M!d6BL2NREa>r@ z(xXG_v$uJd$7ISh%OAKj+z)dTy;K%@TqiFa@UM%40Ge<=U9aE&{Y0|$EeTr)usFY@i5FrQ(A++tXAztZOp71qA5(?kO=jxV)! zY9U_lmkh^>pTBPR$Flc!Qfx%}bX&9o-|$+s`Oa8vXFaZFrQE{2GBoCwYRUWxxFgVS{wI)MvrdzdQ|@fH+jJOGuccT#FITs#S?SYVXAZ< zAt%x&9Y5JuDnBHYgieS(Z5p{+FRp$GdKhajf%_5Mg-t<$OaXgmI~}Xbx)I;3_b##f zDu2EjA?lchcy&lkwKT#Jy-3aY6$pW}7S;@^G!o=?37utk`W>%`Byt^}jX9?F~^uLAXsuv1_qh zov7v8O4c;msVa2Pdx1Lz+-E=%z92;_|8DA{H2J)rDHlq>yniL@5ZP?V1MZioEti_5 zD?rszSXN!Zr5SWLIXvsw_TVQnj%Zs&&UMPqVS*kf>?ZL3$Gfm|^YHTf4%Y<@aVFSQ zN*i6$85}6>T>cqiSV(#IRuZR4WIg}8D|9NWUDZ3qD>KzqYk1DrOTbuXx)+dRh6Q>e z+C)JA*YvR_tT}Z57>RtrhVEYYL_pa)VrN*pS;fIQDSWH@Ur+A zt1r{@<~S@zz~%>if@!M|F6cpDUnW87-;`PJ^@NkkGUYe(M90nFvzippoWI95oD% z`gD5~2cpwTL|}R0!>fV&7P+L;uRDAl|9jCsjqU|qGXm9LH&!<<;lL(M6l_R&@1NbG zIBY2Ue{0X*%N#_n!)B#UrpQj~;4Ut?qUn|IUi|a22CRYg+fLB9MgQSr;GczCx~ype zoVVM3L@O9=`socHfc=uz*6db~(9|}XWh3P`Cs>rLU+;*}5O0&=#4?c0<|5Wxh{1f$ zTGl{&%gfID>%`aiwrpz#N+ZV>tFf*zsg;3TB}QJmbp_I~4DOzI+RT4V?JFJQ2)Dq3;lb7>af$w4pQh!U8u33V-0ww?6Z zV`%V7`sZZ8W~KjKn(p_v4?9)0$CC} zg4Z&$xYXLy*BB~HAm0F?fdy&#(-SS|5tC3mLdu(>DKh;H^J>>#TNH{Q&vzanG7W9F zf8@Muv$hW6`7sUNj$Iv^)ACr{1Tb)Vp@oiKt8v;$G%okP%l*}fd&vNLW7w9!`mKSR zkc!edwRhmI7Fzo;`0d*tqC3pwXA9}GeqZKIyp z>RE)CDFLG1d?wIKig}3)$rq27Q0KkKE9F7}3d8sP_ z#@R8%rm+X!EQkH9Ieuo&R1kQ7+QW9}_5&_IX^>j-vjYt?US{7d-_IX3S&t>5IA1E?vp;A4OEk~=~e^9C3GYar@q)rcW z&of}l1N{|-Y@1ZP*KuWx#xrfV*#O(Qm2p_dg2KkFxfum6g+Q*&KaWL`6X;JhyiD~x z>r(DFdpEfSr(9;$r z$6!1gqPNEP@viI49o~T+e|ip3-ZKIOi_iygBXrp@Oag8Os4t(8Vt7-bv|&~6Onr_akFPRlJ=GGMOglq1UZs&v;oRk&mNoxdO zY4d^hk(ZGb^Hp~PKK`02F2<*!`z)B%j9swOz{#wlVI&T3e)yk<;3o&vKiyAb?pARd zg)jO|89Vst+Xk*Z({hzCXZx18FIS zW+6Z*hoKm&&+Zq@Cr0;-O@~@*0kPFHK1ebGXJmuw>>)xI{za*1r>K|W;>zfmX20!QRQubdbB|8$+rI9EfqM(J;_j4@Y`+}5OJ zL^ep{(77IO&a@$3NOT_U0mEf|$o5~NPUUx~nMh;09m8nPuRO)Z=|rznI8;Fo={rs# zq&~ZAKKsWUYso$bZjZ~D1YCY%en;M88sztTw+jj4wZwWY5TP~$4njcewdK~<^7`GbXH*_L6$@rWBpyS`Tblq#!J(FgVb+Gw3HCf zuJ4Tla&aI(t`02c;;xE`{ikocV&F=}L=e-smwQX6m zJ4;b#!)go(&=YC$Z9PG3hj^l%kwm`AFpFMIu>|IUT zUfx4I*w(;l67SLlB*R%n=>1;QjGC4I_U*ZAC`jPmo}>n-CF+14|CJhWU!agGu3Cpd zaOTUIjWljhLT1|x>ifGfX61WVCw7P@GiXGxWO8P1QHQ;rnQZcM7865pz!N^UVW}#a z#Q`3_|DT8GtUCmGzFbt4=^ZEA+^%D;`L*pYTh$uqdk31v+wlhLfc2ncoZ!eaA6Wzq zI!#cSmPq4K2xBKLw=o zKXXo~nncvz8bb2%u&hE$K$mV>qs*6z7WGT>jG25%?0kz6D*Z`bUC^(D&k*#A!!3dK z#_nCV4ppj^D2>&EynU$ksrU2`%=vA%^aKhD@O;g(SPtHz&jVe8Vtt&^owqbCf^@+pw0^6(wa5pz0`64#< z!^~y>`~I;7-mdNd!KVSnB0P~2Z-jb+5@y$f7;+d3FrR~!(`(4@H&a$)CWr4(k{43R z_;g8VU>*CFZ@#C@aNfK}7UJFa$alpw?c`jTX3XO`c z1ico?OkllF3uAxm-}4(P`7&5NB&u>(z>unn#n##UfHxaBuZkn(oHrkjR2 z3T{UgR6xBlL3bH@FaNMCydV9}B`6A#Z@PGkvvCEV*5peUjevc*mHSY6hAc;Rrd<2Mat;VXKz>^Z0W?W4G{*!AC(BJ1&ItN2#Yev?H<|a6TQSSDF2Xcl^z< zki;A0X{Wa*7-&kZ%(&E?N6$V@h@0XtHef!_b{^n7Piel9!Ij$Ca)B_Tnod#X7`d=B zes>;kHAng^43ck*2y1P00C!O4^f`W={o6a0rf@N5vlGlP*SSM?L}K%AcA$rw-5~%e zZ>Y(H)GJSJ|2||Gl$mF4`dA)~3;ncnOYAT*U_A0-*%_Bjw|rwr+aN9Xk}Ocm66$%- z+A9DbRhC@(aEt1tJ?L3Rn*;TEuVqV5$u8$g=cL$f`Lh@52IX_?QO;EZo-#G?erRYp zZxbqV>mQ95-r37iyXqG-yfL&y>WnsJE^*=Kdi+8EJnT#{V16L4*}z9Egt47gG|8A8 z+p^|4$xF*K_Tq1$#VqhW02zfx+~OCbrqORIdRlBk`?C;uNT|H{cgQzJ3kud^VOSl( ze7r<{!1^t!@=A@kwNu^Q%+HB>u7{ST16PjCJU5K!^TYt;_d7&W-s$b5h70V!)_Qq%`CTdJ3^HKz~)BX-vhMxHczNyrvVQyACB@PhndO&Gv>3 zEf%QH-+bElWT!Thw2amU7dZyjdRa!rSp}>t!(RB16`XVu3b})xIqVN${Aeh{<7;G( zpqA&e$q#_vi(=k{dz5U96&F|y4Ta?UZD$cO1Di!QF8!6x9bd}jB^J|J{hd)9&kJKh zC675@KTptetH%fShmNx(P9_$16Q>{FJ0kb=7^j--o6x-N{gas{nga2XyIlfyr59dQ z@E3^_h-}=#{gH5BpQ8&nEC^LF<*vu7@&Y}ChFc#Zj4-31AaKzLT6u}{R)}zh|7Me_Z7H*fwFQAqz#H^bA|!$K zYhP6uP0RCi5U0{rSA%b2U6@1=%T-DPeHSD40^(Wer#JN`4$ll^yH)v<)8NP1p#Sb` z7qN#>^b{M zqFZ;Et4EQDnmdKxj*=6B``$J$m694<28h1DvV7a>souZQ*GV|!qrRuHYcFt9VkG^|FV3w@~4|{pPP(9ooj1j8UL>IU574SEn59vUD+ZPr0h>6oF$#qu}+ zx2DCFM%~@*Y$q%l%;(JozK?C8Q1ID1Gv5=|^vcfW-BJmOE{Epj3Y$i;b|$bt#QG$( z2K|+nqeVnjJIBPuNzB6YyR|is(L8f=D7v;C#zYM01%4j_`YUMJ{e+oK-R`CRq$qXQ zDk0R7=fPW6!N0tkHo)^Gs?1g-@E;KiqrNa%7qNFMhFVXopQ&iMv%2DcLviwi8Vh>2 z<6A)e)3}pox2jOq;;H%e7q62Z=Z3SvIML^JR?V?-1M>ULxA9S2i}i1zeto?(af(H^ z72hH98FB4BQeIS}Wk@fb_dm}p16(icI;jOK!_vR`II0n)zxp+iF|b|^gItE3&W2$a z;+Y&sn9YCee-I(%aK%l(6hIb$4)M%^z^R2 zCk`wxMM66;-=MF&Mc_2W6Zo!yqw1rscSgNuW^Y&M6!*oZ3V8p+Djmj4ngx%eELch= z*Y(W5U-y+`Cw{=6b$k&S+V?g)GKrvvv;9&N(!X4Fw>onik2xE9KYa-GC?b8qFoMj` z6jZ^HGT90#?>UxYK}l@bD!K_?sSH$d26}5{8o+rJMUhvog)8|~M0*q!uH}T; zfOu+;7J(y|?Bn(VBwto5TJ-u5y?L$@-tSzo({jpSuec(lReqCC1zOO<%ZhmEpl8Er z4Aj3wa>nY3^BP$7U}A$u(v}@!jy##KOHr?@W;n+o-scFRF0EB;T*b2LhVX1NQm@{T zuhDsR?O0L`qnHxtZfcO?t-S8Or_bzV27slRg1 z1a(ic9+>qp9Do>g;9pEB5LN@Z*HqfCj}ytA;RAue3p3&*RX^T>`pO~JSxbp58Q8uc~O!tQjAiva@&gC zQy(iY#22RM{i;gTOERYDX?Fp2u>kZAM0bGk{O;~`Jrz=eezDQRw0@a_9fcHGlo`yn zfFx!`HY6YFlGY-hI5++{wZ9YY&|`?GubTqzu}VB@ss&8R9)FQTbyNR zskc~|)<$gwm=A^}6*ymQlMOCp>8L?_xO&6G)pz1bd`ll5t{NF;vrk5IHlyj z^qcPPSYG$S2?~g({w2mw8a&VAk76k94Ab+^J2R02>Wj_SJDwGi%eR&1z8eL*oFj(K zKW|uaVJeVKf^{KYg$tQI<=O`#0#~|PwmXuBk2gPXos+Fm?C(tdeDqbfG{1rQetVVx z>s8x%TGmst{QhxMIOmMAZ+EJQ|9#f)%dRuhOAJwn*N1AQ?JIX6%6jQBD3JMWA8|CP zZ`B`b8Y<@Jh{}K8@DH#0S6)m%G05*nAg@N9HRx;>jM!so{PGfWH}>?Mc`a4vpd7V1 z#Dlx_R*8J^*jI~?JkA!Oz{<>6cOE^Cb-k!iZr%^i&#?H10^afA zDTG=*#X@JFM;A5mWsSXgE7b1-T)%^!Wt{}@JhUg5tGw<%5C+am6CluT9|!#U-DaIO zi^yiPrUJ?LWv)2il)Uf&v9{u5Ka9?1ZkF)}g35!0r6nlJJr6D)g1`G`xWCu8x3vPd>87=TIj|8 zQ~FOk7rHWB6PSbL+{wi z7b<8oand5~#KG@7`JajdG*+^TVv6YP3(4Al9!%9%3FP@I%ovDwRq+bX@3S@bS){zE zIIcOxRdZOY@d;!C(uN*`~K$`KPXOC#o4t{zMVHh?`S>FDW2jBUJH9(|76*F2{FV?Af0su|-I+ zs$pEM5Zk}wi@S1tJ?sQMnYTH>eG7hML4%h?*RfpTE-rjjwMlw1yFZ>fR3HA9Y`8=6 ziDAU2;o2DKwKK0ee4vCA)FxTY^J4fsa#nzMn5b8q^SKN3&UMLv`Bi>_p_+Lk<%Owy z!r)B27yJSlJ90Vt@+`3#EpYxp2$g}`a;(iKyJ2FRK&IE>hUBcg-uNjfO!nNLCpfyW z;Roo!XE3)xe!ot|9-H`7N$b}GbSD=Qkxk7^K^rQlKhZ=vH9H~sK5@D;vuBI4T#jCS zbZ5{V`FOHNTC_+qf_#Q+BG>mS=3_VLA+DYQ<7MK>ct3Tb(EW|^kbx3zQ`K0;(&jJ4 zSv3u7iPsR1tTiw7yRRkU1a22Av++0QwqPVUTG3CIXY&kAIa66@b^r2te;@?B8>5Mx zx=-<$Nb52YbDD}c4IH}0kFujTKiL_2A)Xz9C;CVQkAGgm?PMx+Ie!9v1Z>c@+xL zJBjKH>g;Es(8TMJEmYxcfrlS`tumL(Ol|$3C)!jGtOsj3_~lBnJ}XO{jcd2Q>Qu`- z&O^Bq7=beEe+%>nh6h^*-6_fkugdO~b=Lp>dTvBd=h76k`&w3UHZW+e!Y}}O6KbwN zd3DjK3|xD6Wi72{bbIpeev;&KP)I0AZ;dTPM`~#zR_V2CUM}->3(S0whW1jvR*%guHj{QT8bWI|?#u-&R(;;?k z9L#rzfCP+}$$=8W7vuHTB(nLj#kQN#YRU~`MS}1mUi|-ENB!@Q@04K(cwU@A)HJzr-I(+z_j>OqLGO41d_Pa1Cp7W- z943pEiA1=o`wDR~>x67H91f$@>zy*h3)t{Acz_LnBS#R8RLJ-vmFq}>_#yKC#rI?* zkzP^>g|R8nLwLhh0BLWAuQ>|NCc3*{#}IW`O4EGm&Rszm*_w0l%RsDxc*;h_M|z%x zNjyJPen^lSy*-hA7zmm^l*B->EiB^?T9KLtJ?`2KpnoP|J$CACG>UevU7>|;afnkf zD5EMbiNovvP73Vj;BM_9oub;Zl;mXdzjq#c@Y-Gt9B59!RFIeZ6QPqsBD@58PG?=f z`;sV_FJB9!7LLudn2TlpZT<4DQ_Zc8=)e1=21P)5pR{==%=76N`d- z>Q=#gePc(!{WV)nGMmX;{oj?%%edb^GAt~6Z1BFd!ha6uCI#BBX~hh_AeWc`T86h` zvgU~FV%;pAX?@Der56)V(UFo#;ai}G9ksy<$#;=dKIYGKMqh0mC%PPaE%2M#7ZKH3 zd`jn04VVw@V)m{~MX|Cf#ZR`(N@@RGfG15*hMsL2jv-;gdi)t@`wR43-xl zgi~ZQals|Wv95%`d|atahhE$<$yT}g!}%{nbf=-}+DnX?gXH&lccbXrLfCzWp!ZSZ z3RoY_h*IO_G|j#KGYLgAoO>8UMusJ0KWOt-^&tqjpYy$bIR}b&ty{tX?Z>IMR$xSH zO1gv4S108%%&M+Sc?S0r(4$Y~1IBYgJH_h`r&c^Xq9(T2rMus3j z%DWi)`R-z;t>VbFa4Lk)wrrpnp~7T_#Ou{mna#eIc68T2kB~mS3i5o#lK6a+j5^9i z?HpshXUrW!+ZKmtF4aX;j%u>klw4PZu%5$wqcz! ztITsSABN!yP+m8cQCM_XcRXmlGm$b!n&Y1roI*Hz2n%LvyWo9b)l3}!(qJ!v5*|X6 zxUYpyC;)1@qG9pDO`%I=`zmV81TxaR!np%*8hgk9`_4y#&3zGB=<M?ZU7mYo2P{d(R)x4nL|xt8tC;A|eIcg5GPa5TJcj1$lnpTM1sZ6+{VC^y{~-v=>NKb<^)UisG%puY4~^c31$(N9(d zk<&7=qJ-kgdC!#f$8ofoz5@2c%()(xrDV?drJM3j%@sq6TW5}+(;153`$KH2@z2P| ze?5U7jA91xz1K8H+E7??O-#MJ>+7-sbwQ(VERCXCT?!v!dnzFLV3DT~zOG_9{J~+3 z6CgjKOH;tBFf3$?Lu(XgDtn^AaNXB4yEC&>@9yWbeNQjRm$33veS>`oQpx5`s z7+7DE&E;zFOHBXtJ*S;oMq2p@nW8B%=K-;)^6eFHJ|g9|^!xi$Bn{ROjGIH$c7)c$ zbC=sPYuq>0nR3~6`0h8)-ee{Xkni7MsSW1YM8X%@m+H4i3Up@uAL>Z>(`UD?gn{wF ziWNzIl>2?xciB$S-iQVvf03N#9A300E3r=zq-wF3tkQU8?M`r3{ zs>C1&3wmSXe876xY;oPYkDIHwiSMCdbG|Yc?ybNJzA^Z3!)DM97+)ch5G&P)w&s*(79#PXP{O2-x?5HI7uBaMra1Wda!zLzDQ= z6$8_hFMRn@*?1g~zhB=Q0~N{yG<`3$nV>2W7 zjGBudV2Sf$Z<+TBc`Jbac~Tikz$~X8b=CJz-7oCw0=>Bld2KN$WfNG|g>%dAa(mC7 z4x6&$t` z50jo5U2?XILN{!F` zrd`^^0KM0r7n2|jbT=n;Oy}P!%A#Z{&n4srZHVHhBlvEWETvJ4>#AILi3mtZM|0RU; zuHPOD#}{Mbfq1kp3cZrPQ_+si*%scWm>yLTrp5Z=j!6CYRT=G^r7whC&)!1R98mvg zcqNCE7_n(5_w6W--U_|57g>GLVS#mo^+g2epXpXngAxt!oLq?8g8yckQShM)dH4|M zg$(Y@OD%pW_3Fe1^OcHpf%A{5ZR57!?mvQZCVaz;&0ax*28}sQY?6HI-&rB~jtu!r zHs;t4;L>PwkqfYb$RuY8F8rL?f;_lFaMcpRUlD*F)=?QS-;ytSSs-=+o6wV7v&|bS z648FPE}1i&j`J|A@e1Nu`S}W_iEK1HoOawYm>GTx}Rjwzjr_&2R+2Rabrk*K~sWukUpQi zKqnhf_T49@wKV4XZ_yap(CrDk67YKCPuV2l^lZNO^Jmvl=3(Y({?7ji1)jArp!x zmmIv@t8_L~0&3U|5|V4^EZM;%Iuu|&)&WVN{<*?xBaV;>%X}UEPM{FJ*d&kEKp_fO zOTlF}LJY|#tsbEr{N2Ay2#+W$VzGT{b0{ZWi01tsY*t@icwvH0V{j}f9Dj7Qh-Ep7EC{(Ci9!`6miKG;)#&Ged?psy79A%ntFAWB&W!H*nvMqU_Q-t z%lg5C=&KYpm@hG}1bDtNtDa?cRW9df3nd&obdXqf)sl@)9&hOT;-CQY{bW{M;{kD} zVfhkwx3B4{EHeBe8|!bsGVh5*p}0_+tA2j=@V%3O_fZJA+xC5QrNy$Ue@A?7uWBIU z$xQuA?3Q4*p&bj7&;NwD{?{qTNrVJ!rB|=d%&>q<-zSq;<*9)#T8bB$Q;IZTK7WK& zpuC-=M?D{#w4j2b8%mnA$|C)kr30>^g}#t@t^)I!NH>*Dt2g5-v3zTFekaokQ!oFF zAvnI|+mk9Ql3&4TaiRr1uRjLB{iyzmpq)@St4)0~O3ByoiRg2sB?ZpyH7wecP5~sJ z+xyoI+xG5WDf9t$hZGEv0*SXg?RoUG@HFKH?g*(e5_F(PS}y|L-)0soOrykW66Afi z9lQ$cDNMrriN8`S|7|C0Ks-;>c2xgWc!{;BL{v9lWO}ibZr{z_ z%>(OKfjTPpH5?dw(sRmr<4L5pt@+X;{oVGduEKCO zd2A*yl4GA*Gru~$6IAUFj<9}sv6c(TXLsAuG$t2TtA!Fo8R~lB)IG~j{z#Cdxcxb7 zN@ZMkGnNDNdQ;@7Al}OMB5Q?_PL6k%nJhmvJ2%VTyYP;C)ZDhB=@y7bPb;;PUc;4w zapJ3F3mdF0!?$Ne*e9z!AL1X{TPnnG#0h#RQrJNMG7|tdYK!&hD@>G&WwkhVPA)pm zWqf4VEAz7IA&57+KR(fUtmJNBTs@U1HYF#wpjbWH0!y{6+~rul2gh~D4SIk434s3D zw&kmgujXPSUL3O`cYD~lxO1)mG_iX6O7uGL`;@=PPuazvf`8HG+8L%@MVACIM?*4r%|Ii2(F%FcLu5#Igyh?95BUA}1G1TyV{up%YX4&l z>xG3Yi}WWZOGIG($_bT=)uO-tqvBINHuo32BxpxCxo?~<_$Y0{v_I-NHLFxXuf38Q z7@rna2IzCb8rD=TwHYyap7mF|HEP{*ET3kz7otJ(5iDtY9HZwc#xJ;D7m^p@etOAF zhep0=)u&g+wRJ4IQ~T_}StSGIWjl^H37zQ_)hOUKp}o1de#lNpkI-JbGAJ9qkafo84;SDP~AYNY+RKrbKU_hx-+wza) z!l!EDZ!SiXRiq1zN4SxC@>|`{USTCJ&_CBPeR0Jc6S{m^XPt|4@2SaE9ob|d=s}V^ z&)@>_hTs*exKpQ?+t9;L93{xQl?0RH6ZvSGrjj@Z7a2h#aj= z44TuL7U-in$xUq2enScE)-?S?6N7k?hh%VBn|W|c-UbY}o5NU7?OBdT=}BVV^3I{% zr361|G(k^-DHRysV-aNOl*oDyVzy0$ADg}$#k3JfCQGjvS33znN3ud8NuW6Ei0&z4f6Q;@Nk;CE^em9zP28>lVb1uo+Mp#t@VH zI)_{;KJoJxR@~z|FkkcHF0g)p#cYPxP-CcSNIX1YpOu6EfKs*^kSRmIbi4|TCt1wv zE=5gHwdQxk0gRWA)dk4|nK_&sNmVk==qvwXwZv2}Y= zrs5W5*$?0B7=g!3okwX%KFATPUQvZu@v;c9k}u3PL9=#S!9;rN@OR2kjpRuN`$nM0 zO9FoXL-j&?%B)_h&?9g6;$U}`kHH*Whh=BtuFGmJ ze;z3flN0_W)6ExYgz)gS3Fsw^&jZi%=)0;rn`}(@pV^s%-^mTo`JYB|eahjPY_9j% zA^F5F5S6O4Uh9itSQ6nZrVdelIw2jmAhH&TgWtQt-&QAo_7Kwqfcb~4&zYI>k;VjJ z_FuEcst#R*Y zP+XtAke`A;{i|sBn*PrnwRoH?07j+C%RT+h;A83QexVs%?HH4_qZ9e~n=g zEB=44G_VT`6tp6vBwpfT_|+xso^KA8ccce=-(07S%>8a+U3uyJr%?748R-XMgg@b< zg4qM^N`E2chE_pX5S-M$q_IzSl6sE5&hd9rN^lO42xqv_JI~881xbge^86 zyM7%Z{`zNSY4Ur}!&{XA+HZ&Eqr{=ybk-^+YRMxYem_w*@^8(Ko>QUy_se0c}C&RhX!*o87_f zUimI<>#lLgP7=o)upahBNn>g*DJPFPJ&Chn;$yEX%^bDK<>l;<@R0cA=GK#y9q18F zrvUZYc!zHo#@HiGua)CiNY0%H=TDzeWLz4@7gys8NWOX`q@lV-=0j1@7W2GtRzzP} zci9CVy&?=&fr-BfC7)yML64*|1jyI%Da!J6XP#umZvG^)VfaSnMRo3Y)&nD~#T~Go zgI$vUSTOkxe?s}w5Enm9dj4XDBKBL=ZKxO6a5}7AH~EgBr<+m^tT%;DwX=z6?M6o?dNa?oC}Zwm+ATC9^Z=$&@kyAvGU16%nf{s2SRS35Wgei1^yY*KQvbFS zx(Kzce8)vo0;%%o9J>a0@|4ApWZzZpC+9=FQa?Y3ptr{(8SspB3Ws%~Q(0QLt!{o@ za!GIss3VoI^UvOboDa}`*ABQXTofGOneL2Tk|Trs>U0dLMYl(VlVTEp^YTJw3|jBB zM<-{X2r2|Gj`G8-DK5hN1vM||^x7+Ih6NKm!F;>IZb1LsQ$a3y`5lh6KlouzS<#+~ zvg7aj{ujpcIOndUkbJqYh@aMF0(9=!odUmjQhz6aCViT1kHUS~?;-K@%a8f37wCCS zascKdklB#qSEqr~&5ww^z2LW=L zzY4h_D^$`wA@l1#yyZ$CK#!BZ4d`DkgKg;+jHwEK*ahCkU4KQ9x%w?&@`m?Tq?5o7 z;)SIvSh#7h^-m*AAzN?53~>qA;}w^E>*Z?C-fPJGi2nK6+xPehT)(S49vhB2+xPqt zP|0KPov#iH-o>!j-jI6ZWdrA>RHDlaWi*OM*Rgsm?2g_&eN!~bIQfAhI~&dI!T71_ zjj}(OFXC@03FQ9f;*u)d)tZtZ`R%aO$H-KY3=i7}t2v@*LLFH_@&!t&O41r334yto)%=SFF<}iza9}fT9Q-Cg}CW3g{ltfB>YyF)fYT_%F%W9P3j!L8kp+r9f zGtsG8_xEx6Lcn~xW9-0qy!OpJ&6&g`RQcEuf-1i(9!Ac&XC-L|eNy;8VEo*8+|=Vd zG%jF|AZYaXy3RDh+?|!Xo;4~>I$&x+f9l~wDCm_7*8}Zs$seUO*w>dlfR8~=SW!%C zA?@>@r`QhuKPB5mkbFLHRpA(cjY0=G$P#49ZHQdnL9u)u6QU;!>;3R&0!gZ$K(FSm z73iPoRDzcWU&l2WNuZ-2R=CxqEk&zk%Ts*zrB(xezeO6~x+;5W7fu|3CW)!Vclxme z4Vp6hcP+N>%m@?d68G`5mnxYKc){&eXHoGaG;+b|@loA}(HXn@nit|t7M2rQ)wgInH6cms}_Nw zmPz*3W{qGWdqI+jfMp4Q{(5n zx4RdPG!Z96X%l)gT|9gn4zGF0tU46Dg%u6vn-SIk`h))lU&^0VyxWOhW#Y0O`tk?y zIeZimvHW6_)CTNtWyMb`$q-Yd<&28R-%L}zh^_8U*u2RAUrf%#ZpjR5NhugLzW*}ZAi-PkuU zFT7E0>YM&(UyK<$(BL5koDV|~#PW?UryegEsKDh^mNP|rH_Swrsc+iNoMhsR$&^pW13T7wQE3*(f6D&DIX{ZHHckbD?Hnl>|Sf%Cj(QNFp2 z;~TyItqaoSaIqeaStcGeE@$P%gZa>_e**Q{H=wT8-Dh(V>0O3Q=8$)P4mTBqtrg!(*Ben&`<=;d%k{ELw=cj@qx?gMsAlE8u)z$(dY79RJyjTcxYu3+YAJ@e2ek0eJ@z*5Dp(2Rc+LJfrTM7Z~ z38{7R-m7qfEZC|vFdrc+GSJ=>`RGDAnw=}VRCX;niBP-=I`&xE9;CkBO~5ul^353* z*p^pvV@e@BVEzbUrv63@HhI4<%FW@@}Wjg{_NWQrxs(KDuJ_E$Jm^|A@=pw6pm9|)kT}zNQ^B9^eWaBf%T2f9<@!4 zH^o8S#m9XURtE`{Udv4w@_AHCm#H@p@1ZZN57Tg)v%zGjkT+3$3vOPF0dcmAv4l$Y ze7z=I$u}4DV(s1no{|Y&&JO{SF3t`c{G7B7;%`jrUGe$$#w;eb%@8j@_nYPx>r=Zx z2}1lMftCt9w}}$wC9IN))s1cTJFUr=KS1xjtPjxM?z8!$aMkR`Wq(Dqk=65ka$-e~ zyPv5u&x)c2)=#65;q5b8|CAB5Y3cN9{To+f>>DEFF~$f zI2-6^-dDQ`N?}6171E99~3uJF_;0i>wOrv zG3J+^7_1ok(gR%uU_R{kOu&4hh|8{Ab>zp67?f`Ux=~Jqq?PEjlUi4t6nhcSKDg=M zb_LssWJG2T4{^cw)T@ent{?=TU74Y?nvi*-CL|Sto?ij@{qE`X7({2yH@Q^ZML(rW zaQ{2k@=5)aVVIG$UK{9NSnSO$M538cm7H+vi>&Zk5O}2y){=b02nA8ILh+Zox1T*k z%t>H;dW?j(P*Pc#F8RP5@K5X7n^cF;K13n*rk?&7I4|F{Sv$b?q$LzhPO?4`1tUtp zhHnVZg^)Z?U2(GP&i03-=sBNg0MOsVlxxhawi0;O%dv<#pKk^I_VB{Cq$J>6iSYp1 zudkx+Jq)_T}jFD!xGOH@e6oruT3An&HeAqkb%R zm6n0|#F6-c@!z;|ZpkzSM%~Bz%WSox^+;b{tJi&&B7Kq`s=)gAT}btr9)XYiTZCWr z)Sq5&h!Olsl33h4ufpz;u`;{l9ewslVj_U@X85a9(0-`5r|iKn=y@nRzzAk>h-dV8 z5V}wS#%qs7-rup24nB&E+p{$lg`#ccA>Y+3bj`teYppQ^5y}XbgZU6%5VJ$--)AXO zB>yp|f7gj4wYhpq9LT2#!K>RI*$hbSqmcH|g70b<{hLmC#z_aAv|3y)HG{YQHF6V8 z0;4@{a=dB^X(i|dR)gQ?>@%krTS+I#D;`Xu$DH)CVjx0a|Kdp+Xwwx8?DtSbxVstL z`y9=T#5aWy?RiKln{9dM|N27HOaD3i{Z;<-vlrV7e$O!Qw3#?S+f=HC^mS$VqKit= z0B+gdyq18`@ZuRH-%{)#xoi-Q_q+}ZG!uhu=ZQO2P8yMtfll*xk2Y!M{=F(N-`_lR z;Q67$RuU;2y|sQu5gWQ;SS*A6#>C55%7FQc%>%F>Fz;n! z(>i9J!n79kd?}!i=#c>5I-djkGZ)$_G8lJM>drDpN~|9AkkmQ?AooKge}a#e+z$#< z(Yl+tU`p@hVL|lm&*a&i`57mOxAaMT5qGJuMdMC#HF4qk=eajMIxHebh|NYJOrQe& zbjh=4@fmDy#R}E&Fb>F7ccpju8f2Q`G8Z0ubt5zXM%7@OQP=s6x!0rz9MH`M$W zec@Qw=Dd1lIReQYlvDBi$k^8a2WQ|shypSa!Qi>^172#4H#+AK^#;$wVOh;mv0P~- zE_0r*h;S?DP1pYg+J}G0Q)z11Z>+kKkA@oR2R&4Rv9P&xoIKxF_;w)qXf3rexieqg zKzq9gGoSCajK#yW70hbGFZ{O)zC!;ZhrAv1J{80R{i#`(LSay|RW=U`)UIHNWG@bz zs=7jLMf69-iCBn-X!F4>{?6BK#PtU=vuDrYQ#Vjv1e!)B*c+-b?>|dTGX2ure?Hk~8sXoG{Hyy6oVOUx znADR9%V_%W+W={>hVaqBR@J$DKwIhaUQzWBss&Zxvu9%i_NNE=6uI&1#ltxJfMdTIPPZCMeS1P5Fg{llb^(U{WdX)kx8_ye{$R3cRzcc z*e5`Le?KhBSDdO5daIXdhIX&B_3oPi%Zu(Uy;q?F!1~7bNnQHgy4>75p^(5-S$FK= zsx7|LtmAy>VY)+$DW6*9Zt#BW7)Su)$%`3EiJ?Z9ou)`h<$}=e>kR!=&gF@v8)|~A zO-Q~@HA95_r2M(>ZIb@sVbBEFuYT4O?m3K`oxB^7b#N7|=moux)vZAL9duAAQ}BBg zrQPq?qqD6Z4ZFJQ-kZ*7Y)*n62l0kgekX_vV0(Jmx3a~HZqH6CW_caJR9X|3(SD;x zL!3G52ffj`Lty+D8s>i^Z@)j5pR_IT-z&|2EebzUj$zQ)4j)IeLA+g34?Cp42`LjM zH>8_GOga+_b-xVZitxX}ZC%#o=efQ|dcKNv4vEuZt+S zN*GkL%e^TOPf|VblnQO$lYiL`gQmG~iwS``_=+HLMAAk!W`IX~;QauYZ_MQcs4vNz z?%7Zpmuk5r@~A@nb+v|Jym;uR<4UKj!@&N>5!#;->;6ifU1rSar%+#40ZhLS<1x8r z=Kqd#bMBW3Q-?uM-^UC1J=0|K)H`{VjFoKaloEm`wz?V9FWoztQaLkXBS8NrB&Y~e z)w+3*(??qp426t}ZV`G4<+Q$D_A2h^+HtY_>j>x}oD2iwwIk=Hk8OApew`u#`y7k= zJ{2Ot@r(@9v}UGAzMo6aZlS!JL|0+w`Jd8K(61Ctj5>7a1LEwlX)@fq$4Df zjLYk$fdsnDU-RE$R&C{0pFKM`BVhaohs_mH^r2Euc-xeU7HxXreC06I-K)~ZA3C}m z;$dN3qczDHU()7rzJbUED<@acDQ`C_+ zD?nTD9Fp(p)3$GhW63M(12gKwpCO78=~Jv2rty5GpU*L*sT*ZUXFxB3$rqfjrW;4) zRdp%}fADbr8?+ISKr$DAFH-e$>cVQ<4AW$BT$bYAXBI5X4yjU0uelc$2#@Tws35Q7XYQvD{Vp zmUqIv^wJTXJD3$o|685DEe?!_Vqqhf*Kg1(s$l@iYr>sADb6`urEvZ!EXnh3Ks%|< z=-Of~&m;*4SpT!)B=PU}sc!o=U;q0=pEnfSwV*Tq3!8_7T0T)RAyX67c69GP%<#w5PBm|15|9dYFF_|%UG#@7f*$W)98h0KSV&>$N}9h98MkLu z-LR*iqS2A3DgPFV;#~#SBj^)!%*%Y-+z_((Kl2~P4dt@`_+tB^C$6Lr?F~P>Sf$w# z=(TWk0R7*(ARgh$U{^q)iK;&A@pgj%z%Vc z)w@J(xepZ@EpP8W@=dual14pyC$Kd@f8`x^j}ZN_Ktf`w_dN{ymiF13lEpEOD=X`) zeqcY3B8%;wJ(Wq8Gf}nV!0I2>_nuF;-yU?L-GlHwpNBZ8)oygU2=8AZl~FqpZxE2CqxQsSsJLP z3t6?L%V2r&L>z$nhe?t2kx%H*nI|PD-!%lkX>=qS%TtjI&!R|A5#s%~^#3}>UINw_ zwje9khkIB-q^eUBZ()7AZ_JeJzBLDL74(n|wE<7+6|rWQUoJj;7%I9{HB!q0cGyg5 zN>N)`H5&!Qdl8B~c-$J0fmDx=me!pjEI}w@@q%+@TelP`G^Vetiri~?Qi z)z=!;*vxXZjX!%+@>;S5Ca-Oqd3BD!3_(?m{113gRJAJeu=v zjZBe3>x<1#OlOU@lBuLw*VjBbZqzt8O-qJtfcah&sK`Lt$A`&^9FgSEMRSdyqJS_x zEhV)z#^yAEDf@8=puNo?1VziUWN3Bf<8&e@QLi0V=xz-W4dscJDg_Jn*e7m2dougm zz<5I$CDeWb=^?}M4tI3FWk3|`a;y)IXj8TN12r&Ty+4r3yPiUi^uX#h41x1Eg)T9$ zV9hzhM)R;AIBzhEPuv9ab%>(@^?7)Gc%}KDs~_<$ilOYS^7oom1b)5RBx4U`b6~zj z5zvd1)lTvX5AGM`D~|<-@7J0YaSbV4Nb#Dl@^3v!(w{wo&DX&7J6XU(Blj6XmUFCF zF1!=4?F=W)uJ=Cw`!U&J9diA0u4#ga@@(1{tzWd{pPVCkyFNmnC)O?#>TAnXiBBn{ zZh`qe*WUy4)qUxiE<{6T;U%bsnvkK35e+H*G?wU>FG(Wl*C1Z74CRd5yCNM#6Rv^9 z_@y8VHCxPH>@Q1cq=$rN6$C+9+o1P-TpIBB>GAOQ^`<@4rDFr<1ameOg}$NfDZNpA zaXME8@e;o_?$6wJcv!D?H!T?kWGpit94t3i9nE-?hg&)c+OI!*CNIF>2UJ8$P*Sm0 zmlq8-6DIKoMCPY*h55wE2=ulj1NCKAIw^V_or40YkdfBjKQ^-d_P*5eCVaI}I*2UV zKkViHv&VC-2wXo@PugUIfg(+w1UUsgRAg+2--%>jvo)dpm6Hb{`Q*~2`BKld=M6;Z zCn7$+y#H1bh)C8?WnZt3)u!HUO3t(gmbdOf9yo8tI|Nl@#8jWffhT~|zqc8g*985< zcq-m|HuJL{;;kFR8}{f8CvcD)@HsOxvr(bRE~xFv{=a$f_)?Vx8Pi|JhdiBRV4#}J){|?v>&7|d&w*UP;Ff_#AHATE@8HyaNIs*UZx{$lbBacJ7eYuG&1e+V zNfC#Ldefb=4VTJm<}cAtzG!bjd1`bWH{ciF41FV2QxWEHsGDyi zgfK{1-0x>DEem4R`pnnc|YQXwt$)093 zdGqKWHtV0uarfHKPF+_k{Vz7>a+hqw6`1d97Zp&SMK@qFr4}AE<}`>57UV=pzl3|p z)*N1qCyJB7Lh{kHN>Ew0PZWo-s~gB8l9nv>`-bb1uXjZT5GaLvSxIYOgC2FYD)2mK zowRz5qmo!o*c|45so`)r7%AvitRpJZu-E~tcM6T|`P2T~o(zuuXY%nlYIxzL4mz`9 z9ydqU;Yt+iEydfvpod+;4xI0la>NRG@z;Ygqc2!@pZT9sZaU24s^CkFdG|12zPft5 z`wwHn*L_I)tde+h>UNMtfvYbKmzAL!O@$%)?_0BH?^PBZaQ(`4%aSGr>uJotjwJZd zzvZ=NMqKWH+F13fE&=ujhqS^k&D?+w4 zHIkl)$1ajKf*`-?W0iqahW#Drne4s<`U6Ej7gfK8q?6_1r8nv}4}#@!nG1M2aK%J- zF9#r=e`@X)J0o$!V;0h@1d_V*q8qG-I7-)W78ZO>vTa4E^Jgy{4V>>sf8()=t)Wkp zR=VG@xEt^rdPDT7CBrHMXUdZi;;jr6qYXYZvK9*77me>orzx=G=h>dUjpBDMFTRUu<`sX9)MQ2k3^{@GY?rmYl`5npjNKRQv7A66Ml4zuc z!LW-{<0QoUKzDyR>EAiVWK8%6o_-h!IxoF`%JB8!+i8xL=D!CSDR7PClU(|1AESnj&gbM4^j~IpT{Y#2<^94P&zJ1BYL)<4wCBN{8h z%|pKRXYWn44EQ{f%ggpU3swByr}o3`SYAQE=y$74@i%!LUdAIxJ{CRSFY}dk)S& zm%Y+k`I%b~FKpn$hP}Ve`mVw3sgGX^qJzql0Q6ae+sr0D!5LkPn&`8~R#XUh-R0=I z8mvx-fk;=3MY<%3KKW|1#Z-8f^<;5a5YJ*3r|aYc)&|a7t%#t=IXV@2`&*R_`blb> zZXs8*CDz<$Z`5`SEN{59T0&p_y;|SGms@P%cMDP>wwN5sonNk5fb-9k+CBW@cnvS? z$!&3?(yn%;!ZyNiG4t6~y-bmNW!^>hz5vTRGP?=f59jWKHLAEwUdc10rh^|9=?&V! z`ChX5BFZN6SCD)y7?TXuQg64@L^p9m=Mot|Nk+5og}pZI^6BWJHc^p{MFKrS)ub-S z^Q|qGJJ>*3^PO||+h55bD>JldnHXRC}hJ(^%@+LIIA zBE=HZ8z%~JMY2F8ePqzP)La4TA63>X!k%k!GnDzV|30_<=O;ST8(JGJrl}6jPGG#N z_XAOfVOHJH5^buz?rcCw+|E_cYc#wQ50#+KeaysbhCcci|8Uo2iL1UYp|Gh!&uU!|;N+Qcl z^RuVi44xMaY8T-C1ReZ>9<|B)6WzTQgTUvMr1gX9L7iW~eE+p&?s9d8woTv}PK(~wRHR#FS6$8(YTAY}X z4A(#3e&~h-*+YMesEDB!{L%HAvk;pBsL$L^?#tVo^E#vgog`9J&Xz|cyN!u)&QA~J zjAk$SR#6XeK=1I^9dI7A;gpglRLrP{3c+SV67wrOsnwp3Ec}`x58~w_Bp>_i^j^#E zR^6Rh8%xSS#++m0=KzigY5W?|WxLnnlh-J?ptpVz1GJ9`hG<89QBiYK@s<0Wk#&c> z5rN7ti{zUy+fKX?PuD5&@8X9a(34r;9hjT7<6c;s7u(26?_Y;B)lqcg=dwL}52xUK zCS%u0u9D;f`L&~BxfuC)N`$?|>$lK3r)Z+6@(}OamoVA~aSU{$Udo{Uh5la}5h7tH zDm@G|?$m@H^)$Wscwj!*$^Tx0^xyxx`)zgLUp0!5!LOdPY6V}^m$p4n@Bdp~yH$kz z8A|ka^at4+D#aFe*S|MNQ-ajX@NC2Z*PM=qkJheP7@y^dKrb(y75F}^x80Aa4mH&x z6q`beU?OI@Sq91%+;qJ{_WPx35YHz%vA*T_#E#8v#b5aMFwdWOfjLv8*j%>|`$pok zVa*a^&>M}U0qV28x#A=Se$&r1y_~~H9`P2{{tBxb8n^= zROj{hVXF40qvkG+2>SG!Es1{|2?r#gr){SStgppVC&RSO_nOq0dP1GR#afHOK|3 zh8s>8gJRx!>|>s1qS}g#dZpyfK!8ATRFg3Q@!C>IHv$ddSP0J*cF|KdnO6il@3>Gu z5Nx!S|5}ch?2mc&_DwhdPe@^Kj^4;Upy+y@Lb;jBcKYxLeoQstyDriiImCNQuA;rG zV5KJzg|#LTOh_EngkWsSlyBb2Dxr`r!iZ@=3Ff<;)d9{Ak!>86HCSg3c8g;i7!JRq zQVQ5+AztLfcc5rRg?RWJmbq|ETW^POot{5`d0cJH>s^ZRN0Y8A>CH!&XK zS=z_XzCp`DJ1tcXTU%~3Pfu8{>f~L_{2tKS=F3zXEW!YKjikE3?`L`o>0nK_xg32b z4vP3gQ{UvJY9sJOj>e3osR8}pjK+dQRG~mh!&*)pZbRaqHaFvLoU^~i+4qW^Rp1Kq3A8^+!gr54M~T0>pdU`QJO1YAbEF3&K?bTfXa^opmfS1eSbx zcz@c5G|3@_!vf|rR!0S&9}F9E!8U{$QrsSj+rke1L04}s-`uj^N*Ki62L2rd4 z6j(0_hWYG{$lLnSX5pV{NEX@FU#E{{J-<#2A3eJxA?1bUe@r%TC!9t4GUN72-Q|AR2n!h1bR)sm4Wf;h#Sq@4_#@618fRBj}b1by@Xpsq8o1(1%j7= z{YzMh$UkkjtH%c^+v$<2>;$LDnowXTOxrRwi>{}RZHZg174{9vlNlJ@nYL_ct|14Cu z=H5PgL~?2)kn1-dB&A;);a)MtDsZwsGK%(zG=~l^hRG8i@pCD}qYj%_(E1rO){P^E zZ05^m@~b@I!Er<3f{HnCZc$Fj18Z3SoqFTNW z7p7eKwE^_cCYhbNkD5-d>fF$sM9G^6ub0{<-=^fw)ZHr+w#)XddOUmN9tXhlt(~UT z5&P4zMRG%+gpjc$nT<7(D~8Q$6cLNxK!4gW$*O*|98O8!o=Urwc#u5l(%*=ZD81a# z^O8TZ?bq3~D3~vwChzHhLYv{*_Wzzy=zVHDL$rb46wP!K*}qB=!5<` zlw!*n(P<<;Q}}iGfmobT=F*pyP3Ineb^$8_G0-c{GXTm<#3SOu&8>WA5L~I_J{04_ zyyOIRlm9ZSV4&;^#ACiO#PA-u3_~d%@mjxF2&SpBI19|U8nI~VtId3xI3|Dgkd%ml z@*Wy6bj^n(zV*kVA-seMECOI$Xkv6DKaoi zmGiMvT8ok4Ii6{T69@Cz_GAL}&&9r^<-h)ekwFKKZQ|DtNlx*k>TG{hf>073L5O#z z67)KAfoj3g>4YxJ82X9*QlS-hF=>r@g@)bt6=k}m6zIXA#pXcj3r-@V*Ul*J4If%6 zvd73xj#;}z4Oy9Ph{4iZ;QIluN2*}hy9k=0CDA0 zGqEut3h`7lxMa@yV2W;Jr*zMCzgFfZz6~T6;hhgHJIW&@v*znn1wA-VSSyH^xih_W zjnJ$gWAsiZTt@)ohQ)cEf-B^tpdQx+;*~apS-~8q2*vtk8ZV`n5z$W0ggX!`G4Gs) z%T97PicURy7d?o;{k2-#`snz#(>GM^n1(W4s6GT0`lOMMU=Mx;3z%=UB>X51IW zbxiN_8zL743rIfpzz>bYB7csTU>}gtPW{rmPdZmHrR3(iVLOR7%KY+zG@rfuHQ;*$ zd@h#fEw zm2S3DEeUT^ly^MZpjYq){QmDjMuNt%bC+MsXN}z#?NI-aoI-IeiKgSXrU}m=9>2hT zeMEPO@muojzl}#7yQEl;7NcbRgxyyi!#osjZ?SYhZ-@F3cz%Rn^r_bNTb*Rbp`USn z$G|;54$h3fX1^U@s|Utw$qS7es|eeRy1OH^jxYm7OV46cb4RS_Rmzqk?Mk; zVBjGzf6Kb&za`ImOg!Pz8f8{As)cpqtZTOKnC>6E`Uc6DH>lgjNUL8}>g)5j^?;s` zHjsdr)W7V=X!QJ4fXH*L;Mprb^alEuMggWNzL0c(Yv-%J?3aZ;oQxuG-sf=)({vB6 zK|ICPs9)m6h6~ySGn7$kzaMtRFbz+kU2b?V9j#mS$ApgbzfK#7Jb!$5u|lrV ztNx~HebAfrSq0YD_GLVA^!vPIVhi9dU}`bmE?B|Hv{Z^Gzj=cx4)G$@f1p)~|C#^U zCp^%=-qZ*{0ecHb-nD&|Aur1Nu{J zgEwRbcbv8B3+Qr6@~OP!36{S2bAEK|9MxG6Pl6(|Q9T`foOSF&n61@BTikJ#9@JwL z-KAqS2_cS~G=eec(arDz{a=)F@nHoaaWtyz{W*U+!)3?r$STRN;nOO)VseO=kIMDR zcB_{}0tc?}!mro3C*2+kjkv)3n?PLxoR_=Dg$d{d2Ur2)NjU}A7n~RoU!)^3J^$O9 zZBN=I@F6RA=re~N0?z++eZG(^K6@J}y;EGZp_GBSdEw6JxDkUdfh~4RhONUUYYKWq z-%02p_jj&W_kKUL0A>AW)8%*+B`%c4rwV1P|F4zRaYFmgrAG?Q zs?e*&WMwBfEVt~ZjLk%Et!MAGA_>sHAXZus=?PpVq*6PQavIY)?GasGm@$}bpRXtz zL(1!=Gd6Hs|B|=hr6Iuy1^rJMo?eMky5{enl_w2zU- zQT%79p}O`Sy*N6lcR5^i-+gNW7*9%0s1z;>%37^%fA}%Y5<}o@f6fzFT*{+!cC~p~ zj^8-->@{#L0r|=lb2VPIZ@=qv-tNB%@{I|PMp#-B93 zxgutjPDEkkVjSAOKKGk)h@h8c^Zy=7+gHFNVbc@&aUam;)VHYC7IezP%PCZ7U_>;z z40}@y@pgF?=oC&W-)TY(g{-}DCwpJqW3*#YpKtdyAuXt=(OA#|EN}RKKjDSk4KE375%^2$2|X?Sc{j4xu$TQK@iQveUJ$Rs?j_>JG}=np0Aomc)P4%I7R3nWqvfo! z$dtHt|4-i(OVGoPt_S9WkvokMKGL zaHax$p!WV>hfo|>fMHsGYaggS-}nE7mP&hZiQnl7DJ~e4uUtk&!1r$GZ<1WfxnICf zQF|5@9BD-|E&IOhL*NGK1JV#z2;&72tUQXE z7;6+9C_c?a*WK%N0efC_F+hJ_AZ^{jWQ}ni3bQ^QTUdOEo&HWS^3k~7nzHl)n>v^F%F&Ov_rW%_cZ3_wB+at_MjzyD}egTP-lWepJumiD-EgN zeJb07c0n!63qNCXbRi*7Z}(g-bf?_VI3;Xy)nJ5U8Ka-zXEWj7gE*=OAz70l_ zA_~dw4x+g7QyhH!y4~1nS_KcVH^IsRoL^dr_gSusI5x0heBa2{7w6W@0^CWD^@s{_ zkTXEuPfyH}18);oCjoezBKj_rgAugm-Y|wYFVd@MypNDqr>~wuGc@2?Z2R_CKPet| zpG#rWDkQv@t;Y8`RWYGswZ@qPd0w=A1dhAJvn-#MBr&zgKa$*ROC0dmwBy~%9Wtz8 z{$D-^=bL&D1?*QrL$M5DL7ilqTlbH$sE3P_G`7{b{(7Wwuq+77Hz2BXC{&-$(eITp zMc?f2RK$Ct7A)@Je}c3nF}K zY5#ycEw#Yhc^ClpVtSl`{im=KUG+Op)AXCnQ)h@D!j4x9b{q9X!aqL|4j+NM&@Vip zTCIK#}zR%$#%bEbH`Qws)rE$u>px0Fx1Ta9Rmd`oUE+4y+x zWoa6RbdQ#u{3jLyn4k9KQ~I}0{!y-ecP8y0=RKd(qoJXyqIS8sQIU7>*dE~#0``W( zje+Y!FPHsj8nF&F_1TH`4WU#1i>u|CKEb8)>5VS1o_>O}$a7^c>*#RN60ILqsJuzl z*=pXb4LT%!x4xv1&K4OC_Mpt;e}K-%U`WfP(>>FW$w{mJI89Low8V7@^7lZsBKg@9 zPdYVBT!1#j1*i_E_=XcmX z&rWXx2Aypi|IbiG$%uer5gXunR6ayA>o0~G2TOiirP05o%bT8xriC0k-;QipHrhK? zI|C!Z`69FWf%dj{urthCWetAly=qM;SXUQUJ{{=6JT!QxQVrCLy~l?ZqFM1Opp?F$ zeRp;}Oy$0z(0;%&t|*O&`vTW7ychG@UcG*x{wJm8668#C>ft8D9{oo&drH1iZJ!;( zJb{~pnGe+7Fgrxn2xj^ohl`bRSAi(=v-aLy#cez$4sobTeea!3hXk-EJZA&EzjbWp zdCzm+y|^4KEl0k)tAs`q0^Z9yqEG3bo!$zU(1^9<;JUOUJwExkwuWqYhKyG<<5 zotvQ~e^D>->+D*A@2_#AKgL9cJ*&ceC7h`1Ss2rRk8)4DnhKzaCp(rTl~TWc_3()i zbwK^)*U$)SL(tEm*(Ro)Mh%kL#f$E4Ioe?2JWYn z_`6Q??~?z&2oWbfD4ZG&nF`LgBM$z)?M8q}{a0F>2RaVMzV#!j6u4+PO@=y2;CpFX# z_?@y>kB1`|=+A?KAA>(d_LO_*TYjS{;9mVq#=5nOWb@C|F&}tdW|lKweVdr_en;?3 z#yOzUwzI}eKJ7HMbd)JPNXI?!oCrrRIX#0{L zmxG=TRoYxTSg)&==ym_)U0}lk?XTc>An#n(<@#KN-uMvvWBIKhYx>X+AG_(r5CXJc z_;W!Svno(I;Nv$qz61Oo3uZLG%A-+1tD9qJd-T)uT*Ok;GIo+JA^QM)8pw-I$JIfS z`k}E4kv8G7T1qjH*4#aV`f+N$t?TB`?E@*>tEZU&2dt0UPX)@ir0kZZ&;D}U#RV5- zB92yH4GrP5Fq#6_8>E?ycuJOEgb=YOL98S6}^T6$e{IN_6>d&VIb>p6>Fqn|`{Z4WS26Efp*RAq3e}lOQ|IvUv z%)4c1nS2+#p9}g`vYf?jN?KdQG8S7BLWxOjD&~j*q(xv4F79sv$h%9?=2hN{sCK8W z?lCQq@)X={+iWL~eA9hR0o4DRa5IxvRi1KiI$M0LJ@cjtM-*DW58Hfgx+hI4s_I+D zE&+SG0oTCwOQ}|LRUnFl)0%d1Z6Nbrkf$;u`aNXod@_TbJSZO@Z8}1csY?g@VyRPy z#`YL#tX{6sII2nZFCC8hwuEHDaXY?q|7IuZ1lYIKR$y%KQw!Pp>=~i0E;*kGcyK#B&;U8g{H7B-pr3y2$k+h(ph69R^)v_i+&klQ$3wC*{V)^HqZ5TLR;sLZ5`Ip~_q0Dzk|A{xRf+{l99o*>E#^KAf7OAkTN&S6iTlvlO36(A^Nh z*}Gp`K4gSWIX(P{pgoiuLgV;1*h`z%1IFiz$;Y9xA9phQ#F=!em1d)>(tirem35%2 zwK=Up9wU1jLp~vsQfTy1=-;8oB!_Vv479fNt*4EAt{ZSy7+%X5QZ56bs41>|LyUl}Ng^4U&TMTe-@5J%K( zo7KZ6>TjFO-2(kZY#Ku1gFrKl><=Z1lq^lgKbW08xSa%OF zKRCU}oTP(G+iEjP7C0PcGrQxT^4}#V&YeEe0p7>KK31L6r8VJ868*;3X?UmK>rJE-F`Bj z^CJ;|hKEELrGzA~Y~f#11bLHpXGsS(jVT2$P@+-Bq7UqBA0QNv9*s_u8sj!PL#du# zy+(ozV0@|a_IwGZ#6fWk;7`4_nQQf^NKebM%9@NnEMo+Dg=sRhDS^*E6x;XhJ?})3 zuH@j08hCl9QLM+WJz3jPGRMIA=7Jc3W^YCzWI0CGhmhJT zjsWt;<})Myux4;0M5=!k+Tn;a#rhu5ni4Kz@VSgx%xd+HVjk>uoiS5@&MzIBHWatR za<3_ZGE&y$sZxOHj}#fZ92mJ@q`>`Gwk9K*4ePuhq*UNt@v*qOJ*C&tI5$EDFOS)T zoN_1R`m0B1HU#7&^2fco`mOY?B76I|BQ7j;EBoW>0n-uZMq)WRDBqIWxX@Yh4($#d z4}xxOzYg?L*DzkOYbT}x<{!e)e`TQy;CvEFo51x;sutpB`NCbeyyh?6Q-!uMP@tj7 zo$qM3y6T_|@(6U1eUy{Ui?3vsINU29VkgMkc5Qg2-w}?Uw;h)p;jjDwdniQs!1tBs zQtnu{3uFKPDy*E?({r$9PK&yR!Qlt*H!hY;Ag}dzo2Q!=O!t`bFw%C~l)>j1w^7A; z&6vwca&;DYde+$$um^!BNC`TAUg*T)WfxMo7 zjJ>~N`3_aiC%X+Ovy=8wQB51*^RM$u+*}&8ON_w$rNS12V(cbD@F{QkL&-;SD}7R&M-$ooV`@G6U!fr*9pkUw zBV-LQo;rSP86G|Vzi<&Q=DQ-*>Jft0L{uREXQ$W>B?6Ss63=E;X?DVb_o$sx4Hvzi z$VMfyLhQM;||lE=ojCEH$R;ew?8W&VIg>f zg9-AwVALTu*eOKBM8*m}5?0lEN93Z6t>;(aVdWEE8nvVR*Z_Mkyh6bB#tAerGWO*-HY0u+4S$9JTAw6N+JEWRqF4F zr4!ASz)i^x@@_K1O!QVL)x`IM*9!tTbA*4l3Y=E-uUmLAsIJ9_IW)a`5koM*c(poB z+%F5eHvf){X``<3<$^0`X)9a%Tj>)@5iox#lD^^+-}g#=oZ{M8^e%c4mc&ddz$oG= zFtn+*n-5!t*ahdCug3tM=hbX&!lLI`Gt3)|!O&LnKB6w2UF2tzH7szooPzRc^>4u5 z+3zM!{qFFk?$f``9yruFT(PB)Rez2aZbZRUfAvQEp@IHV3t3D~%9k5tC#bX%)JSv@ z%u+bgV`fTj6)*V!^4j$viig7zBKsL|3)Z%vL)sD;iP74ADh^{c3Y6z%ulT)sD=>6` z$3|rtGdbm_IF6nOSO5DAPV=Djlc}x5y7~*`KFCv^fG>G8Az3gL!wbV=92W3HK^tyK zOI%9YCbFi%kD5Gr^&&SX0dKo8A|3LL8=PHuS!IK~%#V+Ocg+$9?KQ6^cWKJz7SJX>+_#qA7WZ`3o=vkVB@-Y z{K!hZvqulpuwAp5IXXce>Rm#EU|B(u-cF$fHEZCr_wh ze(K_Wgz;tVd-`#@+BY*-_U}`Raqvh&`&VH9fnPcHpb*m|5o%SOmwThG$0rM})hnp< z^c11!oI@lu?b26|gl6>~G~PeEbv7t!drRp*qD&G(q}&=8?QPZz=jsv-v^Ie9U5lX? zZuXqyE>+fv2orJQ<(arh4g5O$J1(DacSU8W$aMqG_m`poI3Eb-p5<6p*tkP9a-94B z7FW0bwHG{A|3uSC2n+*x!`54B-5ggU%Z#+1q$jh@an;ySFVEETgg=nZz*PF3svW8#krx&&>UtW265VP4{Pno z1M-6Ll}Pe}F=;Y~V4%|k+uWP0v&Lh2Z${sA7HXP8<?sLM?X-WAlmbhNubwe5qry+S<|=qHccZc#RvxL zUXjG@)oX&?2F8Pt&zv9Jv8f@7*KrJ4D1V5f2b>*C!4DSx3KawD5nW9!(^9Dc^Y})N zow2<uK+x4k$r5iszQ>=vCg;zE+ z_b6z;>|s8G@@3)#{eon6YNH#hmDUJ+f(y+3UhaeVwGRDbio+(Ft>ezCw|fs>&n%nq z!l~2blcQoOpy**4T8+6Q7k27Oo7?@y2l`9JE|x_wN{tW-xi^c!8T$oS=4`{990k2i z2_hoA`b%iv6F6Vu$~|y@6M)((*W&MqiAN=q_@}vPdOg%{Wgl@Pe!eJX0?Kz~;0ISI zWQ(|)=zMVInu3voj^6q0SlYSj(2xjr-mB>6GuWFRqXyb*=0L0ZOYHOJ6^$5^kBFet zfd!{5h1Knye&$s^8b8G6k4UwNg-Yl!Hvi`@T=H@ZN&R?HX+{WV! zq^bxj(8qitMa(RM3JzaAT-@3vQ2!fV(XW1ck2Xr2Kpp5+^8e=SV@F3rE91-p85r3TCoI z#FJUhuf@rF>;j`v0m9)M>ON_@K)o($Q80>bgz)|N$mg$S+ttX|iU~{WqCLDOCdnbn z6led;U%f~t@bB4_AE|tsN_Ol_Iln)@86_X$no2+-gtkOj*mD{LVztKoyXwcL zAN>F3BjHaKf#ZXR+z~OeZ<4ea*TzUdAZ>&Ae3B6U z#^9yh3Cb0C-u+^^!4;ck*~7kmSnOaKL~h=#BKQHXU47ZM8|>m2ag4# zFzEXCIO=|@2;>fmTWG8O26LJepbJi7F(+ zBY=cAH2@pz^{$lyRToTLnjw?S7F3I21eu*Q&5hBVHvb3VA9&z=$pUb|@mtj0xy-lyvG15dLw~d- z^_IV@vFh2GYBUT-S(PhXhfd`*eVPk)LDd3?N!%;8aF?|JpI zmB8N%vSTLRO4o#>eY_`t#G<5ezy67u_sm|rR9Izu3G(LN57zr^3=HW8kh-EgMp>Q* z>Y#sK(i`SUgrlF$lZWdk0O!kI$^z;`rLpuJcE5jHqDtOLlf79X)AuI$DiMEEA0+w* zs28IPvO*wZb#E?45A1E93OY`}Lp=B!H>1Pq&1>ehh{0_Uf;|@F17N&wWB0`)z6!+r z27zW`!O*^YDW(8#6JH!Snv^K_WfX- z!_(2P`T_srcLXa38OaZZZ3%>XJc+N~f#U_x|0;f&US1o>C#yD|Uco%Vu3warZSmVr zN_sUV0bZ#omZx!`=^oqi#{NsKS-naYP7L30?cQn`M2C;T(NqN~IA0-I1h9Vy*Cgy& zC~FHb3DO`G+rri+n#BjJqy%1;2Z9V(zuB06;MnggTO@@j>deJ7rZu_4q588{#;x4h z8(uFt`hAWJ?BRR90Qu^F5YmTy?KYx*)PN$3P_h0hWZifZsGV}^`pnL~2t3kb#UH&62^H!WR3UG{o>Pt#(EkdPpAknM@|fZX4KkdBjYGzJob?&*uydtlf2WkOfujI>Arq6p z_}mTsbUD(i=Z*P5P%ck!6x}tP>7-Kn)&hDu`!6V;&af4`fD<^cLmw^t8QM2HP^y(y6?kL7!CAV2qVxo>nLbjvmoLRd~Jau)0yGo<7dY7zdu*zGmlwvds5AsyJ)s`pe%CD`jHe{&y zdIF{Hxsi7ID+yVYX8dYketu?W0DE>qpMmEKUTMRY15TxGT6g#MdYC&iC#7qBO-@>*|Hv=Xz*LNTIWy*E(c{u~yQ;-BZs zT$OOa2DxN z%%vX5cJ&q~d|e%m*+xnb$*_vqVY+N#EZ~uwA&sm?k+z?9q);@N7}CH9DmT_XHt`X; zC^;!g2R6B|fW48OW#Ia#9z*TD>FZ|t>G^^kfBCeEVBlgJXsqzDcn!uEl#c_3HMOnO zFtZ`oPY}OnITxK#T;Vy?veNlP0lN`X^p$-rH-vV_89lR0kT^O1~SNt$nu@!<^68v^QP6pXRkyljA>iV zjspcQB7=gDOFtm?6Fb;rH-iH1mmaVjTk$UtMNm19Uy?qy*hip6ZY?V&&{)xUih;Zt z%W>7Kg#pHhpP4~_Qj?4S&Nd;8b2|)5T!zV>NM$U`a)Lb_EN$TZipW`YUbA;c=QL6$ z#WEk$IZfUj`wnKn8t3;$#e%&1f5UGzf)g>3m=5ikkrbF^RzBLkV8JU;bCRF)!SX|^ z3xPfLpY0z(;{ozi!_>!U!;s?pb9H#+ueGJEmpMMRCg&2toIN0~@>$uu;|Y@$G3UKT z0q+_T<4;Z8)jmU|9)As*33Q77$X5?8B7O$s9i}aEtEWXpU4M%+nOMGJiaVqdvAo$M zdhqbk19?*Z9jk2d#&Q#UANikE=gHg9ect{aL<#mVFHssAP&_Gk^?tbs0rj<5GG)o5 zUmW;sdfHkiP3baS<`72NrxW5=UtlUhUS)b}cGj>c&0f3lH+4?0mY8@VSbXFi=2ony zzkYkrj_@Mj_FlnM0@qvU$4^Dd=<^V|P%(wKt{X#qAqQuo_}s*@c@Rt>Z=G)xmajr> zDEA;)Z@wgo^S%#ryID00Q*H&tmUAqoym+4X!PsVhAsU0rztP!%ipKZ2jTLu;MVPQ4_srnEJi5 z?{6ej8MBu5TJjpXCBgYDEdqh@petmGJ;q_FG>X~%XJM8;gzxQ#73m93hVNA^a-jAG zP#GR1u^zd5uv<`_Y3o%cTDh@hJIB09YhT$TiKH&ZlmdGM>14nIPo6-Zz6>EO)@Cv^ zIfQKrf)&Uw)WwEE|9?c#9tPz7wH8UDCs!aXC1FF}b>bZ4ht)mZtWA2a4Bu=;&wb7| z@#@VGTm$X(q)@*!a2``g_sz>>e$u$Diz4Q1vx>892xs~S@;KTSpF%oy2n5;=(gWps zo1gheZUeC|&WVCH9~~CxFJ2VE`B(`Hfc1waffhgY+Njp&ToV;ldwA$vS8N#=DZI59 zGG{<4v+@@!mK z|3@Ofw3d}!m4(oHaOj}O*TIJP-5SV?-6tg#{v1l>9*O(QIvCvmioE*6Y0#vl^|lQL{Nzsm4OwHW_7q+5b1k{>cGb7SBt; z=>?uQGK4fv{a|O`607{GzcXxe>x4(*?5AGH$Ah+qGqXt0mTLg^oKe8f1F}93>QX?E zCy>m*s#S^pbn~B|Txn=*N8iBnkb9cZ)*)X0Rj#v0}?v7^#i`hsFYXvzu z>HAj!C+uGm$iw2dHx_J65Z!O;{ot?a$x2f%h#eSddW6kh8iz*jus#0jm875pUaI5X zm`CRD;Tcr+{vxR~yAhtU_M_7V{>qLeuz%9DLu^OZ{nud>^Fr3zKXU)5LiyBqtHbSt z(6%Z=k*k#tX5f5@XHvj^i&T$hb7n5d*uacYEb~S}-H;Vj9`EXIU_0r8(|%wNWc~lY5eCYKF@wT6zApxgD-xr3`Iy_h z?UgtKC)XA$6zz(AXgRks>;(3R>$hG&`RsD~hwvle z-=84vrqkB_z;X6NR8 K$(Slw+r%m6xN8p?sl>rMn-%|Zdpz~sMJjnt9??a$!m+= zbWWMh{{r^L;vj(c_YI_c?BC~DqpT)yGIvCixo9_Ksfo+ZYJRd%0lvS%%K%9^eY;S6 z>ihPk%4(y>Kp-)_1ij;pXLIu87@}aMj|bS}nsEWv)1Ddsf8yhNtoO0_f@YChOQXT_ zx2eO}!a=dx5Ft=LIi_`8&8EKhUdMfNQG9se$u3v4Ee51+^@|t5L_fCSp1r|d!e2HL z;DVpLpg|w3PgIL)(dbwDwR-J{&uJdE208p23K;LbGDC#D*iRJDKJ<`hejUU~jY?1s zf4dw>c$D4LkunPc_X7X24h2fO`eHFDkHuf4FrTe~`?+JuSRm@PoO7@ICp))d z!?t2})H@QgPrmNjy=~3X`GNtj9%<+SFyCOy$-2j1vUp$X;?~|l{Bq!vYU#Rse_#5` z@n#B?Z?dC)qf@eqyodxgvX|hdiIyNhD5tgITK*#}o{Z`CsX`DqAAad2aKC(8nat7; zt1zN%Gy>-h4;QF`KCt&8c{IIRSm7Mx9eXfPGBQ}}@!b@*dNHi}SGK;9MlphDF1qTn zj9Q!}+<5i+t#*O?TX#o43GG{knJyUKHx*=RdTWJZUG$B;`lB7a79ekQJ_6IDO~+r8 z8aL{*$-gc|qfxJEo7V}B!U~oQZav`9-#FwSm$jb~iRSZwv$FoLa;bfLE z2(?9f(%Cw|^L-~l(w^FnJ+3!z+mThKiY2k{CB06hhKlv>5W>{9Vw4zOJ*r6zAm8;o zM^=_Q()bETqmsYI3FST1xyKs(MN{Rp+E-A%&$Ms~Z=6T*yr1%-=DDm#4tgKOW8YT^ zBad+0@M8A(Du#mdUEn|i{SQ@og@aS|rX;hI!(QkYd_~f`(pbnRBtG^l9ZHa=DnCeR zxtcLyq2bO_szbBHU5zlpg(VkM`IhBD{!s!b(>XGA!RNT3(sK3=R6ld^eR9TGE$RAYZ>q}1&-_ahz z1434+OZ}^nh^wWb8tcR;u!o3VDgwGbLW2vY(f1-2%CghqhDt<(~b$Isok1{$H$b&6QE5KA;$u^!* z4afN)@7o3Y)>*O#r*HgWsvohtE7Cs^?9tag5Q5qZbLY^-yc5yL!0ad$gFS+kHh5gV zy~%AU(d{M+^74h}>;k=$$ysa}YvJ3Xg6E?a2-gqa9iy}M!WmaJ6~(`L*Ppq7{`b$l z`PBILSeqdSfjP@TzI(FKqkT41jgQ1OlmW=I;lYr2VhYPrsqFiFx&26|WHQpnq_1T) zq%FQrD&)$Yoea)*-+c(KA297YRghjO`VEaT+}x17IopjX-}FA?)kC+4 z2G$?67nI7&zkd1rQSU(9JFZV9<8N2fH(cW8CB+8j2e7&OoF<~esVwWy*n+q6U(2Wh zmZA2Y`A0=_rZadi;ksTuM!i1Z_`zZa>D>7I%x^q|L2xq{q$P^RjCVnJ@FM68I0Us9 zrO}=aCb1~=gjtwX5J^=wTYD>d5vs7k`_bwC-iQDD`K!l?S`K(}zf*%Q$D_U;N8A0x z-8!zWe7CB3M5FSuG~WcgPd8wY89m+Pcp;-dMXhlbF6nY!gF&jZg_?3Y9mtmZ%i<&* zeEjUc2?O<0o*3IV8Zm)G$9Ah|A|G+QrIx88B{uW);$!>ZLHWo+C$n#*!_k+sxA_it z(}iItf^iLH^0HNHZ$%NO56?w1!QQYNIZ$7dK~oRLPu#>Np_!UUcz62lV+(^)Hk(6s zhhPNIU*2YV~a|!@^Gn#^>p(&VosW?55zYm`3Nvv^0Amtyq?3lQ;`GR~C@xyMqPO0gJ*) zh8V>xUH;a9Ul-5mTvcd@J$QtvtRk2}GY6c{xRC>xpI*-T6Swl6#-PKc;hRL62+glw z63lfp*&QCJ0MC1rhFi)P#0~^D98PvaVNr=Qf`gTmPHR2f936Tr5z`-UUOjaU7+`$q zGLEZcB#tCaq2V?SOttkHYdk^&l<(bsgt<{)d;NtGy*HuD<3E|DT*o}C zb6ZiAVI}!$aplkga6X!pRA9fn+P#m1n@fkklcg-(GB$BpVo)iejEJA^MLf(r$a56^ znR7QwSRDNq-wb2b!mQH9<|{?PNis_NU#nw7D}~2Gu&1)74YXH$RKNG|#l(W~j4?_F z`*E&%ioBbOC-BEi!qrcZ2hZjIhHWtL<)zFHK@LJ9j;`ikLk=~zRs=NOpu$gt$=B@hVQ4v!I9}l%ap87|LyX>>6>H5~cOuTu# z1)LaeqK+^pi9~HG%Kq^&8m*OJuamPCnEz2saM!@?yE4HG%eFNUQj&>pm=xS>8^&)k z)<=Up{WSmXw{oGF8;k2$)fr@QjU!6*mr!GBFEvjzId*nMxwT+#m!BG_CldI5)6jG} z!j_MuqBfGOA+$Rnhc3vYfwy63%m#Vo1+zsIsbmx)iL7*Y)eXX3Gi)}8JSEal@bp(J z{CeLK>%pFr$t-ZcL{Jjat=~}U-(yDn6jYIjrX{j^cWFRy+$RR%4f1|62y}lep1-mX z&~*MhOdH7+_F-x=buIb-FBp7%+(j`+Zw7nc;n{%oOmWqlOc5(`HX*X{lR^f?nQq#v zK^uy$y}g4KV87Yujz8)T)pciVYcGM^pN8G7UNa9}FMbEoo#l89mO@trubzf1Jutp> zOI+6ZQdpo8Z0pB#LyV~G_{*+H3tgg#^A!hx@-ul$MGQOTsSkiP{G9Kp(znSdbBm+$Nu->n8Aga8r&) z-DU~zid+qz;w+mg=BuOohQqba`ez4w{FDrD>f&nuc5?TGmts<%|1X8o}HXQT$+Sy|`$)uYrT_C%{FyBhbU}bAgG#^r-pO z%Nn}`@@=-P54H!NGqi5}(R222BF&IY;~Wxg$Dr#KSpa!QpXj|DHUhb9=?#KKaw+w- zeNgEARLE5yCw9mpbEhBeJHYv1iZH)}@|{VT{{MTUn%eK9?0*STwuYIYDrO_J*I*}Z zY6JZxIzIvy8;y3F3596R_3zLfi5f)#wE)!^&)~#N+gr3i)K0Lcsh0%gv)v_83DKW5 zxTHYc&@z%=wq&e=$?{e=(btWn1LX@Vk0tcOzhvyWS;U0mi?H;u83Vf8w-u#!j1rT&HL11`w(msj=J0eO}xkuZelbzO`<_Alw}` zEJNd2=G4J9*6PQ%_%B4(GZOOXt7lF7-}Q`S@Eb($xKhC$xaSC4Kp8|Z&wab|z2 zrc9JI>(-34FZ5w`>)R$Zl^+(Kcn8zB=YaW~&)n4m_Fj~of%7pVt9-@H(%s4*zpzoXLDK)p z3YLP`QpncG1-%eBA6^6f3RXDe-jEacwI9NkJ9RHQ1(tFp}k;la5)?B zELDD|2bnTOi`3&-qtF|(=-neX#-Eg<`IT2`g1mDjn}!nIxO@>L?|Ok66q)S9aXdW? z784)I=`+qX)(-ALus0`p1w1c97=W*p-?`t-tyt%~!_c`RnB zO8XsEmIpqonXK9T&jtPBkkg17Ls^eG{j+QwsOIBfFIBD=sIPf1VHTS=kfy~mIbO## z6hHk4nCOp9R@tz)X#sV2h_YP5Q*L{5n>?<3Rpv>-dMwG^{+94`^5@UD_#OcmoC~iW zw(B5pf15~ZWoY0(%{Fo!_zYcv%&X^!vw0Id5O0eG7X$LR5QM*QBzNOwYpBd&+e)9sN{ilZEg7RefuBg3 z9U!la|FU{zm;davG37`48=hxr$s0R)?T$3>rs@Hkbk8@jvtSQ0VhtGYoAWQu^R8=* zKJYv^UWQ(IiUhU4=`c`x>R8*A26?hhC>YVpXkUWJ4lT<2+8+7|9~-nWDujY6tyaZQ zKVa}LfxY@&RiOUz36_nAy*H-n4U3jnW(Tb}efgi?zwPntYuNd-Kprgw>U79Pbh5v8 zh0E3fob);ArJcybMr?8Ujx}CZ?~nKEU@z_SIqg^k6o#RHp%dRa*)1U7y$dtYV^mPbzN*5m9g%st7lm?5ld%KaV4zF zWShi2D);4%f4zE;E8y=ZicE*O{+l6QlH?6SyEd^!yHTmQE1s4y=qI;S0OhlmS{2f0 zU#V!t$+w3s7l%&391_TKJ-Ml;!2iZtr-QMy32rYY#y{Ztgd_w8d zUnM@Skr>ILYX2~J1M;~4>p5sQYu{xOOJMM2LAqc)`mT==s2|uJjMz3#S$>VHD~hY7n=kGr z{}{}~4(J*PYH?^mo&#&wYB;1Z3H z3+_XcrG|~dKlc=O`-Gv_(xHI7h3t5;EP;I8B>nUIUmS@WS^ie_*)qR#zU-JUOj;AS zRlItQoixDt9lP&wQm(#}Q@Ioi-`qD&D02N>_uCr3{8!^B@cuqyrCZJKf$-ndwY{G7 zQL9i%L^1GGO>gScyqf9Eo&8qi_Q35G`u81}k6RKNVRDy$FVv9nr$=Y%p7VXF*JP!` zcxV~cX9wl$b|2Q#DZFj>c{9iQE#`&sxPT7VR60&UIWcJzC+r&0{nZ;-K2_{HCPIX~Q_O5PT^BfD z&G8Tu&d75J&S&)dGcf+a;mlG5)Sh1(R{U`9Q>d-jb@rOMMsZ>HNFoI4o30uiT z|Na$f-h{@VS76HQ|9KAfntLFC`FN(L^|`^OmRK$h`fY}l^PDGN>bXE<@!*B3jS(PQ5ale5cbn9a zX9I+bSlEM_$?_)tHr#eu0wC{itLO74VK?>@ViS*9VrQO~_KA`M#zT}*Y#Nn~SPGkr z8?XoG%JL6%y~S5?d?Q&1gvEViH{#H~f)m@vcYJ?^-1PGG$1TX45BeHx?W|_{HR-XN zP8&a(m#Iw&v zXG?aPqy~9)CMqLI?tZr)#r;XFqT3~#+Q@GLn*4GKV7smmTazb`U%dzsHsJV$`HjXe z=Ob`ppzn^%9p$dNF_3L^H`bJt1#~8Zyf=meH^a{j-3Mf@O5R+iceH5iNdisR#CnEU z?>wythRmM9`92Se0qYN6#{Vntk*k{GsMu(YhE|C)_C|Weog{<@rCx79Ud?xtlr=G^ zc-tP%h+lA}5bd!C8M%yUBlXY$`0B1myv8srzM#bSn&5lc@xx(Ipyw# z>WY%t!RJi<4Ju8)Gmv-YA!#pK$*gSZh+N;uz{N@&30K@(z`hur^b|8nYO?(M)x-WP z3Os)+N`a`>jcX0N^*^+n-|UDTi0jgeMx9pZ*(ShraOtEdWhC z`W?#6^{0r&Fij>R=l4#6+Z>SR+w!E*N+F`6!!Pj*0ljoa3YAY`*tnKRqR)oUWtMh) z0vVhSpHu-@|Kj(*<@-e!LCmc@j7IiweXmwbq*hV=IZR{vZ7|4lT67@FO1aS&ERIFm z**6!k$EDtO@5e?{s8_-_ge)WD*gTEh}ss1KDfxWGervN7II{uyWp{Tys&k-CM zjHgg2kXI|@m)u)%HW__;ZejP=EBiW=hF!NI3xXtp;-)|eZ+wC^)0yvSOH9 znA_1nUhCS@oIH*vR3UX9BOSa_6A61M0&qSYH6h^rfWPkx13ucL1(^(KHdu!?4ux2B zTp<|UzuEsp3)CljWJvOiMvj<^_Vl67JcJfb=mab+acg9wg-k+gR^0nN2*IAMlLpXV z3UF{x93olPl3L7 zUzXkwm)CoE%+jsWU0ilYh-WG--tJeiClFF@3#20jdm1gPK>f;^!U>gtLFl&`>zMde zTwAUCaCMVqX471|w5TcQ`1ya;M(q(ppNgW#JIgnkO74vgDo6h2n)!p#Zb9+tC6DMW z*c%^606eUDcH86CBy-vRlHB8@X&hxZ5_r~``bFtyD`5XnaxJFM_46eUf2W;yJ4dV3 z4>p3?I!ZJ8L&d#y65BdkXbP}LIL{~m8c&(09Cg1XqO`TOp9u74-mu(?vk#C{5$O+L zAmoDb>9Oz6MAx|MVmlw)<$umB`3CoUk!6F&SDr+TR>67yGc`5XQx78t#)IE8W|f!p zB51vQ4Mm%>@zoE$(8g{^_prR);Xr%I1b!n*$>hVQ2;+XG-MalHp;(jf?B*MUiKRv4 zP|#flLksqGDThg9n3!|y{e?(m29iGlt926j|?KJf`DVT1Cib9XL}xt+Wh z)V`OHRNAZekP;|Rqc8NBi;TItoJ57oW(IpQ3Kzh5FX#2)8OHs4?p{7JIrONkK-iYI zUA4CF3C2O*0La@kWyTh$@{E-@e`Dj%9E<*^)Z&gS?>eBHXg`rN3+5dZE7;@H2m<;` zeSGeJEZu`&UR?kO@Z7SOv0ApZyv(JARcqNT+gLW1y|ip|*;=-}?Du`{Q-8qs^E>yP zdwidKeabd`;XhXtTo-o;K9>p1&-05u&L-#s?{6qIdXdQcBC5Y-xkR+KPFV*97KU6% zp50i2?#LMQ(kgeXU{BDS3z%a}5+|W7Gn-c@ zzRJlac!VLLqb^nm9~1+5b|i|H$1G&=z4ZluESb}D+uF9auTZii^A-OZ#po`md$NN) zcX~UZybsfev#?50RX8ZgN(>5+)ho!>cW;sQzifcfL#Ca(DmlNz=w+sREjkoKL=wWFP zK31VFIg{^*%{?$6W0S%z_qKOstwH%@?L==gS6}T{BBcjBF z8kAU{bAdfCFKEDf7sH=|-=w7X@ki0@#XH(~1^!vq( z7vC%SseU!|U8oT0lfO@REzIOs8j)d(4;CX_!2EuICiz?d@3?FQ{gAWTajK|y30K?d z3d+d~5rwIFweCCd2e6muZUK1oJ*P+$E%Nmf$RwuiPj+t0k~5aB8%bNYaDu*|d_mew zO-+ne&&F=0>64uE?-K$*(ZNC%WJnT2_-5trZ%O|EmU{~a=^ z#72y?!c|BPZQ9JRig(CwQ9-b0gEIlF7hL95Q`nf>Ai8k-M@NzS!a9DNuWH3)`X1Qb z0sAk#@-?_As`A_J%#iT%<3V+!Ej;qSq+F?HMHxT+|5FfIp+aB}W*f2_R3B%zVYlgY zyA6jB^EdUy$C65O+mzCp3{ZH<4J)901~|lJu9{Slb-HkKS0C|u?%5qAXqe=z^*+G( zq?bCRb_j#LswwdKR z{@_)5!=7~)4)Xrri3y0*(8tK?A+?FYAv)NwB9G8vyjD z6g0(pL#vjiRML|dN?8>_TBH@O2P<3J*g$PDFT;oon6E{lKK@~vtkr=)z{i5ZBWpIo8XTapNHJZJJ1zm`tDH%% z{rK1XQrmmOlUd!HPwBhj-1oY>fIfW%WSgrF_Iw#|zD(f@V7;Fg@za?0l4AVU2uXNV zm87XdTc$rBc2DlCKdKevv8fSShYSxioRAlu?KFvl29_w)YIn0h~|o6RnHFjz@IvE3Zlyr?bCD z^M{IMhDfP@4wg~wR7w6&WA->2Ci+oP&Mk(<_=o$q zJD_~7%IPOm-*yxOu&+#IZ{U9JEv>^Rqsmr|Bxp36@d=TesDM5EPvMiG_DA|>-RzmR zof@mc@;I=VXMqyq4toTFhoE~bp9SPO@3p#7dWI>;u2czn9tBa?XD7V1GrWZ-{%P0P z{S(Q#@ztZyO9bkpmFo7hS4b+uBsNEaK|P<-nhf*j*okC!+_Gt4zP4l?w42xOPMBiRYhcb;bhr59OWN= zSLrj0ext5+{j^T?5GXaDUX0e{8A6J|b_C;CO`xgY)L+g7m(0+*DCB z$Wzx8Sy-TZVM`@ZWr{OOzl%tS;r{Tm-XcpvE}FvCX65D8dmBa-0cwA+Pjelnh;}#a zqUxCrw4DL>SjG3u%4B>iy^g^Aj~$}F>~Z%AS3C7dNLiQVM3NCnrVb6Q-YU&X%3e-8 zjolEO4^tBXI8RRdh-a~?+>-2irBg_)GV7+k)g**WqwG{JB|i_!$HJqXiXyK-s|#(r ziyd|)b?Lsy{wo-TI915T%AO}CL+sU)d|(Iq`v+p#h@YA{^hC~a>Fy9#GIK8iIc-5G z{{R1M!vn}WMvh>qMK5Sgu~4r!Ctc1HKS%tFAj-n8N3MwS2w~pa`s#&O83OMIf!h|8 zXRah|2$O+7_5A*5k}mW;XUbci93JjnkQeD)cMzD3KdJO5@<{qaSk~H{<90)hu&1f+ z&|rm~fs>CBxV&V_Z-Dma1!;Xs#)Hf_DTv+kf0sa)S+wm+%c(xt4s) z<$0T&P=wA4`0J;>KWx8HAXB4BST6_Ji*B2MJ+;$mU_1|^Z>Bql8!T#PT*ea^O-64d z`q4@5UxcXL;zw_VCr~#3BNZ zmxpbwAABi-AhFT+?P)sebS*twH z7YZ6PL5w}>zSbc#a6T%j0bqW=&`Gc&NB8`qGLbbYAmI~j&B8VDC}Jgu?JxfV^6pP^ zh&PdBc8-}CGQO1^d|0_26Ibffb0Sz`e}0=XR`%N*?8S3h0ne|AkyR2)wjgf;!TorS zj!AA^f|lQ>{e=V~P!V|F@DJM>oZa_L!-gj{=DB|7hcNcMlZMZp_`TZK)N+~D()H@$ zYdThg+B2giK{6N{)LSsIn0MO zX%NraTyUVTalYTXqhc%ynR@j)UZ{ZQ=M(A*s{nb#0METgnp;AJ`R_=qOx`-@ugc*l zaK6eI*thQZvUlLwt(uly6P%z>CHLkcU{?L7H}}lWo>u*!zfnvhwI- zCGv+5K|dr!i`(S691flXR%=FrvUlIX9^M)>FyEcumXbHLf*~pJ`!R^FAwSmaQq7{} zvQj77d^`?%esupxn7f_S;El$zD@ya;AB2jg_B#BPw_k+g+EK83Z#4Dl!R)u!gX-gQ z<%fEWx-#15*-w(W{faE##v|f!f)vMZMHhkZnMiMn=IKOf@gR@)zWz$wZX*1?UPirX z$1RPKRa$YEYMo;T&eyE#2(*`)is*ifLfchr)Y>Y%VXm}b9osI9_UCFCeiL6%zQeqN z1TjMCrZz+xnDdU6nOM`8X`EsLeU=Uk&d9|bY8rd6mxYfG^atB|zR!^8XS}xk>2;C^ z8tRf~)Nliz3`Ae>ZoEOBkXjn6xTOA1Nlw2!ycjA*yyNX3!?JoVJig3b_zlCk_YPps zcsB-kehvqrtrH4m+B|8OX4mam8K_u|H4eihegg=e!1vDWC6T7oBkdF6x|lP;87ha% zd)1z!HOPMxZ68JBiPVuAy@qZ zxX)0QQzAU3dF9c!mKa~$OtYC(A#2T3XRn`+*Pp#rT08#p)$6ad0LBlD4Xq>`mi6HX zTYX2o>VCJxTk<60*fN#sFF|iW<=v0v>bj}Y6qB6~=UgetZO9kYLse^Q#Lt#@rgeF$ zcBgg&=lc?o3*`GEB?T?RrU+M6j0H{nn^5JWoyq3)8qL@U8PY1qTeUsjh~W4!Q}hPv z7A`vMgSS``L)0wfZXgQk z2vhn@9?0uyW&Y_SAFWg>D{N$tU!nL#dV)0>_Im!gG(!lzT<#l*J2)RAC;0wp=qmmD zwE}k;GRz2(rzKy5kbiTo_+$StHp!WR`xe=2*Z~l!vwO49uw-!dqK@!p?&7t2wsKrW z-s`iC!l)EpV2{_M0hpimD~$1Z8yrApW7CyOoV-u&-p$rm*Ji$D@m!1t<&%I;pRx2& z^HdM#P%M^#d?JJs4H{TZcbon5U2RpCRJ`09>~)hP1LI|0r&xK08iUmL%TA`#HwQ=D zZ@14}9=Khlen0{DMPX%=#-wy!)W>0mq1BJ8Hv$}Jf`*fI{;gdL^z8Uzxjw&o(33tv zp!cmo(9lntVljop%aEFVK$VO`@ZiT+`+9=6CkDWLXyeU@NxGv@b0Eoi6bF z7SpdXY}F7bJ?6bFC{*}(yt&rfEt?YO&o?BvlrNGe$AiG0P&XAYpQPT1EaE~TSYSq= z{03X-&uj2pkVq&Zo{gki3kQ0B`#Uf)qeC9V*X^1*x=)Q4k`VI(J8dc`x-1oUDNF*+ zL&0DVUOyOEU!t~MOBq=pm8n$=TDv!&?;pDszf~TdTy!3#0M2VG7NzhwVI|Q8Jyz{q zm*r2Sn3L%`mb6cph7&6th5+#0-j`2IXd?WpwQ1Wzjgqs;19 z|EXnR2$awBif^A)mOL(BocSm)weB(}s@K&cpQ9Ibq_n}&xkQ3I6zt*rk^uUv0Q4`Qfk<#Z>`f`4ev>WSk>|){)HXZ=zKHdQDw0|? zE&o%PyKKHF1NI|&S4;+pTgqE`JqcTQzHGm()GCZ_{vMfIh`d_Yn5f)|6$SQ&dDnq_ zpX=fmPJ%bHiJ4xWcox6CC!ao$$#LTs;}h5b@`*W>B0}NE?@ipREQWtR{nEBeU`4)9 zbg=i;27|aBU4Z4))5`S)#$UB>(4SlthaO2LIx`E)6{HYo@g5YGZar<{%u7M#by(kz z6{I9(X{UbUFNo+>Mfc}cFz&B7A2El#{InC-$YByVA1i(#6X^X2xb}5DPBNcM7thA_ z>lS79Tt?QLRB$YUyJwLAd2ox;wCT9f7SGlv>$#wvwc!FlYeO4v+F>G_zB_yAe zk8X_{YF4MJJg1_%3E!#We(yEiC@Fk;^}MN8fcov;FfUOlqWkBGr7?}v)7kR>XQLyW zZu%QpQFXxmtEXU7KD?_$cDwIB_O}0CB!l*a&`DFOTSC%d;_?WYRACCi`548ifb$;H zWcXy|xFh{Dm&iZ=j7#kUii znM*i<1>Z3YmA=@yxC~grai2x1i%2p*5V<6Emw`Q& zX@6k;H)q7>^QhMJU;<~bz^>A%>Qc}tHYB^U{q`dPus_5~$#A-YqQ|_yfwUo$M^E9PGg@FFJtQUrW+lzKeaiV7+I;YE{^+BgcEroTa}616%LK zs6hE}d0l#1BEKJB+o*S1;VK4ZY&xGpmJ`{DeNJ-~W>FZ?tN?r0RmQ;c*Am6_yWd8#i2oOhSzqvIgCw79^%7|5^+mN1Z2h~1^@F^{J&w+>W# ztS8yLdZL$-KzsQ%5!JYinKQG`vtUGh2LE}_JsKBb;bF93wpR$0??Z1+KwIyY+b$_z z610jG8eh<1fK z*XzWKKx9Fw2At19*#fxlXc=nXL$NW$u__*obT1fKCChF?GA=@}`Iey{*grM>rH~W! z&D~@EOfCqbPcvrW_?wRD+P*xaz|$LJOx|FlS8rTi19*Nkbtoo}1Sg-9;$=3Ig zxPVbs-L%QN{v=X{=!ZV0@!uK0c#Qd~KGa#_fV`TX?}<=baH%sw+-4*iTuJI; zE9*%K3Zs4~?r>k`I_MT&JxCD)VEp~;r|}Z#S8SC4qh3=|)lgTWyyqR zCD1CJ$mbvn!S17(Ru}Mk|1omTB4K48x6$SNII3b2v)&5Mhdvhr%nu|@w)s$zV1_r} zC6>PL3B?>z|FOwOA!pVWjkE~zs!7YRrDc&wzgZ;0u`b}uW&K5=i2wJXcUbYjacJS% zXxI++2(9aLK;>nDVITh4nBg8|F*y9`it5Jg(>FzwI;-uU(rv(bw=<#FQ?~eTXKpF!pRC;{tok(Ly%NZLrF_-KmjO)2#oJdebw&?(-(ndT ze|cM$Yjp_k6upr9$7(v~elt8Bw5nR22EI2Xr;X4oa&?dW_@x7SAjB#Yzg2PeR-ew2 zKuJIS><8(4oj>4w_zph6{#Bm5IJ(8H4o1~OyG^NdQbyWzCIQN~5~8Lf^#$Ph>9J`y z6*M^z4QWxk$VkRVQuPW2#s!lkTcwCf^IA@0^?|(wOz?b21h(O@iF>kaWVkLdoC|eA z3;l>m?QWmoofspCgHW<>B2U=;aQYlESweO^CMKePCp*?wF7}UQMtanm%7F0IEBpZd zJ}P)hf#DK!WXH7|d7rAMvw(zm;15M9VSwvp3lqp&e>Y47(>>t$b*}ac{O9)W(tN80a$-ew@%*Ut4s5C4#lw$1EGJKGS z7xSf_Hcsb*XK)@T?)xoj;Utogb(&10RzE~D!8|=9wgGT?2Yldw`Bg3IdXpK9eSQlg zY{}T1cI2i>5?+St(%?9QW(>&dPoPRzpz1Tt%)@Yig3oj+&rs$dMzZq=uL~Kg*VkO> z7zKM#s9C`MKmMVCo(a`r$e_Xr`&3u4;wid3*{T0`v~yE0i9j9#{RI~tQO|_gRmcX% z*C464Z4}Daeb+^lpL5T^NFVOa8AX%_1V~-jVRhkXanPeT2i#nHe!<9PCM1bph`i$3h0R zaA7jGGJPd0VzFr5v*q2i9xX~e43Afjp!dfy zsJ)m3ANqd$ubcsU6>79Vd8>wtC|BtG6}yYK z-f_|yvCVV4yYfEy@BN*`P5_nnqX2P>34g#EmxBGuG*mVo?d(z!aop3>>`z6DWUYUH z4Q9a}l<*GFzhpw|UKA72{B%A(^Il;Zw}UXelseCi$Hve{!UB2QJ0EqDNoK0;?OEFs z)@uXA`EojH9hR_oE}o6oI}V-^R=^%~zvd(8`Pu&9T;5L*`C?J&;I-a!v2#D|k`$Y= zf6eAhy9V+mknB=!4ZhISs?H?_Y(!UbI$2UmeB0sBL0PgJ|yd7o&f@EG2*^hiME75)3nX=XV)Q1%j&bMNy2<(^4q8n9Kddy_xFF{~CG7xMl zn?(h#v)q5btx^Zt^PgOw2VH%EtqEH1#Bzbbt?i2OUgUB_wv+*+FFa%S+~^x%?CFH{aq*pWLfwjcfswccPN&6meyz6{Vb?{~|Zig2JVw2uDZG*mzyee$=B`_ob*uhj066O!PF zWM^^140g5qHj+KDySl5%KRe)jZa*)9@fR1XMVNwyFUup}WOmmQQu6dysMKMd^=Br- zb83*6dQXH@N!$7<+jm;6xa^;VVe%W2`}(v~;+k!1d(b*7(Ot zjE#lOVa>5Jiww?V?50zH29h^=^r!q+Pu(~M@E(*VkSuo6DUY4>o!WbBB=p}rK+J7R zyJ)vf_<%h5u6p=rrJ=Kr9OP)@xr0jPUt%aC6A+1{oe(!^k8i(VoPo<*g@^kN^!_Gk z-+U&ho&Vd2OHMOK*Gu!{^0pR+i?>c;1sdqD`oziA56#5$ z_qTnryfpCgb~qb9WDMJAHvJpqfQE1O~iIkTYrDRtV_ z735`>DNu79G+QnErX5-mZ@>rR-cP3NdaN;?pfNzD;gK>ufW2Ro^ngdx2X8#FH22go z8^aM5EedB9i1IO;&sbU0^gRv8gQ<3P% zidlGC5kb0LjxHv@5e@VKFcGBH~S_@$-TM1-u(me9;x`2L#AQn zv@&{d&irQ*N(2S=*rjTK`A}5Q$R|tcN_ZuycT$ zQRYa6AUa58bxf!M>*=rdwUtnmj2;gSc71Va_EG~3o{VS9;-^~g&S`B%r*wm1!1*Ak ziu^(EM~c9bwJAhd!MYySEM#C)8morBYYDjy8I@wcE~vcGY+6!Oc0)TmNmSID=^lq7 zJyF`mciNr1wLZK&+=~_~uwW1F*B#LR?HI0sR)U`UxEs-?pRCU+kTEV z1bGbORF(`yLT~%s~kK2Xo z#M#*Oscvn)de}{NQ=s}K=pAtqTRjM2R7o4}HQdzBBXQ;(-U@Tb(b9GT<@@HIBo-5i z2PH(NeueVyUfR$0X(f<|y^pRO=BGD%4?-6*IG>N!IxrvqaXudEJ6A6ASW~4!6VXMj zoXg$9Rp&KcYm5u@&yih%obZ!pzT6W32whqdiVBwp3UgZma=14smV0w5J_MqHJrU&Z zzgL4+d+E!Sz>a7@g8Uuhwb5a3ZR;Mh5Wh`_j@y05W87l%JTcf?kkkYEQ#H{+qt)Eo$Zp3>8!R-$ zRI7!j?w(n0`>T;nV86~M?N8y4Id4OXP4q^wQu|YCg9;p}>{~xPv)b%)M42~eq+pL* z${*;jLhvV9ieX=ZxQ#RagmoNgaBf2gCs;rE_XT#zfbvCdtNJBf6sIg4+{=|uaAqpf zJCDLhl(WB&al?M_PsTSV1A7oPg24H77zMPrw{L{=px08;J*$}wwRZZyDDt%KLE^q_ zkoOjed3h4v6Dgbpt5G<-%W_=SWI%T|=x?a|!}EPK^d|c|u!msw4Ae(=L#yoL_QrjD zmy|UTy&aBkZ=!0JuzlMq(=i{&Bjo$7>?iU&%iw**ZF-EJHQOX6$&#~~8GK#R;Ocac zDlHAzvu)iV1=Vk7w0?l$p63*!;>NyLo^Wmf6!TOup)zequph9V@eJR?G}`C%j3>xU zsih~??y~kt@h1}Wub?6gSvcYFC!q&>#187fe#9_}_!EUTd{%lBXD27|I1M+q>}p0) z{rKRLzC0*jES{gUxd?&|Ru|?YzjwJqxsJ+oD}kc5QuOEwQFb2&1OwQ6@NWjzmr0IJ zR*z*JIG;&OkfYC;4LsepliipBoJ(-c=M%ws?u;T9|uk=T+tkhumOb@4wO$Q1hoTG zpx-OKjNX;!5;LQ zKrN^~8j?O#$W)R0km)@+p^{#l%L^+{!uj=Z2*9QzgS-hJQg-%f@3DI_aw zfBX-8T9laPH=ot$YA~Vrz@A@<92v+96n6=17m$0WoQBGHrsY2vifEfb{`BG!P7&<~ z@*3io7vw)e$eJ8|73q4*^)Q8kr}2}ks{)sZK0HbECzQ7!*z+j^|Gt@%U*jZCr@hr; zPikfxeXoLm7q6B|%xYHCyv;DK%!C`KxBh5xbkrb zj#LQjojrm3EAqX71>L<5TwdhLJ$m&|rjd4pE2lJb$tH{^WgsuuG#j1vBf=l(?nKEa zOs26>E+pa4rIIB|{13 zC7WH{d3Mpe#K7L{mO1eL3ShLCs`2Ch_JuC56zJhn%kTRA3wLI%`F1FpALKpKd%h)o zu+<8-L7VeDLTo7f1{30@EUa#H6KpNh*Eo#)5$r)sUTK2L>x^dWLRz`S$}s-9zI%4I zdZAmMaFxkGsdV198|3+Ee)_`Dqi}xYTA7l=Ip{^~anEZ~*{=61$hfh;LRx-U9PAN| z{_6&LA-9S`D~i13AIQgLf_N`XXSt^xl629W+l?tiKwd!>{BwR*Z2RHHNS(POebXPU zH~yPe8_%h}XG^vIxH(r6U=IoZJ5^Mokjz}c|DW1iDdApae&iu#>I76X3= z7u|IWoG-L)2x)WdAEuc0pr6o@`ZasUJ5}tauHO4)Q;vZ0#ecZ^)crfMW8v@9 zU;ruCX$q%2N&$=uHviq+McM2PL6rj7L+}^71U)}VU*%4IlGrAF6E6RGzR?Je#EA`8 zmFU7N`IhV`i!Z(8I-SYoH~;B zhuoafWhgY|k;%r-R_=(RzaE(^Nc#dI?Rthcuin`(HBcXw-WyTJ&fJkMNas&1)ayGT zr^GF7p1hgoc4#ml@7)KvI;5;BsSU*{QKgxx=Y|Jz@aM&~(S|SVM8bSGw!q|!85h|`#gkU}> zpRk^WqQSpxIp1dkm?<>&dtRz4k|7&dJl(6_lZXu+H7#|pH#12I>^DKCs^+cgjIeau zavAjh%!}708uKhu}LJG7O`0Oys za$@ahB7fdszhxDN@)sXFub;d2>l0(Xpz;PB8BCK!dlxZ_h2jyLcNjZqDbsJ%9H!sk zx)++$-g~2KgYzN&W&`G@5c|mD;Vh6UV?B_eE5a@bE8TI!qly~@+U?MnAn%t;L|~+* zVJt#}^xTszhFsU0Y6$U|GQI(lU7WcOuwzsf8AK#~ZWIaB{+a?K)@+)foDuDa*6zVHDU*1$U zaQ?xA@bzz`-a)7Q819bI8~PwA+1otGMlSkk_%>kv7v8v}sn<-rFf+5*dzujc=o zr(j|JXSRjjXN`9w;fdeCp5_N1V7@W07%$kCqoPoLWjPM3y%QmCR;{xnFE~lj&H$Xp z^UmTEMbh?V^uR}v9o}cnuyYgHQb729FHet~d+W+ick}A8Kd1rqA;iU8htNR&O~9n_ z|9^`78HdY{&KL59@(23|Rd`T&mm#F*_SMAlSVwY|Xb@C%mUO<)_Y3Z$>Yg`=MKi4{ z;u(PR6`q0bzx<{w@cT?oEPDw>LT>YpsGu8XVma~HOW;mBVaJwuM|%2S)1;MVhr{obdZ4c+lrwH;m7@G=^*hh9bavSRc>`2hvP1( zQ7<@0fc>?De+E+*6S4NKCb0H%^rXLi(Wem;N-B1Pa;IJSG;#^oOu(L*ZX&SXE_LBw zfNyJk`j&w`QBWaR?J$1J-DTU zP*8tR*kvq!*BvzZyKOttL`>p$Al_M;^zz-0@N5@gzLCaH%Gv;{I_O9vbHd?*yhbD6 zJRchn;kdE43_U{Vy%lN?_PE)71237;- zDSd|5WuJsKS`?|s2IIO|2qSYKbmT2%UrMM4rcsX#YyQ4^LO)A^_E$=0P_(jDnaw1F zg?I5U?Wz*bQzW$=0iqJ6Y#8+Xj1suny7?I6wV_C;`IenEjoUP*9;o-ItjV~AUJ7B* z-#CKvRpGt`<_8E<`804Zi{>Wu9%L6mVHk5a{L>9zgS~Q5&Z|LQxF#yQX4tc=KycXu z_Ak6y#&*(&EOP(J*rskys9&>WqOYEWFUaGo&vL;*#%{-v`fP>hQ z-{se4wxy7-Y#PkO*pGG3dQ>mV*IRH+;Z2DtJN%%14vT&-{eZ zjaMVA!;HGWI5~Cv8*;>bdw&ZX`K_U5yEfbsHQ+1DLe;b0_OZZ{kx|XQ?`IIOqCc z9;HXPoF#e%|F#!+fb%WQfWH^dzphWVlwFeEgE6qTY+DP8T;%P`V!p4M#moopPg>&o zp_pIHdl76$tbOG6YEL*u`%P9p>W3+PAE-5uzU<}&_EKphf%C0n7h|y-xD+!CgYM`4 z#u|xGpJ@EgJvrafmOIrz`O>_6M%!)dKJ{I`Pj}4fJNI~hyZW)ul!pwy|F92(U&Y%O z?5RO$0>76bPT#*;{YTfw(OV|!!@J6L+C*{3RgDivR_W%LAkU1vLdW#($Cag7x;{nv zW39d5_WnwMg5&V6!beP-g)SIBu!q9K3G^?*6=oGy{w^~nPCUAOfh9Iw4Y=|0B+KI{ zekNKVk6Xic27_oYHV4(0XQS%M49b@b|3b_qXlY(@j$abhcqtIFtBL+SFaBHmyx)jK>anFw{nd2@@5ODpr-oxF^Sa8N~qkM`$Olm{! z-#Pl;APDSDl8^%RJCE7G!Q`xM%iW`i(HtT)Sksz?z@>11MmzhC6Xa1T+Se#c9v4i7 zaa3wo?@@RWg&Udt^U^Sgfo=3i7^)o%27B5t2EhBfm?>=6P9Yc{t16^3r8-4Y;VW@8 zJi}=k(H4OY@+6OH{}d)!sZ}Ri4ZlO+GZ-7OsFg0gSa)~v9<{=l!}${i_OPD*`GVdz z`dk6uRumXVl(w7sRHGwVBiHog4qO6y;~Jh`kk=}5Ecy@HYxVe~h;qim+rw_~iome! zg%D~vuv~13;~F;#?EQ?-0>&fBA4IkoKXwu-b;?5#%&4tBqK(FC(@f33w|xZKv&d;s zV#eo^!P-adE{k0#s&w9!PN}wXjy}N<2892ATTklM`!0VA^e^QSF2m{i&9U6;R~q~b zXqL`?qptKV*hX7uZF0VtP%R!kWV+}wFaM>$9M9pdn_~res1i>FBPn6^y+`U*&)8Z+ z+{&)4T1+;+9O|AJEG2Cu%?V(yDwzQ2UmC>HDv<{+0=*F9PIwv5q6`_#@mmTkcI|O% zf%_3=D7;RPbX}5~*VU=nNU4)GoslXDdUxh>W2taLy<9#uAP{Aqw>;*xR^y3+y*h3#Tk74b7A`L2;s#*8?cja%DE-C}NW272>Pmkrmu4IIrpYo-Gy^}mAV81;} zv_miFbj4*5KJ9`2J3SieM-t3ghLyTXCSE;|XT*qR8lF8c#YlHG{D!cl5x%@0ZtQ_7 z<_fmjH$q!1{vaLf#Ym|F>o-I>$oNRhk1>6!b!coBts;2Z@)V>`OGNneYQTNCE2WZ7 zc$SDfGd=}#|G+*wrl7ax0-rcy%;*dZ9OZR*%QL_pb}Pp===srkQXvFq$43|ZTmMb1 zg&6y9?SZ+QVVbxzvjVs;fU7xDQWZiJ*!Rx-I00TF>!E84Yk(Oh&?`SJtx6m&M& zBf5+R-d~@do{+g=(#~ZG1({+^D%C}1zMC(9AE5TwV}SlNL5L`YGk9>iqPsEVFV*DA z+B8z`n0@pY+oeCq*`@V`1i4_Z>ah~&pRH6b;Om(SaXKko--gp=`g)VCaY)?+3c73) zrGcK`XX@@GT6vOm8urfaxlRKa-jc_jxp-Rb#;?=-k{sc_SKF&(M=VUVIfx zCv@^8A@JkQh`hCrvW(P>VU8EQRsnf8{Wxf6??+y!ORw;YskS}DTCIg?2N!E=yb<7T z7rweE{{nlc$Ok}qx9u|NIW9@`&?yCw?~N!5$V!&6c6~IM6RI~)KwhDk#mya0 ztU^j!E;S zH2>>qjNmo1&-rM)%f@d(UV|BA)!vF-I&k={ry6A#)_34UpQ*NAlZ}by+v@T zDH6@{8LvmUKdhH<^`iN2aK2AInZWq_<$(v?(tZ>sS((Vz-gaj*68Ut+(r;+#@Pr%{ zly9=A1_`UbNe;1hp`E zL-4OTt3N)gpoZgHtCKQYV)6yXU%w$?U!??NS^?;a;bpD-GY9xN+aH#=5wpZ@v!lU$ z3-0w`kMZveP~N%AAk%#rbMZ+!xBdFl385?>Tj-n=69LtaFofZp@T(}0#|0%)WJR~P zg{+k9Eb;mAw#zFFD>!b3jl7u6O$Jx>ZlejDPkNd^&cyMOz>j zQ848LA{?Fxgn{-#6e+Pfa*Ssgq^M%35QQ&AZ=%oe%)UN4GUDHn^6vX@wGOZc9g6|% z=hQumV(cCmx^Kw9%lU-y3*16?lM(*>{{N>P(2k&drazmiEs0SXr+72Ew#;kUF?VwB zy)6YhE0&5xqRZ%xE=bbGJTQs1$O>ctBAwos~=lJtQ+oe4AGeypld@`nrxk$*xT zFOjN;I;G(REGWYkuKL>9hk*5)@BQ4BKQO$-@qb(q;X_Vy!`@d)|#uU`6o_JPXVF;z$hMY+-l(}lQ* zAM{70Ux1-XD2e%)Gnx6~9Lv&zY6$F&4|xOQFMHjaosSFOHYbT7dh>RM>-lw;WGR;{ z?PD4|fc}M0P-nr%e6z#bjL_IkuJw|YfMe>*R}Q;aqC?R*CR!uG5wO?ty&C9G@xNDF zGoD!n67r;FO{k^&5!}R<^mCT3IkZ>cg7WD-qJ1!2QpwEtvs4w;o}DFq=RM;2L)EPw zx5vVWjNN^09PA;KDChz6Nw(jr>79*ar`H&^u(*;Qxzzz}Zi%~>eq0tqAaBTx6Pp0N zrmE|#e05x2bQVd0X?Hw2a**R9DLAH8M;Uh#?1hkb0qrjtV&ENBE6E|I6I92#P-(9y z_a7a9?aHrPPLtXo&u?>JfN`@So~Fh6w_3(e1$rOTl+{F*ndE>ZCvg?iqugn*hs@Im zJil?dEiLPuA29F!a%=I+-G<`8(WaqS>=9s|#B77SO^x(pzIWOmX>J%;8CqP1?$|JD zzFEquG=HT`-ESKmH<*1bZ-)Rde(-guR|gfR(J^+v$G!4fN*RLmpc_}YsZ?C~f06$G zA71`S54lG`FYb?^I)RlJEJ#9S`%yOc`l-HynXf%uUfX}c9#*Liupjol`Ukp;(ck`Q zd9=PNG-Vrz31+AdI|je4jct-aUM}S5)z{=ohdJ*mYip-Y1y{A=ODLnr&=XMxE^m-ULGst?Tvos$m}Y#*i6v#u-v~kE%pHdSj2eO&v5JJx-6B0w}}TpRfS@)G+G1`9(^ zvu4aQr+bGEY8=0KFEUYH+8dl0p})KkjMlG%J*aLoeNcNgR2}b?QP`oMb_q3U8PKef zb1#&RIdkdQgicKXdBrz+lU_CH-zZx&jSw~hGj)pZ{a`+OxKD_*-S^yJe=6Prdts#C zfc25YNayw}jvf!LTLZn8U1BR`=+y?jRHw3`f0aAPqn^DN8TYTKNs=;xW*XlyKeXsv zkY+u~_JTJ2GheQOAHEIt;OA$6@?K7Shble}SFPtjq_fm3nT=0ks#^^m}*4-*>HV?K7wM zIWxD=mmjEKNz#0yCa;5i&jglk-bB*)kVj#}_ja4fs+9^&^132@b4Q@ZiyjW_Kc2O` zJc%mmu7&P7sz`>u@5%o@qpDj{?>-m10M>u|u$F()z4M-({7~PWH=Mg1SH_p>N!OoO z2+vauq6{VAAA=rx1^9o=viho9(;sY#8r0T?iBlSO8Ag6hU^I;+Uj`oo=jW3u@1zCM z!f?XGXMXBf1zFuR97xhcd04n+eG=oE&k@l1=Z&N91J6%Du`9+W>SinDAtU?Tv7*A8 z2G3Q_?_Njv7Y7IA`6YS}!rYf~QSSG}L#)R?bR8yya+;3Wc^Cn`W|V>;|>nuNxSC z;yyoE_Rm;yuTS;O)kZHt&rUcB$agBRBoCyGtIR#nZtf}TymO}iHTdPFffVudGHM9K zE0x|gXY`fP;N+cTdp>&(;fv?<;vAN2`<&8}3ajH>5pxZC?G2Z}_#)qGs%Tav9Coux zIY2>|c765b<42w#TRc<@T;Tb!2cx}Xlr=YdasLui+xhO-4uy`dg)u&(5MReRRC`D> z@g3+PwU+_$dA_<%n=~WQvHPRsr$b7XXf*m~tH!fB(aCS@HzdBnXMF}!zCPqDmzQD) zbW7i7ULlWOFll|f{&bO@KJ1(!4$T4FPh1wFqKEVkxIs_$COQG;Ym3VGoIdxa0@KN7 zrYuIL>p^B!h-Y?1NT+5`hE6c~=6kp>2j8P#M*Uyw(5?(_?WT5?4bh)4phrn>3(UWp z{+7zJK1pX+F0>U6S}eBd3%?`bfBj;qms1Ariz{+0Ltgfql@LrxvRtTMeo6jXiN z(gW|Yrld;e^DEpR-&7V@-(QxvqoaC#6hr>awCX;NifT>6;uHZJ=A-no`7mn7FKYM& z=>30z73go2wzTJU%m-+Clu9>Ki)T$=a5Qry)d(p6A7chJysyhjJX720pKF(g zdN&W`BV1Fn&LtFMgYIqJzn)lDrdAGv!tR9cXuu57B?;qx_e%PZiLt{UAfaNPx+O1uNLFTX1 zACm}GXI=s{0w~FZIFdeH&lHOHVa3i8v;RDHJ4ztFQnTBsm=?K>Xe}`xbrD)`UryN_ z1s|Anns@uae!syh-jHm?Zm92KL82$PKdz%ur8!TP8+Urd4An3}_P0D17$0c>^BSan zbFlZt1X#_SMB&u`YB&CW$;F3lS{eVQ#XJZp7*gJnt3i7!{A(h$b!j>Jd<}xtscKU} z6H>7zBABv5(o!)=JkXPB8wT=gTxP+28bhgYaQkLAw$dYaI%bm-n;e+~g!v&rzWtSj zEoZ{@*d&2V7#EsT4KYyw2Dy3ImFQm1e7O;F=%K_u1N~$DgGMMSx#r@lYp6Q* zE#D}HTNppw=ml8PUY^g8_+SrdqEYpwy`Xu(yO?X1giA*>u8h z$&l-4JbWc%9(af4V(O(fMMVn6H#21iyst~9bCooAz#2y}#CDUB{mWa;Dvod=A(kGk zF~@sDbC_|?-hH6kBWbRn>~zB$#ha$UV=t!TZO4#VqG!zTkhCY}+XJ=@E)qdDyG z>wer88dT;dJT-9^c1T0PQn6oNSAuwH4Sed0Y+2+&Qsa#J%+v1p4T-|T^43$Lg#)Ya zJXm9zX+UpF1cM1uzbN_U$}rj0U-PChtw^W+R!v<9~CGp zqG9YY2)4hBx>KU6#ysHGbDsWM#QSiF(}LdednKU#^`i!n^U#FrGcORX1jJda5t5c^ z3+fMs>n3~y&KtFGzvKQUQdeY(yeMfWMB}@w3A!ynjx4&&k*1K*MC6?P=MkVy$3o&G z@PCBo8&K!B3E}7Gg=Mn#Sqdqu(I<8IpNV}~v(X(oEj3qYz^4)p%n^bWloLIB_W-B<#o8Ut6L|#(O$Q|g4Of+xp4+tj-St(vQ{BpH}qTUdDzAUWHayVc&MdM z*gp`aWhOBqrQrn{5Z$6a`m=+c!6iJf9uknR3DO%7r89og&koIL}&AZM#5~QI9|R~pX*lL8hRJ#jqJp;{Ljl78V33Yi-#7@Okym% zI`N#b*w2bcG9suqB@gqti``nl_;+}yyFcx5_4(t^6!9N_L&Su<^Iz;_o=B`sc0_3Y zwv-g&2jj!(eVl~UZ}LxeCszH((S>oUXE+oq)xWF*9=p^8Pi)8F`ZU_>5oLj0DaRqg z$r$!7RxYedxoxJVJ**v(=pjGn{yd+ifw3R6wzGHv!wA9%2&AH7D*w{L(Z23+6$D% zG6}N66W6J1f11vmrq3#2_Yce7&Wd0w??A}&b37{gsncWhj1j@;plfCBz=E~`%hzdK zZ3Wj#Zl9vcZYctK)&eEKe2K)78E~ag{MEa;cxx4dPMOyqs`-?q(vh!Z4LD!$MoF)0 zA28v)xBmKWd=JUtuhIMP?t&JvMy8+J6$3;qu;QQxs|9}l-rVk3IqCDAYRH0`xB}J! z;!f`uQE0fhF&SBU;J$6s&8AgMJfDE&$@Qu;F_sV5U$&_vZ<1Gi`tk%-bT>tqz)sV| zk%k(`-+m|ZGCZbKr8z_rjPE@gGSHq0zvZ=GIi^sn+tU(K?sA*PnypyvKC?cXz;Xcj zHF4;wq9QxvnGT6W+}Aex zI_k^vpof4vNec1ygv;_xCnFhZ+x~VSh+!;sYpG^VGfMjlI!yuh85qLal2z?(_vdC= zLqq5+@A+rd#}53%NZ?m&MZAATi{Jk9NGz6s{Mu+sq2V*SN4S3#^gAGQguo8PDVx$fJS~N{i-BgHELSk zRmXN<7qNzZM^gMe^z;lEWv3odRQ?Ff#>HsQB4+F zjJ~NS!-Cc?=a6Ph6?X~?FH(u<2^?&3jMyKQwLnh=!4){)va=UH!`5<^_DJSK#@N%p zwi9XXrO`FD3nm&Ng_O7DxvucX*MUF&d>6k;vzRno{S1#$eid|lsLlPRoHcXPq62yl zF!8{670z5IUH;!w57tV+@W4U*F9%&(> zaFz{Aui`mg6CJh_Jk+DpJ*xAw4P56-I5akG=w6*qEzRYwoC%fXZSU$JCM7B0%RCFh$X)-bF}5Sd&$El_yF?PGAMGViIWX#|OHZ$n8!l9+vbuIC*c zp}p*|u$sMK(+?iSvLJ>gVZNF+Y<)03lQ;xmK3XEP3uuaW=pv7DxW9;BSou}yEu;6X zIhHkg7C4XEllF^h9O03@8;we%dKZ3g;6XuHL;}x?Br>vLz-3c5Z3udZ&4a-DfWbG6 zshVWu0O{=$K>)}wC&R6)Bf=xKhuWeVj@b2=V z-7Wb2h=_%%5$Ne-odD%U_B9cR`KuffArr5ON3u%1o6a4qon%^Q+Vc1rQr_GvWul5o zBdKlzG<~#ESdFVb_=)dG7Y6ulD$gi7>p_q&v1%=&cFQg@TRI=kc<+I#+z zh-uJ5WE-#%bkT8~OS*Y^pAPXlxtPNh|Bm#r$5djO&g*h`X@otmv)W4~KjH3Orqeb^ zI)L$s*%JZvK`RK$@bNh5DGNss=_Q7=1^lpQXQ?2W9N`NO6Ns1g=$|*=NW++b+=6|` zsF0?OdPQ8Umzqt+q}O{(VNewA40;-2a=`v=SFb8vLvRzrVEI+@21jd$nELc*+U%hQ z>(r0Hc{lc--W4C})z+G1akuxFn2pgi(P!%46U5+AHqYpDHIW<9bc{C$7V*c*(`P4ArM2?bJ# zL$*S))Hk@@|J8?78IV61nanwCG0%1CejSMZGPcqM33tRwQI|Sr=fENa;t6?sp8k#H zU%ba)#L!MduW*FxWvtG_x;h!|CYbC$*iZHXy^y$BV13`t!uy_v!BMvw_bBWpo2FDX zjyW)#hrE|{*n}106?GdpF<7JB$Ver&45^;9mIc~m>@QvLLcgfFn#{3T+xG@N%Ck@) zzHfqINAgh6@C|MO4M~dnSE{9M(2|vuYy!sal@QO0!J$$zp_!ye;YmpQpb!9 zvHI5JxUEmgv40RH{XsAFPYuvNS{hSBuNVfkBi;ww{KDRWvdk!5H!K%Ua;9Exf_TnG zC1?k?&2gAKa9l@$2vi@~W@7q%Yp~u6ehhzp63eOv1mcq68^ zjOY!qmaG2{Q_E;PlXZz9-j|T2MqkGhY_))fZ(G+Mb??|R{A`Uo<+N>VVMcj8Y59Y| z_+Y~2#UTA-xC%=e=QQ>%`wkXY+;8>$HM4a>NqjZ0WVQ-$Ka3jotnDWkY-`KA>G`c? z=A7pi)ZA!ei@d>}KDn|PnQWL4(6gP20OmLAROzAxvMPa+rI8j;4oC*Xuh2TSRKcStez} z3(g%-L;t)MtJ5qMRX601ODNVP zjis$I^U4nxpHYS2S{aznhaCc@y)1_`#h&zQFt;yd_8E*wiJp+Q zXHyeJx*i_ny`js)!Z3mIo=4qyleNkMb|DFSUj+U1Mgb z2Q>d6!1yqT ze1ZG{k3*n5KLOd|q0hyyzPT)N#Q38KqYjLau$KtS5U)qXJ+7#6XrkE6)#4$xj$dXa z4I|NlAs<0p&NTjq_sU=j=)uRGTtM103%slvBg#s$UNdQjmQ*%ewP;`_ddIHgJrXaF zzbdUaz?5z;WcaRS^TD5;8pfIt*zlZf2!XPtWdw6pjMma0_Ut9_ZPf*YNW5wvL_1ApFAc5 zGc88=y~ZHk#LptuJl9t~KCV}~K2RxPgf)nR@KJrQh;ynUbj@xj{Qh~pBxFGUFi=)P z$46PD_NIfzS=mxY{4OB<9pNkEvlxsb0>pbO`aBoYTUei8j27H~5G6JEXrjrjlNzrS z3Fzz6KkWzZ-NWt!FSIL#XUCq? z_7By{^kg(3OV^n31R`=*PMpm*!2a4j8SJ6T2fg{BLuAPFLvFo$r@HFjZ{!`eEsX?C zug;Gu9~%}6h2Dh*j4zJ)=L1h@?>y_^&Uh7Et}>dCabwHu#%nWUihM#AExra8fgW+w z5b*zWXD$NR99o;>D0x2P_~DMY-+JUyg38o42)Xv`A?1bUxY*)$`9sl5YyFcuGxU>v zT#91QE)uU6IX>dP>6_5t63~mE6b1U*am93-;Z(v}Igzz$-Aie!1?6~8I5C*{ysazX z{Xso`ru_Qz;5_CkuZ1Xs4!d;EZkyH-MVh(wHDe@#6cnd2(Az5c0nA5-)BsZr!F?lY5vZ$+mK5eqwn!x>o)SafiJ%y&+E^;33 ztGkS*=HGn!jJRC9SgotEew<$JXmy|$BIyQvpODhk>-T&LNwRd`vRSOnWFs7(=)`04 zsPLcKFF^al|6}@0xK0@yk+=NO*YdsIKuFC}!QYiKxsZ>eLeRS9QvW;zOifux{U%)V z%o}+ld6-LKADSzl>ZCg_`305Vs2&Ajl0(XSe06o_g_?==bfE8;S=R5~$M%jQRC z?zMs>E>?vjULzP^VbC40e)+Aa9dqqt`u3$HZGbl8d~M8^rDpsl|3988fx-}P4`-*f zLr-*MC(uh%mfD*{nhkc+`s__X7ne5zfwAO)|3A;zD73V}t<+X~dP361BS>YraZR^F)JnTsP2*#HI z*8}X|!jH}m?f7P^b@7+gP4?d%^Ju$h$@??F z{i}-9q(#CP0q7sbvVT?S-;?RC=wAHtfp#XEreGMo!t@>K1UmD4wW#klP9Nz@k@74#PUlGLY#J2j80;XS6`R#2{QVB zGAgLVx%1dkdk{k7vgSAVm^_WN1PI+>B`#*mkad#0(zLm z2f%)xf|t5Rd9yMPDFfiO97~Go8gR`RP7PH`M1Y9v?qC zY8v$Z&oltzY3phDml@%bU$^e0)pQ+~S3}quE1SUs{eSSNfc%gV3{J^WLhU0qd8k0Drb(m_IMes6C-^u%P*lJfy3zrUnKwyC;DAG>q`fNx3n9 z8M3001snqpF;kqYJ=Vrb8`eDW8Tg5A92QL%WLmXHsQ4Lq=O)A%J zG0FeRo_!&w(O-;;++h{;GCi1q@nzQSO1!WGi9B=Td2LE8Ozp>uNy-o37A)6Fq6i`0 zE;CyR*7HpDyZaSWh*zYQi~KsCoa2uBN9Tkj zxwHh^Y7}jNqgOzme7Sq7xd&CRH zVe=qj+KacvmAtPJoxc}PGRVzr(5h3GnraL5__$<&`jC|FNR$ZIK)=B~tWjJt=yQ-! zWz`Z+o(*KQ*nz|+MDe1Ym%LJB(?L(iWL~1!EO0VqfRVruqvq*;5QC5H!#|Hq+Z^a0 zXkw*3POdSWnoz^RytJiS>tQz?oFgW0?55Q{Azm`^y%@3m@uyvJs-FkjjS}feg!qL{ z_2HBTA4jUG(%2}r!T4k|X8=zi7xO10RMqETKBP|=%Rzj1W*oBBAuHpQ zw584d?Oo{STBxf1B@G>j7y28Gc#&MLK!p4Bu7d9(n|toRS=mMV4sD~wP;z4H}D1WM+U_wD1|MCCl&C{OE(x_83 zfbl*%W+*3@u|$agolHj%PnZ9;ZiHfX7Dc<+{Y^4FOUi}93Fr-SY{IUIcgsaO5oP{gMO3wb{iS(0%Pm}I+R@7S);mg?hA-t}St)j`c-~UtUq~9Q z{XsvdoRfUY1g=tg!uyl*UzF!Nc)eQ5=^FA{C>&r?s@0M;*p z>wS-A`zL-)Zeqynwo0KG<%&30hujz4%rn6K4gP(8pS1_^R*HOqr6X5;+cjHsoF`PD zhtU?fZ#TGS2V)mtd~a=xf#=r(lOp_=YklXpq~={$_N3XJM&CsZOm`%W&n|G@*jV4q zJvnp2{rNu5yGn4nc*^8Qn=}2=;L$_`%@&r=!NDcy;c}+~{cVbwgL%s`em&MifCDy? zV?XQhBjRHtDW_+u)gh$3qR&!)^F1qLGBR9}dfzW`5%(eM_E3-|c5JB*I}t$%%3pyV z<>CjRyw?KMxrB`DF?5M^<8iHnZd@m4GkKw2r^p(WKOx@#uU}lOJKyBp*N}fA6*;UM zVQ|w%pX6}saX@9`)RKw5zWo>9P&ANVt0Ca!Z#A5P7Z}vu-Xe_9X;NRo!HnT4oIjah zgm~N|KP8nXYP3aRi?|xmU$~J_Y8flN9;z498Qt13kWJ@O-r&sq!bjYet{) z!ewNb%%~&X)ki-+8orMzp(&LRFXWogy^%;>Z2BwjC)gl)BGW*H6w9rG!B*Wb$yQkX z#P1(K&kI%_nBVlVgM+YKKjWzG(0+IjF`Zw=Wy}`SZ(V1g>|KL+gRm#L!Bef%wnEBg zC=(VuFuiXZ-*(%)AIl_i*z<8@RsSt|lCC1a-M$3l)^(dyZ>H>&F#Gi2&w>;~~-?-`LzCUhrn%_`5$azc(gLGWdBk6oRQ}yaW)l zrlL{8V6K`EDWl;*58uZL_#Pu=fS}#rz^h9scL}rqzliW+{9Ddvy#t^426n?$h*!Mz zhxh+KeAv?PTG#*XgR^mT@EczZ6-G7j_kwQ!>95*T1kjsTTLRXTBJq?sp{09Xa?rOi z4ZR0Jm`2KK2UZ_wHTIj4AYS2>vKK`$scaw54B}glE=%fRsXXbryL_t%VEXYH;yrX~O3sduTXB%ctmfx! zG@Rpx3&iLdwKvNg_8(a&ZD*l?o}u|B(BJrFqZjdUoREB{#Uys72rVNcaVtGIbSwqM zM1c8dIr}m)lT|)}2S1S}%&(U$ETyaCt?g`m@%Ys2DCBZ;4VDa)m>~x zn_AQSX$;W&J=PDb5AJ`aMX1oJ8DJz|V}(*Eh`RfhoGJ_>)YLdS0`Cir*ZE{<={Z-% zH)uY@Ds_=Xr)zdUMP##MJ|>|r7X6mw!U8?Sl2aAPc#2J&^VSf4Z#7NE$dzJQ;#cZd zR_$-IhIOq31rCt-q_`Ap7R^)@Y)sdQemRpLqQfS)`334##~mM13G6O?W5Nf$*1?#ZGeM!kIXx3}3{i&HT&2qqPMpl(S?78&9NcusvjL@YE>WX-?Upreh2MPaVg zGEK|Asw4g->f7FyMg)4Pp&CGaG$+Hv+qtk{V2M^!fhW51`G3ePxya2{O^CyF_L$~}ID^a$n zKWgwhXx3bOv!Ujb748e&N$|${o1|S4Io(Kz7qJrD{CD43(cE{S>VbRn zJ-mP5&rA0g2y&x{s0C5l?7AdieB{;~)>qas*fA zxkCWr6{ShpzWUY5{a3wf|Bd;A+YL?Ow>315z$Unk@7L>S%6f3!ih_`|$>$fQ6UUpTd zJ0%$QQleRW&*Nmq@rMgq1`n0tiwY)c(1TB^BZIU*q`^!j3=2Cy`E8cqW6dc-f1B0^ zy*{C@GyaIccrTBf<=9Ix?L20iec>CdfMVX3OJN+3z7s76pV1K-kU~TQdb5(?`{G)8 zWYMFYa|1wEok=59!R^j=G|xf#zHz3USuVX`>-gC9ec8Elm?Qpqst9;M`>TKSV2Hl>#Z3^- z39UH!b^1OomzDee~BflHA>AvKn z4*H$@**5*WB@ooRqjWr`9kw{WKd|a%=8}fHRx@QaC|RGc(2xiIMnh_VYD^j$Qv)?W@2f&fcqe?XAV#>@z6fLRal~v z8C*%MIDA~?3QK233olo;LY)}a5(7P`VVGJ-{pL5?VR^WPy{D`nhabL#hxt29MNbp= z*VRq)4DfCwIE#(e**``;mN=L){B%il31)#27$#??b%1BF^;DM^2fdc;0ieC8pSPxw zFKKfqr+HOa;Po@4D_pNh8GnvRt3w@!)UOAUei!#Fva4yRKx%*h6r90UY(&PolJl7f zT@IZwPHp)=uRtFBzt1DmZCG~&nCkUXJkdVqWNt#2KW0vED;h6izSBWG*5g9=js;EA zZ?A()8%NYVpd{d|bV}^71!jCp?rz)Py^#RpgUNmb_S4*%zt!tY4~2{Zj(2a-w}UpY zLtk?#JZe}tNdo;>Z{ptdv&N=R4ASo*rQ$n`?mXU7ywxA$5goxFR9Pv8g8q2{ERw)@ zKqNcup@~y3{BuwpsrcMn=prnUx&NBsaFTgj0}`L6c`LyX!+<0wl>K_5xs*>jh2?{Z$l~IP&GtM*4e_+8 z>#Rm^XVaYX=%meLWf}A72Xvs!rA}U*^dP*+n!ACO2fbGI8z8?n5kUDj0CsYx3uOJGnI;w@O_I|!%rTYEK%DS1p?J{)?BtgA9ARYl3dU?)cq7JK~j z<{o;0=eIdNU(%JIhGAdPZ`Dg+n10%(gSs>-Ug#8wWd`wnQ8rtZQ)-{;!C)%XcI$J? zBNxtFU2E$m#nit+?+Wx(RRH5#R=)z;%i%zyZ(#&x2#I2vOgMdiG%*&9z=fL#-KObU zD8y@&S!&PkJTzIx%3b3YO!wni;+1kUUiBU=xp=Q3@`Jta-BL|FlN9cA zj_yCNauOZzX8nG==}_49sg12vHBWUpNy_aWDDKqxZfM{Ez#a5(U;FH=ud>f#bU}(<;56I0)1%@ zZb>UFkoW>_=nw{xFfy|4U*%!CBYa36d?$IO@od#iyEj4mv+FOjGU)wIP6YNJ&7Tdc zJa4*Z5_P2%O4CmUzj}q?JP6yN4u>ZK@p1jeQVs4ulag%}`F+6AjhnW=^Fx%DC{*Ib z=fwTR4*>}3pcj>y1+1?gnuF=zv%%E2HO5-*|AJ3VNpgIj6BfP(7e5M&2ksR&cFIPp zG@5U&oVDGghwgcoxBmaPR6489Uq_Q2`wHF~poep@)(MO+1Q+GfDpwDCQa%RY?r$>pb~eRGxqi*Q;JlxtH5E^-h5zS=3wy^pK#x z1M9UH*-V@&@!|NyUvb}IdZB(j?GaJ4!FM)*vuBTjcni9_8!&o1a}J#$gXsW-lX% zH^M>mFw-t^8rv3e(U!Gq!?;l!dz1Y@Mi@`pFT+3 zZ~pTTUu&&Gp5M7RNAuP4@%-3N6MpW`-jQ%0epe^Q(^kpR1)xB@@$pyfR9{*GN0rT0 z(Uobo(ByOo*O}cYR@kUgSWun|ZB4=W?7yo3{f)1WIry_J+QYkiGV{_wK61YNDBaJg znu5D0-WU*%@hEY4J6ZMR4fY`xg3^2l#!~eM;fSt^X83-XhPSa;Qr4i?{BsVt&x)|5 zoas8-NZ*5BgA09HT%_oOYqoJQ$P_gE=NaO;E;c8PRsOVTYax5PenBHkLX~b!cXj9J znv4GMVZtKogAM3~jt~Op@q1VgJSYv;;W0g0!Ag9Qae=BAOa@Y|wc*m-!2YNslDN&6 z!WhMp*v$utz0qGLeydXNQSVMULMdseq5a*4E$FSi1K-CUrYM{2P>jz}entM`_^~!< zSUw~Lo)%HY%nBdKuLXU|2|*?QaDf#ddbzGW8=4~=`*LXBc2rM%Y4Oh^2cCo-=)sqD z0{H`U%aG_AgTn&rtNfMPhztCWnC1DEXp8A4oKTpM^6vNz4eR0N!4LJ_*L+TBS~d8v zGDExgy@&D@az-PE$aaN2=*=z20G?~m(KT^(jb8ASXh`Q-j{L15k*P6~TTRH_Ezq7b zt6^o|%Iie9QdjI7zEwR|9rvD5C5Xg-cR^`qF26j<>i~L}-t|EJ(xv7Ek?IbpGpTwb zNz?bnLpk(QaSkc$*sn$!K;mPVXIB4mWCE+VFgr^$5-vVK%5vx_DyKGS9junXuktqY zpO@D$3GN5mRW&j`H7BJ$B4twP27j>P`_h~%8TA?-Rb36@g*b3?3PL0sG&FDH&=1W1EjkCjEbN(dPu^xd$eqX9NwA zT{?m9fnLHC!LZ@KCKrh>4bc9gv9h)$g%+$-TnDR;i7Si#{xxY*{1`5ycd@o1cex#D$s5f9~(4 zYU)vs7UeLiI5-v7GD8laE%4a&2K;xf(mX&9k(ovd(toidN|R7&)348)_umZED^&X^ zPPCkfEg%vZl~dw=;4-(1NrQ7!yNJ01CpXF8(4zU!Pr}+w=)@-dJi&OMwwY_)n1}N{vvA_kcR)a|En>thYdNgNA z?UT6MZdmB-0y!(g;tZtr5YW>Ps|VKOR-!Xj4o3Yab0Nvta$&g05^H~pO`rL#XkV(q zLdu(j+ySRg)e`?X7uM8QW;8reXPD~q%?W|MNb-_d2)cqoDCh}}hXU)N29nUqv#vi% zcy#Vq)jnQH{cnpq%bOI%wb)}?AztmW30kH19B=nm?Fa_6hCb0wZU@RYO$!IRf+^&- z7gH$Vpa)a%s1B)LVMeOg1RdYmYXijSw#_cHv)l4{&Z4I6DRlxbARcrUlLyUGAeB3{ ziZTW&ES0_0}H7c zoAdk^OTNU%ltj?u zx!3{rTW4L}UlXd2=JuWXl&9&+hvtvQm^_}GZ(6Apf%A_s2@1!$BXQf?tb%7!g;GL_ zFV^mzoNgOP#!QFb3R9YNQb13RC=JNxC~lsxXPh_VGC0l@w;J!+&N^D(MqC-rZuWVf zK;mOX;3(>1V>?7-s7NHAOOzREBw#_lO}N|oFv_dBAr7_u&qElJwScsj3Qkfcmf39) z`i0M(NLvS}uq)_7=Yp@9W;?A9ARZhuv(GhS?E+6f$F?w3cI?Xv*N0K9c((#%x>pw= z(}_)~V0;d;-avh<4xL1g#wE7tq&cxFz77k7{#6!wMD^P9eDDakU-y9F*h0YLIV{c#J{!dwFUHmiQ>-xexpc)L-j8Wp4BE3X9JoUn`Q#=BZ0;ywC%(U^ zjG7g^+pz@c@rM6Aw;u*T|1j^Sn0(U|DjFU9vN)h>`Mo1t7w6MhArv3i8Swrp^XWPc zCDHx(4=yja0iW#uUq2r+hEWl+C;hb7Y5qmIUOyX*kLTD0cz!k~v#I;4YI#Lpa0=zI zjZBr&P%e(Y)Pz@9>(@czvouR{Z`%%dMb!#pis0|Q$%gbUH=BKm(xySA;WB`k%Qgq} z&NJ76`I2gj+u~`4Sm&(wO`cExXPE(u%)(xZ;TFov6-$Wcc<7Vi@glKgaj5gy^3(Fs z;_%?b=i`?jq^VP16&X1&o#umHoP{26UMpK?e8oeicqh^Jx#@}MaG`76vK3=8w~mA` z1z5kl)K-lM?Cwn3I~sUpE7sZ-jo`|`#^Qu7FDzFWEF7a@SO9tjur0v&M^xlD?ZlhE z(rGL0NYrh{L$}KN@&qZt{X=jXkYBs0fw7ad`#r(FR}h}{a1$SU+`DA-Ye>*KYO^S` zZecX01oSSw&w=sYdzv)1QHX0f!Mg$P%gkcCOUP~)^kcDkyw6THq`Xtll(wVkawbLm zYw_33G=>frD5_9uak`S4fzuehiX4<>pa)k4-nW=~O1q1IB9Yx;TS!@setMi}?{#w> z2%OKAVFLC?u1~w^rsXZ;P;AoyZigohZ(nRCrd+%gNSPY@7svZw;RLS`%A{;504 z>aw_RWG5cukT8^IN4}<<8d_ffKIdyGdSJhAGe!8=jQ$hhoFRB-A(#Sjc{s2NBf2Wi zm;J2bjnWfuVKwMEzr6;=mwM#K)u7l^tKk>vFtLTu`uco-FP9ZYH-&@jw;<&uI;X00 z@F*Hu#GH@7g-hZqU3XQFvYL8l=bVXUGloNVRs(vt|95{#|KK&{FCnO-L|={ahb!jv z;HsT~he@hVDDD^c2JWwE6R#*vVT-y=P2&@vuZ=2l(=2mwX^J_%a~+VA=^72osslZo z*dGfJuO-GH0q!cHV`vaDiZlmDbS*|h@8=AL2(@7pFrU9&&0pZ@zK}rh#dfZb^Y(9Gfd2b~wFAW^wx-P5 zHNNfk<6$o%uVB%kpYtQ)8ad$IAxk{}8toeTc3Ya?G$)9d&_VHjwj^r}IfoC0r8i%m zpc#x$)0U7DQeJ48f%khwmtQpkbsDno2N=1O+ifd$v7{WA$(#;wv9AQ^mb7|{f$<>kBIr|a zJSRs>E5Dx?NQUY0VeSF#QNP}7+3R1B^1A+vMaGlL><~1Mkvl3oEz-Q~ z$0)D}qSx#3UOV{zBaPO5pvSZF0Q5JX|8oMh(}}z;WzId3Sl=(kR($WS)yBW>EIYG9 zyel-*KrYR4gRL2+fO+Kgol96;dYx-F3erHQ$PjG#T7}P`hq%BL45^Q>crNE=+N<{| zQNA)_^dHKqUC?D(ELQK}In6 zixsFR%qw2e>)cV_GI~4^I}%;UMnTUr=natn!=EU=;A0`Gi%*geav_I`F0}prUQe$5 z(`>piaGu9yEILU22gdpyVes2FS!nnHW;X_0ZPNQf8#gFCG!c#0W1xp$mIkyxRaW$O zI-IW#OxVsgs06glJ2Ei!;3W;yuP_^d_m4bRa2Bpxv`XtfF-S8O0qK+RSafiljNn}QYh&%hi|jriU+gCIHV!4l z)m_;76kEpRL_+oDGwkxLc%V_`!N}B+OfUZg=p}0Q1Nr;54pA4{2yR}-sI==bg&fUR z%yGj;WKlNsBb=BIBSu^DOxhO{HKH6%!huaf|h0TJV`ymC;o_&S&7uytIF3%G$%4gRK9~t;vN|R|GJs} ze;)1KH87qw6>D(tFXgc%(@frFvsiM)&lg&@r^EJ^+Qb3*Vi&gV`BH9|dI*kDzV)qnK6r^je;l4qzuJVhPiHT!C{ zej6N$VdS;SUxl+6zO@aGq%P{LjZIWVr!Q9im3NH-xGx|Ye7s{|{P(T#4m@YKlfA1V z0;i}&_%ItxFEkRwI}()kfnC#_GG~TSPx-jB5`d)h`#cmsY|MFMV7_6i_h}XMkakLe z=SK-2CU~`P{>Q$XU@u|b>HB`UZ6D`OD*WWx)N6>>*UOoauxu9pHeN)~a6dyB?fyZ- z@FkbB@FY8LL&zaJ(i-S_n}X-RnT~z$k#FuhO69&0kiOY^@4Jnpld6^oJ%B{9-f7yuG4UEDC?0Cw9ZUv;G-R_b!H^H>)M0sx=ScLD-)HPp(IUs9s{(TZfRJ>>k@G_-w~CYDtRcJ%0%$?JsS74 z!eAsi%hS^r?t>mnwg51m6vPPk!l0n}yB;*$lM^zI>Xu!nW%wZ6c|noh1o7yX6Bb=h zYxR(XbN3t*{a4C|0*!Am_oh}&LRg6pOqV$iK<}Es0T_>qG6(hU1u8(uOZ@c zy-&nUOQ)|GXQJOywk;;Rk5eb_o?AF|7zkG(9_++SQ-V$p?C6u&sv1HFi_d2f zQ>XBihNMJNb#0R>sh}&++cNC~?g#GYTW0-YvNU(*82a@zsE=$@qwMP>U$ug9vKb&A zJXQFTksJx3VaodP>uw1#s$$=u5%GHOO_{HVYiyFeQP-fyeB2F;4~SCqkabgN>QsIB znx00P{@Ob z^bhDEVc`x!%Bz6kxWr?9=OGoj=@`s$fx=h*geI=>*xN;$#RMtg?!a4I1hkMW?Xp9BgmsKb<_{zMs!h0XYYPr|22|+;$15fax zMAzGG^AN9l-3KehMNNL^Q|b?rql5)X|A91&RjNdh3AM8t^I*-!2hc;Ls{q=UIxc=T z)3OC~XZ86UD4PzeRt!cKqqH}uuhj?2A)ez$nmQ52K?u$`fk|RNr)GAk&!gf z{pL!JwL)$F{pD2-}}QxE&^kxk*E(fY%;(K~_+^xtfs||2$(}Nua!p+d<`a$f1Ro1Seg z9+(PFTeQ~R=U$!=L5uM}t7hahalQaOhczzXd`?~mIdP$GEAx;_4E1awSuc_DRk_4^ z>2^ND643vu*_0H_G;amG^sN(q;nqJA1*J(+Sk4$$?6Nt#_;v|TZs_ypxC;i##cQ7`!i0MW`DEJ zQxQX4@XrMYm0`|ggHd$5MC#Vs?7Qw);Kp>3K~D-f70AbzdB5r^d7p_TG zp{KD^g?Qw!Z=?^&Hv{u(-ZQs(AYISmB>u&jYt}x}$?0lx+WB$n!R(Bq)+&wE4J%+Uw~qGTuby$QcEFfy~^I!?OU% zmqb%$ zEH>y_Gra@m3;lgt?PbntIN7JeBUniNbrdA?!SI|gl2K{3P7qH@m)v&EDnqEt`RGTr_xvg{NaP>K%v zPW4Lx=#MH6${*KvXw$ovi&30xyO73{5pN5Pf2yg6#vnJbBz&0v=TX>#-$SX(B}5;! zopT!6o~SBN916lbM=kPX6B=xtsfWaa;u=e;W@Xr z==kJ&=o-c5^aS>_(n}>|El9pThf#)+eY61bA#CU7HARy6>7}-<*mOz^2d?QSj%Ian z8qnjc@B{YGrBmK#VNazVaCDjnZ5YtKDVQBBOBBpm9P(;2hj=DsIjKI&`;w^SP9Y8> z9H@Vnc9jnE!tv_pJ;|$+f0hRP^N0plf%%O8^4Jj0&?x+6(2LkWS_(#o|KDamhF->` z*{%S_YjToa{oY9BBiO|dJIQA?qsqFc^?(+cUpe193lf%(UxIVUaS zg20Sd(W`;!!|?H~w>kYdua+X`+x%=H`CNsMjme|h*{xFK3f^lTh9vMMwSUlSBN-q# z*9_dkVJBt)y(wL1p#2j=oIqt^cDf86ieYkJ9%WWPw6c4;K2*NPL79el!f6INw-Oyf z(x@rRI!}K{B}<+u4oYm--b*Z1X%Dj`^_{=1%kb~A^Bd`=Q93kYhNWp71Kw9uKtu3*PElp zLr?p<$AdlQ)Bi6ibAw)_%N+23xLDn2)`sP%beaQhaeA5<(T3kjmcIEp>rT&U)s${j-?ZLFgut|wRdIfVMm6Rh!=JfOGYDhS-)9TnG+VKmi`#HhWj zkw4giBZ=%**0#TK8<*p}fOwd8^)C*x_s?>9A{-k6e`8IJivE%Ir0&jjL_#1p_Gy;? z=e_J90OlW-U3~+k7pTwvWS(RJqx{uJGM~3BrDnxH>2fYXyjIQXI{~D`dG+sdr9_Cx8ueE>~oxL>vf8;baS?y$+QsYAuIL*?K8aH=qwjI z_m%=yUpwZz&abqT1Ut>ccz+_vd)gshap_bw38udPq!W&m?SRqbnv`kOqe+E;D&>M= zMAU;gk}&9Hw7vk!Yad}Lo`$v^_buqhK*Mg)%m78_Ua(N~aC{pYus?k!r;ruK)gk^s zr@WD&`StK;{d|FrJ1mq{kXHhlO@Z7~(zlc*gQg z8rV3f;txdW#EoFTx#zs3#XpqAe5gkChRZq>1(qB67As@nW-!vnBVphqzN zehN}vJnUmfD{|kq-`dTt!UqwkC_JRHG}d)4F%4yD5D!Kzz)(gt?$d9Zv0UaC_M4JP z{$pu`NC7l&gRZWM-rl{I20b<&7vO$87}{RyN~w4tADw6w{A4s;;b*k}TlwirVX-za zK7AaK^I6#&G=YzBw_D^OI22^l$o+YA;K%MWEUz@@azLa2dI+Y|Kz&(KMPQ*N_^cxN z{~5wj=rE(vUW0x&Fy0LfI>Z{WA+xXxTiVIok%P%k2-zzVMj|cqyC;Eoqi>Fq&*0b76P9!` z--VEs84KH8P0{^*74Y-qqTC$a@~GG1c_uWLazDex{fw_Zz=|GYml6iQZT(V;TFPM{Sa?Jh#sLzOZY5bj%_{Y23duWe%AALA&zfPVUk<349 z9naClof0`~fF3+cH8bS?Iw82s*^`$;t8@5MA*DoK5-dq4uXE@Olhf6oLCQN~eUY`z zqAih?()6CfLg&c>FE!WpS7m0&+Ol~*Ly~~FCg}Y#&jsq=U#Ouyy@S!gco^?4qfQfKp2HTy za5-L?zZT~=(6A*VqtOFBJ#~4Y{#jqASUbS1H2 zX#;vNCHOlKPqNP6_$@A4>o9_Ug?=XiUb?7jd<;WzXp-PKkWbQZ?GfwikG7IM0S;dp ztDxub(Kj4g*cucgic|0^i#)N;pocY`1e`yp3~=0Qa=GwH$#`|AO6Zvn)7mj%&TGJC zOzR2kR|FXU_6yATi^GV_s(FYaqd8%``7DXJQ*-^}&!A5G#tf@F=)D!c1o~eAkMhyB zAAt)FHKQj7N(}ErYZUy-U&s#gKXdm&t{;_GU%pLsR-h@njhlAe%6VwAZJ1q@d}$1F zk(U3eVb1P9?+GgcsLxx&HiB&YOm!|Wa>c@zt<-Gwnk);8=mI`C+-MMwK8sgZVC7`= zWBaF1lS|~uecY{#-d;q(d*3IY7iJoM4tjw390PB`^_T7u9D!yut)j_r%|~|bq-LL{ zIJT=?N+*YKVE<#VgKqFE{+Eox`|qd5VY;T5uQsmf0!+#|7as8}x`~TY>c)Ig?ByhLpgb6$>O&dcwTWqStnfbxc7 zA8~c>J86w==-^`g}tsmCs=>RLv z`x!n#D}w{8qGnOI+rk^-(MhOWS2ImYoTQ4FN?X>l50wyMf8L`x9dCo#x$LiAGxY^M z5>i&6zEF{(xisW-*q}ucCl?jkvz~}2Y%@GJ50>rjJwiM$`)s$EV(02YW7{huJA20C zEOhh$9CTcS;%V={%CEgf{Xs8gfEyS;b4YWLjyXD3-s#6?>&+AHIh8wdEy0ntLovt; zLcHM*s=iastGh4;{!gbrpB+{Bo>0v8amh)L{{NWZ-n$FpNYHz-cjtvXA5i(GgzxMy z90+Z@H(i#2ODzj6ilAdTJ~-v9|L5VS(~LtrHH`F|tUs~^9@-z!KOuL)$ZWx8^{8GC-H2NO`=R+Pav|{)@5Wjq zs4aLLsE1hCD^VWNGoIVXhcn=^grYd3!FOlXIupn@OJreWTXO;e(WL5~*FZ=q= ztT@#Tz10F(uM7Cbgt);gD~es zuuToy^;UbR+d0XgM^X;H|Atdkd{j|@7i8vvqAS&m-rWJc+WJz`u5DSk30RLnvnaHf zLY5}@(xz*fWX*V!**!fR#taW#zdLwhk+*r>n*w?%bgMxBTl1+8)<9*jq5J&qee!VN zl?#T}YZr7gm3Il@3Xt0+gsTMITNoA~qw_Ph%lcHPb$@1W@XeA6{rY2`+AHoC)ru|WP9xjg ztVs|rLrmDdtNo{mwP>rLzck^VTp)|9bcJh1D2{a4U4#~A|F|2~?JKdN;5 z>vvS2A4aS4r3QEOf5+-iLg7z~1ol5DGI+jqH0TbOMG?e@AChZk z{ag7x|C^Ktq`b5DU$Pm0*oC?MPGEe2OoheYbE-*3AQk-ozll(pcn&bD6@s2YBQena z{e~OxoN_Rq6Mknd`cAk}y3qIcS3ldleCr6ZXo$B_^yxcx>|8;G+>n^OE=p*Ktw+bW z9v55J&u^9fMjzvii$Jewr5hL@NYfK)J=2zH=MbrRylc$~zCv^q{k!*#YCmG@1H}6z zxZhhss=~8dVo((+F-4WcH+cOiQkbg_I{FtLHMW~=G3cq^b^#tATO9shn)Ddh5}5RX zH)_qTQv=5@BD#w=6mNzboYu2=si-OamG@yijb)cSTurS2 zJz3Had`Nw<-=_Q<;urg8J{&$~Cv;XY*Ye&ncXLK(eJxoX;=u|w63Fu<(khF>ItEmG zQnPZQP#e&{+_N3CoBu^mF>6}|dS8-@fc@1+ei8;_wy*7uCMIVZ^@M-sa`jNARhhb& zvM4Yh9-dM`e`gXmtpb5iz%)-6+4!|=ypt#y5-+??;B+`O^vyqyaFdJ%lCN%!SfyQG z;DY;1zOgEc*?>?KABuFSv&6x66gbb2`e>ishw>TGhA4K3d$WjKCAV`q8SXl3qEhtv zID>@gxf;x8##sxDhZKM z+YEF*@r-@=&iku- zNOcceA8GP{^;jCG8t8cfGL*$1!OTVEqtP@*+-n&xOHQ(iWHRX&;InP(K+gjfT#vQW z&Poao#flwVlj%HbtJ&vf!)U!O|IzVA2JDA|A3^{O5gs3x2;7D}w5NWg<1&t&v)!w9_}80dy=3P8RDV5~Pw|2n zsLytGa9ctf)h=LuDS*Q}5`&{FKG6^wE^s6grTSIZEk|@>Q;WmV2vXiM zKc>`=OzPU<5`C*GWG~o9_l_qytP3&j^QvfNZ@%T|G=TX^h{5y44IWGQ#+tbu>iU=C zZBnUfoEAL|^lxyOG%X6lcYnXHnCejbz?G3*nKdWL1k(A7JyKSVVyFS<2a zKu;lZA2=W36!1-PN0WQBRU1pMfxmR_{q+aY*ysjI`MqY~`9LIh4`!1%j??*e-|1*A zdWTDYsUiNZ?wv#PACkRc#gnGOfSxV9?Yx^;IU-=x|5QC z?l*JQ_tCwtbZYgNl#*RBv#T3HAcT0YZd%&PIO6mh&0wzjHlyP|tMubit<4KYPwR`AALsO8JD(w*+ZG#kP=!mF z0K2HZfUT zYwVIHuYrLo(}Z~8%^m`XP!-IJv2j3>#fDv4Y=L5}Yp>}of>(5z+ixQFD)eS%UAvJ4R2f=KuMQqfI0VgZ+&M7Q`DNv=E~d8sm->#Hru0rYJ7CXEIw_ zC%C5B6EqOA<9XZF1A4Cn-GTFe_T-tN1V<*jm1Dt7aJGKgntz3YTISThM>WzdL%eqU zl|P2GbSP?0eL1!ZHjfSRN_4N9hlf0`l8s9-4xn87KyPM15LoXVs-^pNw2|*I-5_JK zuHT4jI=B8>ao8c<+!YEq50Vg)*S|!hYw#TZiR_#~u;_$1SAOmdzTE?i0^5(8r%Uqz z(EBV<1GLX0_unmE_`Qu}4ZHqfGaR#JjCSVho(SC@{R;UX*S_{qM~utzw?zIBT&O$@dNI$&!2V3YIM)QG7Rq1de5>7Bs@&PsNR@2_KS^`7 z!467Dc@db7o2ycm`yuMEBn4}z1PBD*bve~xv5_y#AZuq*wpFS$5 zI!tb?oHY)5S1#Xx`@76rTr8%ax|=#^!_ z{`3*;wB@P-;dHViA+>7QZI`82b<06Qcxi~}PC#La7QF5Ha!M}9KSx!LD zDe=*sbI=h!_?xYg-z?}Y>~;b7cd+~gj_I{yB-OV(vk7gcZ4_n)_*f$uL_rBRV1J)$ z2q#|{!7;P|>%LBv#^<)i4Zi#$L7HKdU+E&fQeG-y9`wBM>VWGon-H&tvo_<99K5!6r`Q!kf5k5`HVcwchyK5Q(k`~1zxQY-o_9O0l9R8pq{#;gLV zhWQG_i;3lR%DOn>w8A=nq3qD;zKodYgLm|c;_?2>Wk*;_=|8F>U?V|p>{kxw;bk$Bd_5PC+?kHsu7TU^q#L{24+`1 zFq8~FL?^goD!&gaeu~Ia*3!^P_}L?w9{daRwu+$0A>OFu5T;^d!Sv$ptLf9Xo;sX4 zw!ay*DhaDCPF5ja@|4dMI^nYfO9G}x3|Bajo~hLcro(L^!;J9;bMqF*^gr)K%M398 zMYhwn=2M93XMB+jRd{vo3wtmoX*6FB&4W)*1M$o@e#Z)X(pG0cE09-cyrBx;#)7-XHS6rXXJ7x*3>LaUmW9ii13}pz)P#i7106n|XBH;dR#^B|?>z1oM3S--5 zT7=sERTHG|MknN``#lQ=;=K!NPoH`_9Hty4q2aIKF_7ayz4KijZ!1z^8%;qB(~$cL z^nQPu0{Sd!DD-1{t;9`Z$?9yRAAmR2}kzFP)aK&EWpR>pqIT4 z8kn!Xov-)hC!8>H(n$&T)1J#YfGV=MZX=BIo{p_9fkL`yzXtQE@kjvkkN!fMAwA2y zQDUkj-p;N7J|ge2ObH6nO`mHkU_Ftj{C&zc!KX1LpW~4=V*{f`r`r}2XzvHOweV@{ z0hf&9KcE+WR1G|DkJ5`2zFgBQbQ~9YuuPw&q1frm@E!5DbYWMtA?3wPK}|N5X8BVN zXEsFri@RJ?pvc+d;=(GIWKPgErQEvm2K3;+%>wP!%>)xMcXES~6~_Usi-rWF{k^+u zS5zwVLOdVP{<()phqT9qw?I3$t{vFE%W8an)|J3+hl2CN^DwKE>HKsHdfEL4!1Go{ zLWRo9aY&wISp&6Mqv_r`1pRWCl}c>Sjzt`j&*MgqS6Ioe&Fh#tyrlpkf~%OlgDqE$ zz!&*}T-9Jwx8|Q0^VJ6!|9wFfW7J7=por+IEpWZpo8sW`{bK8j6Y#Zo`ZvUjY|7L& z3BeBI-h%%|j(Nko93|cT?omOh{E77_10{A8=$&PA8;p&rL`LWYrDL5gv#9j{`t&XrUD9`wG} zYy$PqxFgaJZDtHU6qa2{*h^!p(jB8HBs8ypcn2#G;^`qji^sVbyo%lblxV@(sX5YT z`8L=0MG>^jI|;q5rIWk|(1XoF0?z-{(D}FZxaS+Zz(a}Jb{iPBxV5?aPgsdj~U1x>FI390<|RcHG8YUa)dIY_=%ro7F3GAl`3oRU5wa59_X! zw$SOPukA(Y=H9;Y<4luV=w0c1+E>+v0ln2}HekNsb+8lpfgsJYhF;X7*>IkCtAFxk zZ(Yx59 z*_0=f(j!jUXtjQ6b0M8wNcECt!@f9_{SCwmXc(LoW5wv?X`qHFeKHRxxKa(Oo3H#J z(8ojZ(hQ{p9Tv>@=f@>*{gw<6rFALR6BMk*c7wHI>UJK(-^3myOrjhRWJA1S{vi_w zI7w2k3USA7ubz}&YA>={4w`}rxA0HC%D#lJh66o@s#c&s$FX!>ky#NBeMs(U?8TwT z!jN?{yT8u+zElwetZx|RPR>p_{YZ`pUHMZHR{5H%=R;u#BTzr{!3;*0I;~ z%QbpZRqZT^*5{*|N|EX~#`6$46(pYxW+96H#T7eA>y_vyY+2Sn-MaobrN%7m9Z6^r z+yW|O*r4Z03eE>{1~(gSiK*6N8JEX!2F1e8DH0X$aMGU~vpIqN>9;0O)*hndi0DTy z-75Z1=&O|_R4D5~#QZI1eFzVM(xjxIhxkwmtkXMyEaq@+WX~7 z_h?=&_6Y`zcdfx?SE~}8P$Z6vb}0%7+))s3COqMFP45EqtB>7ZE=gD{Xmo`s9R`_j zhfSr+`vN>JgD63deS8%79*^Cr=b)RVxGb~J2gb372N~Vr_-|R*)OVI#Ndgd0YVSI< zq(1Oid7AlX`>fE#5FKjqLl-<1;?V2a5END6?tk7FY9gS2(?5?ioL{kmJ1A8bB_|lZ zXf!9nJ9D8A=QpFXhIknq!SXFb=){@We=x<>(w)&|s9u(dmuy*=QFwcQM0KEL1oIW+ z5(DG=8`2Ecw>1P(90@_1ornisG@(yaHfr!vr=9w)>B5L_i5l+{LHqU&ZYB* zc&LNvF8x~Qe{PD8E;kYGXb!cH`XUtdA;aln0cbzcrbjWwBf z#<5>vQQ`P&qA?MoB>1MhNibnPlkqj^A*obKK|I~XbV4ZH(IA)VZaeF9mJg<6TUPmh z1qDg0X@K=-?bEyp3vGC0ikt{KkM+48KUL?L{r+rBkHsjaM;>=K+fBdp z%%%Bq!OMR0y&&iu9;1yTZdr{BKZ!N7UF_HR+Ei&`q3-OAgpTzq^&a=@;ukHWpijkQ&)90fk#G&||NnetxKCC&5g86V- zKI%fQ-%mp`g+PY&(RG)nJpRAzNZ~PXrFJ{pKA|p%kq}R{+~hcPk4outy%WiN;IDI< zZqidY_8OaY`?b%T`RE~2VxSiqa0$$h)MLjf2(CUj8TX7MGLc>X;B?10)e+&Jk?EG_ zf_PeVli|Z(OmpgqM)J#_9K=t2&<8kVX{EX5DDYiHh1GH;K<~&J85nO+L||uNLcx%~ zidv+{%OtRA5SG(;n5?Jv%-#joca4VGgLmvr=_}l|yNz?j-;7$?!F~C3gJAU-O&)Ds zef=m6dWik5JCO2XoN1IcOuci|CoqR2SZX4#yTkmsKRk0R!@o@n$!C<_;w~n3_v?$t zRwS9|)AOr5Jr3gDtxhvW_ZLPMUr0sYfS%U3SHSuPa*`NaFh?ui5J^AkCk1Z~Kg&C+ z-yuj|$>Zgr9%k=E!&s2wIDhK8ZAyM|M zf8$-ROEoTASa4|Aa+Mn~e+yY>Q71CWdX6K`{FVbfJa!MDeQqSy#EXzvvtw}k&JD{g z?0y>OfAMjuFGe#wKm}4>I?9K?B8TV~%f#uP-#Ck$zm0rZg|jO&s@AFd!&W;u4D&`wW*NQH_%?x58qL6%bP!kxn3w4z6J3XLWvLXg~#SiUE@14L$@zD zdHabOGcPDaJ|Yx`E`4=d_yBr7(hfj*wdQ-y4^6N#)10I<=3qtp*@<_eghmg#8XK!em+*gwE5b z?*jzQ9nvc5V7_$kXJC9k8++JB;qhCy6`d@obzd6gy9 ziooughIJw$k@JwuyvN2G{XmJ`uY6;ya{pZ$^k_Zgf%$p$fMi^1e2~1sX8tvdfxrst zd!=7@E8|;^nl-@u!#zvCn24jlQZb>EJ>we+wd;Xt_Ci6ER@|Ux3Wjc?#;q>swMj4m z`{#D`KMI#gTO4=`(!VZ3Y30o=^-8aPmh&ge)fR@7*At4WixN`cSCp@D9w134}TZWe7x`iK}r~*zo6R>++QX04u>ekUri|8Sq zcY}*NBi&+cEaTvHM9{A+mgA2+At?5zFQF~!l_wDMYm7ke*F7K5A014cG*_hBrmafL z7sqPzOz+}a$c$Hp+0F`M5J9~95@Oud(E1Isb;VToLG7O2U&S|~LUNmL*P=^Au7BxH znt@*Aks7cc@1ejgzJvX_?kk=fofX5XsZZ&mU{qaKk*s<~FvMfsg})f6Bect_;NcHT zsCaYmIui}q%o6@jT`*}7(b(heKMy@W9T?wNn%`=CZl~*IQ*&ir-Oy9%nyg{=CYqMS zEfWRmGut(}U~JFZ%|9bL&BXp0a`L`WzGbpv)Hhp1BY*uY_|E@%B6(DR_xh2Xb$lP8?NeBn}WCm`Ee*d%VC@ZTYw(UuO@QH^E>52_xG5NjN0~H>vi<$VnX5^ zrdS|la?Byc2_7V$_5WWA&t+$+U3Z?O+gvPOQ`tTnqsV!EDjF<2nE6a#L}m?oaPH2) z`0qnI67tTRI(@vHclCSa0WtA!Ie!Se0iGiz#0Y)Q9()=$(7+VgxMxZ@_ z>REhKz`1>Kpbjf_2M?Ed*R9>DWBXtstzF0JZiLx1^v`<_s|Q>^zf~#q(kRwDYAI#5 zPPaw;&_|aqxn@E!nz~i*AmxQ|naZ|l{>!EG2R2Ll((*T@-BG_Gts+)`bjh0FKvf14D;F^!o1f-AV7N^XX6 z4?bwRhj^ckL$a@x?l8S^UWl*p4b0CBYkcX99tr<0Xrcjs7?IHU&x_F12D|`+U+jks zEK+~ANj|#hB{N8sPrr1|ug2@)dANmmb-A!~tO{!sL3WPAMipegg3|7O936M@JqYv`l9_?$_qspDpapeB9*6zKDQ_3Ioftm0 zhNq&R(TCPECP==M;lVU4rf84E(gLd=@V5zdNOF!}9;LM1HQT#>mR!Ef4*@;*v_oJ& zCCR|mlziBv$rh`;F)dmA2kRuWdvWT?OwooIaDF`Wjd*LV_GqocRF0`Ka|Y*aDUt z%U!|Y*sp&_j82DoDDk_}8QElNEmliw7vVZd=|LezfF6``H_*T7D@%U_c_c7U+P;RP>>!O)sIFB=mq-W~}m5_xVgh%gk3m&6E zuRl=$*l+CnOYj)+xhBtX0#5(-XoBP1|z%`am9R7Ddj@NrL?bm`7do@DcG=@(9ewG$5h%XrYkkNq|Qc|K~pir2A? z|Co-US6s-!v&(8sy~k90UA5`DoQDr7Z(X)oUrPA7Pk)kop-It)XyllkEamcDWGlr9 ztF1m%MzKuLBPA`XgLv6e{TvtlYo`+vKctV^WfG!3GFv&n2|V0<^JySZvJlmL?5#Ti#!|jsJ!lg@s-4amQGs1%34Fh+vTWN<8rgk z{n`Zeb?0?T#=v>yzbZ5Xbx3m=mucF>+I7lPunjgh;yDe>#7N;YH&-P$L|;Hpg$eu~ zXs@u=rUst>*FG3VX!B6Li2VR_k}r0twVjR!z<9jF;-~Rkr~Bka_(m7?UKjnfR2%Q0 z>T)<-HUj;*nqU4wT;jd<=iDzhQ5F#x?voiXA2i6tE^Y)TA?3Y0 zW)`i@UA2)FBIQWob)|>1os5tH!P->%DeAb`Jm^@(+teF2&#XWlzO#QdJ2p| zg@!K&^*JL&qoxU|wQCjv^AGtWIM*-56S;A^`r2s5t2-gn688shpfsyouxHjuf@~)L zd9$SXK>vnxi9Ia#0`VJF+|J=ahs}tlpWf1UwmG<5?5a>mJ}pA@!2Y;~Z<{@y=2aT1 zrCa`tJX=i%#1kB;iDx*04w+xUd`9AZK>IxEzDBz5*jc*xhn6N`QNM~0hj?GRUp z^A~%V?1HY`iC(_i`@Fe(5ifHq=W~d6q}xV&_KHqsx<5v6`K$5&Uwt0<-G}$+j(ipn z+cF=!5o$z{d0>A=jJJyS!%UX`!i2B?-Qp`=8S8sz1>cIH zI5OIXPR<=9j&d*`TY(PHUNu0^#qh1K$^SNFoYdFPUgGlTAYEZqdZ?Xbp@igXvsqaG z7~iZa1ygooc(X81n_J=cLz~ill;CC|=)#afvjX%8S7Was&#xn8e>T5fuG#D^Z8uds z>T(hGgfhE|n3@WuTMxwh|2zJ6{MMg-)tQqX2@kdENhL_)7{(~kUv;>9VX64?mR zte(s(i3%zDA@WHTKdb8bMJ?z#jlu!rQ_fa=;;t|^*32Ytv{%`&pu z5)jXQilbvVT@=pK;A@wMBvv4-*4A(6yznV835;2I4K!bqe_pC31@OGt=lYXg1?Oq2 z>cwVFMk6w@3XqUblzre3O&+O%cm+A^pE`wb2jjPlL?qI!KaRL0soY(4AEW;iCNO%J z=brY@Ti1I6?k{wKCfVMuD_r@$<>JRK`aBFJs4qpqtobc-##Rtd!GPUk$0f6Z`#IrT zue5VNje6Nl--)MZzT|`Z;zzrW&Gle;QpAKU?^k|L3*uGKBKl7F{&^ zgJaPC?h&w_W1ek%FOaSmBHzP>q!&-y=+umTHFq^AW9R92W!*bh@}d#+5V-?^`f|~0 z7L@rd!tg>dL%&CLVY*plS+OSjNbX+id{!F5 zbsS&))?JBto@USsuhIeT$EyVs*_gRtn%skw>oHP$SnM#oVZMiMB6klfV0~NzRY+5@ z^0mzuyVdu)4&%DK_fn^>xw_f~9G?R@3$6;N+CYzp_*M;4|9F?^Wh8}{`WK^SLm604 z#p5jX3brayJy3aafb*<($k|s0#)1+bdK(vS=HlTOPScW2Pl@&^&wVc1F9(i3wS(T5 zA5B1crHt)<$y7DGf>m63{Eq9Tt7CzO$gCPQW%cXLBc!~M0x=JJzY`m=vr&B7|HAgt zz`&PAEU>%nM=VV0hI*UwbbuZ)DmySg?_@x%9BDywfYbNGek60#)!)qGL|xwfJpEn3 z4dOAyHfm(;OEicUe?-it-{aF!DWs@{cep-`?iC6Z>{y2F0zJgqFH4Z}j$j=Z_~g98 zRS%)^EN^8lXjuz>9ZG81OiI-Y{GYICE$dcumLQpLbaaJi6}@#-2zBnymy=np;xr{` z3HIAz-Jq9bum!YNZ^lVbKG%pW>{FW9d7u_cQM2Sh3-3qYs8EMPehw;dw^#P9t*C63 z@#Lb#%UJ!PLoWG4AsrsVxBQV=?WuU3|GXIrus+-V41N<}G`jm8S@LdWsbzDJNKC&? zWx3Yi?F*oNULSY)|GlKR_R{v5V63){Z=-jg7esX{UASrulCICc-{bXx`H+%Jf$`s- z;L6>08-BO4_T%Ife&*oiu(dGrjIzO`9pYa|J_?Q(X|RNEEtD81R`_#YER3S>H^6L$ zv<1x*Gg`Z(h$r-e-V5&&TS$SHSW52$xdJ_hO-yHt<#V_l=mU_ejw~eL(6_xHo=-4C zt)ymHZ`OSu$>MaY>LlB~(S;q>ILj@1go1Q(spv51bseQ*LOh*FdRn39$D05SN3%1* z27?1!+Y|}iv}H1eCSX2@_6&1f*nC1j20dZ-CY${B%kTN2J0$#ml%t^M z6x<86e}iTOb~E8Nk_@_ke>|5@^CUc&Ec1^XBQl*=0qc_w<1pyeRyMFLi2SUUg9#4M zd$v8foi{2+jW3tF+}$m zA?4LtagJy!U20;d)W3Pk!({!V7#a9&4LPeZ8ZQOEr2MbuB>b@GSp)Lte#AD7)m0 z!}%_aj1k}u@fsyQip*NsD);3pYQCxqQ#+7K)Col=DO!-Gc0V1~ysBLUz2xD)z<9&5 zsd0HY8afl}TJZfqF3@75`n@}PN{Q|a-wn7sSUA&b)nX4wP+ zx-QhCar@5?BxC=)d>$#Fy-!@u!i!Petz=s%T-5d$bWUTXLfg>CHr^Dv2e8OLBfL^x__`PAnTUYCY+2>$?nctT`VE601CC)|o#Whi-k#&Lo zqu!(J`^Vbp_P4*G)IUu8Mr(pzdluxD6i!tJ;7jQ;5-960m7`^hk#)% zk){1Kx6Q&u+3q1Sdg6@4n=qjLi$sdDsF-%D-DFT~6_0yme`}ENX+lM0Q@lN`@)Z@9 zUe6xr4Rcuo_cy4S0k0^e?|b(JHf&M3tWN+z0nv!n=>5zWfn+da4 zmq;8}{agK*E70TmSPhKFtqeMeoul7$E^*39=j!hbI9G>fZ#y>j%Ab-kVuE zPiq!%H;p9d%A_RkU^y1x4DklUoYb5Nz2Fq@USduMx5#mhY_$p^qzr@5|DcV-_vW!84Z zzgE>raIT{_Nu6jkFp#GOi^fAZh06x1I z<`K*%{@WgC|MIln$)+=F()r;G>m_H1Z9~88D|+F#D`FH~e+0=#Uq)5RWEFowJUEA- z*doEEx03k%6jg!{w``b{;vJXt(?4$=I}4cqR$S5v#`3g~-yZeYePG?_8EVG8NVSsS z;p^H3=D&5n-v4}eSP#WNJ`on3cJ+glaBrs2{GqxOR)Vt2P*jWj3CyRG=n7oF_lr*q zqD~@FMwvsz%C9tiR46I+nYjA4Y4{z1@g$Q|!fbgpX4wf^E5DFn`r*6}|Iv?DlB}E0 z?L419){iGVgC2TN7*O7~jwc73tAQ|L>e-l@W8*=q27S5E(S>BCHaroK@@gU8Gi>dw z#??b>w{fMMrRxg6b5tNXm(sdt4!2CZ{Qo22+`xI2*i0AT`Cvjs(G<9^`~QtqtQIsL zQv;}%>d%VQCGC~yc8(BlfePD;shPAPsQM+A%TaGp6GMucf?6uN@t4rJp_3`*4LHzi zTCf4$A9VKmf2iD8HrM#83irE^r-V3Hj&F8)S^QqKgAv55WZoD0!h z!g(!lh#|~ciaA>^Y{d2eR)UR1WE)VfjIBY!UCsp#IDig!(olFdsZy$2`!#{dh9&)eIH<+c~TU)8^#;UFbgZR3{)=vEySGaa6dr$8n zKCu`X^!{V%E*P@t0XTpY(%s!9(w)+wbR#J#AkvL=mq>RD2+|?lozmScDP0op``q~j ze$Riq-EQ0M_UIq60P`6W$ImN+Hl)r72xKMdIz&BIybHT=-^LDKQWgUHC+8;?rGm5{ zuzxSHJ9#k@$0<;gsX4|A7NO|H5RJvR>lgm>zL~rL%KNDVkJf~9L|=nI>;rPs_Dgg- zTus>TG)L+SMjViQfta5c1~sG6(1_gxR$%=cC4MnPnC+~W%Ek;_U1J;D$zX!{ibWlO z{ToxIi{Dd<>TjYf3@y-&Vq#PDZGunM;1!*O-vjFrFC$~u+jF?3wXvsA)4ik$D#uq^ z(e+wW^f+O9#Lf(}oBnyY9pHW+1PNHuhGh@3_Aat^IdzP_(_5#Cw7)A^8pw zcB~HG*yCTccDNQa6v>Z}OP_7}b@cw7s$VqA&akV*1M@w7T?F=XMZcFkRH8uJQxrul zx|1}gVpjF%S{KfT&$@a7*8kQt`_+B6R)$jU#u4kUofrxfUG@#6Ms(jt$jd3Sc?j#` zgWgv`ZlHf2Dtp(FT-0`Vywn$ii(Yo}A)^n$CjSVD<8>hLy#eX}TS-?}?K~Y-MVtzX zgf0x}`0S#ucj;772VHi$Q*O%$Ko1L=5f~pxd`XXU*pD{-)_7vYApZBh`a#oi{m(UR z+m$Zxy{XbJVsyjzcp`nHGG>|2_HY!u_V9@@dcpc?=M;&?TGSzAp!eHy5BUEII27Nx zlQ1-N^}e0FcQ0;|ilyPE>@0}SRr0Q6A@ygstru6i0l(+aDMhtIyYtk~kcp2`8X>lw zGIc!Cu7M3t1$umeq`>`lQKS558z*&~Li%p+(O3Pk0E6T7!QSn3@@S|D;<dWeJTxsdw@O z4)8qUUy@YVVDpx!@6j zi-h4144jHFNo5`Gtrpu$&|8>V2gX+oq#T#S$$W2`vi2qMyol@2I27V+>b;y!XwE)D z@@eCwIo!IW*+#STi*ZEZZO=RyzKCfzs|#U|y=9}MnuuTmz0NIq;JnS4JG`qQ*VCI6 z%mxL|8E%BK41*1UGr>&1!5pWs3 zEu;TDDCOKyNc~B4UcM7AMbA*hJ)%-W(-#Tpr9?E!8GL4$VgkN*KE|h4?)I{pdQ+-y z$li#5#Y6P6DGz!(8JTT0sa7rXij4)#*WtShJdZ-)|7xK%4lv*~TRSrwpbm`}p=a?| z!RgzRJ5xaNl?~nsP}p!-zWod<$Vw(fnvC!#!Bl@2S z*i=i(&wTgqu_b*8r&L{*P2D$_v8vtls)6=Q7{ks#VFs=BknQt8_t9$P=xJSgVaFtb zf`ou>LXBts4F~9jM9Txuqx#^J1byE^s4*= zf%;2wy?@iu`Fu>>anBdU`0}(oBJ6;jU>oBlbH6milQ-l!8H)Mo8OnFeboj?LU2tMf z=KT80|7V8M@zZYW7mWY&x*t}7{(c|Vr-Pc1g(H}tFE_yl`!hY$m`BSUvawA`cO1my zJl`yBb>uKK`ytFEc8G{Z_(D)ASC6bXKPVfm$&w1e$WyxbfF*KFMd@Q)$7`V(t**{EB0s@Z`K?>E z_gSrk_5HQLN4PT8lKlB+`@NpKiU8=rIuHT&rrV6Cy;H%-Mf1c@e2rxbkI`k!e=p)E*4}Y>OW*mer z!l@KA9eUGt3|FKB@i3M3ZsuH_GFz9ib;*=NJP14Krf+1Kv+k#92_!c4R4HGB`D$v} zf%aFI7smTJ(scSHnq9xHtlUP~>({-@c9KubO%U+DHnT=LF_+yY)u#6TZE#ic(3;tT z=0oldcG$4T7d}lJQcp3^Q@48r+6ylMS;+nzPBKS*zKKKmqIyInFB3%>E&~F6MJ^=Y z>y-&;rBsrJJn{@wE4nwz@*ZgF7{O(V_fj>i zWKW_G8E;NDwY}T9vTjMf9BDn z3FLlnOS$~#1rWLd`S42oYN1%5Nq!1T5(zTU{IQ`(2~5m-r|`HJ?FY#>%63zQomiUd ztCG#p?_EKt{j*zpp71QpS=EMSOXtVY+!d}2Tq7K>2>q5 zu(RZ1-Bs*?9k9N(b?0I2{zo&M<(x6?hpmmVGGCABz3#AwF`Lyq8+%WVsS4;pNtK2| z%G?K!~ZDo z<%H3SX@ZSF56)Z8QdQ7XwIT(^Lzj;mXT3dY`OGc}1td?`t)FXQZa@`@oNN4Jz3L-4y-M%C#7w z-J;S?&H>ijg$jx=S$6JR)IPK%L~!Fx(&~`RC9s>+EOr{t&Ddp{DrQ!O@#_sl$^ z#H84<7MeygslU!F?2^NL?Aw}YZe@UFA?@}d{m(y7?;|5nf8}eRb80~H3e?#}&E|_AKt(_2Mr32c-VV?(?*h)yb!OB+Czk+cHvcRavx`ZDnBd5 zTOD4!mtmx0dBHD~^LB%s^*}GHTNC&mLL|QJC>^T3&dy@(MLu`TYQaaQo%R^vk%|*q zp#FGuP6Im4a-#JF4+EL@Yzf3>C9gF-z8QV(uGZFvlNPWv1ig;fK486$@uOowj(3-1 z=9qtsrcx_rCV44~<()d4vcTaLBwue9c88O2PoYaOv_)fE$m<8bGphoOA*EW4fOs?_ zSA1Aw&^z~J0mcV|cE8=y);vZ9u{V^q{^vmqXf%D1pUxluOtCz*hPH2U+aL!k

z8U240-{FhOOdwyFO2ZV5!O~0TNogUw9$i!hv~(16YHrkOW$54Deq%!G>>2yyHsJ8OM|CKp->5&H*z*AxwKkgZ7cOf6;m9x{+fj&UZT%( z`x3)K!?wmkFsj`g^y28LfbwFcY~{ejS(%CGhMhk_?~~P2g|KhEtCg;PgZCbi?VSXbV8z@yD|P^P}Q#k!$itJQa?D4Hb;Y zxP)T3Cs9hD3F4#~HT_2~9z``v*>q=Vzr<*2tvvzT01Rf!HI`?hwN zChQATC(wiUJ^{}2U^wNl(5rtWnJ&9akPYwa*U+`ak5<*%unFA2+Xi z4i;`7P==!nT1MGy?k8H=#dOo^@@zr*DEpcQtfzz;AN6~&u2jU4I5}F$^&s^vro?XzD z7kz1V+$YVUhV-F&C6)~)qInhys>Yi#T@oZ;1P5=>Q)?sz-Vb68N~;_E@U`z2Plpls zW<=$x4wDJTi5DCEoDHm>RtJh(Ny}6V``?&HVS99Aovb`(^o5eZk$gU9;e3~2BI5^o zzinUu&xR4XiB4C!DOT@}JIGs~-&bq`Ge^1w6+!I>J0xG?>&fLm?%{qdYjNqnbRBFN zt`DCbRjo$GxqG%g@($sa1c07D^Jl=Lk(($Jk1-H==R={3eCwaOxB6lV&Zb*bs4Wnf zFR*sq20gDo7`3F@JUO2^K+gpubG>u_QJ-$^Lp~^V4tw{{gHKVrg|t5+tkxG9&o6I& zN(m_2Vm@~xAwDs+^|y!qz#4&ei}l>_4Ao(MgvL_o~IobLH= zDkRMiFrS6PJdjU?-zfZwyF070l^^x^7Rn<-VJ$!N#2YU7x%n%^JLvq_?Xyz2&Ahx8 zlsl5jkJI?Ki_h=r{{8nXItA0$zH$G&I2-W)%FFu}gL}?`N)?4w_M+fbmEt5ksV(?k zCEb5dQH6N3L<#t7Zy2CMo^`TX@!C=JB$6IAdD)6JU=-2#=SY4I|MOZ(N`U*9!K04g z%UViE?xvvhd%EY$4U~pl`$?rJ+xpB5h_@p`B&^Ah*z52G3ENS!`x_ZXcE<*EbmxUC z%mFbfB2r^GSYF)Jl?X`vt(EdNKQ9Pn#tWYuonFC}q^b5L`MO)CP0h&5LA;Rx1bfr- ziIKs|rpiqARrNk7wcJBYtSd=s#}(_&PhYscfZi2?DllJ=Qb32J_|Scz3_Uq_4R!CC zRynZWAsZ?d99EA5@eG-A$G5&&xKRas$7)%)pI?>AhfQfaWV4>l3(dI`=ZXF2QMaQ4 zmZP8#pufHC^{4J8@ySh#5-J~FVG^w|6l;6;6BCPQAn{F4JWd}&U zue?sR#Mo^2cdselO9Z;pJ>~xjJ>YNA$%QVqoDv8vUyKF48bo?v{`T~VG{K?t=hwU* zeC-RVQ$^(Q^(@s&T?CDbAY+K9?rmW$D7H_rY@)KF5>e1YYGGwGsqlhf56Y!bX)1%n zBo6dQy}3gm*Q4N^yKIh}t)Sa+#5!U0(O)W=Fu%^5-)(*q=NH6F38JvK@@}%xqF#gZ zvW(j(^TCYS++ZaRz6df5+LLl^{^vQK%md@ornib|hRmy4tBnb$q0P~IEf4QYGA)NK zLdfx%Azro2Oc_*c+N|T;m4+y7N_3glg9ct^#d3ynJYiDnTJ_aGPey4HXn)P{TzcoS zXs}e0E*b26o*l=WKMds4t~7*2PCFo88G&R5kI>srqiy-mfjVl9ZjXc!CY$J=+>xnA zJkN`F%i_WE;#)X(LCWhK?k4uu2*j zVb^O3;Wfd>rz&~6@FC3NFt+=$e(f;j+m-}+#mKk7^H*8u%EeJ_DZ#VV=ZrQ-d2Ube z`!^MTZz$qaI$(Yto+gl{%ZeH^S|}Rke)iX$+=_(ukI5~!E8X2qXtZ*@TQcZvwCDii zgT+hb&e7VV-Ipn7jzX zN^KK65r@9CC(BSH8|STz^YJz6gxOI8w3lo{(aE47cP8lRE|CH4nJ*RwZt0o$TvW*< zZa#dp`>qgsZ|8kO`Fqi~KOx>pg&nD^Eq6z2*7L2{YqXL*wOO*;LHwp4KGb(9^SW0pii(Cs$UUqxPt zdpYxXcgqyGP~C=vzOG8X%_M&M26`)++rWCZx}OV=_G3kCJpO~r6lRukxpxK4hx7Q+ zU=_bjNInVG=?=;FF}q|Z&OSF0!Ul>%Ul{RmV^h-xG?`&sLVcqPKrcUA5g0$`)`n&n z2V6H6d(J=)94g6d4wc$XM42#dNeBV!Lqj*7YpIXpK^(!Np~^Cu4V6WAy?74MlX@6} zbPsOmwe_W-_aHA!3Ar9}pCoRz*AvJ_b20#n1CveV$Eb>9>!9(*7k zQ(1E;a_{M# z^e^WET3(w}u%S2fSF<^0H)BI-AyM&a{V?+JvlnK9%etksp<2p4GJ1KRV!rYoxL0++_iH=fR45bE9;phO%OPI%RM4d5?B>W^-5nsG>-8pE+l!WCu? zEzIFbMwCtE;l*%7)1ipZ^7!{A(4#Lx1IlX}6+(kP7aiMv_okEHKqJ{yg01lt{F>eL zsv)pmBEZD|rInG+i-DQF(qH}QLiWs^p!krM{F=g7dh-r5Zm}8kh+w77AlLV_`Z`X5 zzh9X5*pOg!ZRP_aW-2z(j$FBZK@%{)%=^~c5|V-*&jOv0n5k(ui9)T;ok$5K&}Do- zDxRVo>)r}_JX=P<{CB0ry_EQ#nhm#AGW*e-R7UFj*y5t3t4owyL=sZoaN@^4E+mmm zeVsINe6x>5&8L_wb^|6vyh{bz9+;!Qn>s+RGt>-t9{`Q{=ZC~x{%UhC^HE|1j;%z1 zvJUPM_qS2~twV^%)Sslf;LI0#4`1zz5VpwiP?i0o@5O>-S|N=`-|B<^2|6s&0Y7~n1!t{*~ zb#1Eco78^Ric4JR1oQnaIRX09z8M{I1#W5fZ}Nau|{Ga3*Q=s*I=CU8CyZdRwI+WmL&_fu2Gj4KO|soX!m>cDP4ZFek@t zVy$z3?tntkf8aJ#fF}gbtIEFPX%k;~J-(+YO?Ez!Di$~=xL03q^Gz~PwD)BeA?HjF z=otu01NDcTEZ8ZIC5+V7%L(g9TNgS;PKEDhfS!1!Tnz)s=k)DhgrD`YVG@&=j(8}o z4ShC93z-e2;dqiINn4be!BA|%lAJqbbMG6 z1NOI*N(L!uSq_m*`!dzb8Wa;#hy59*uyxB2N{-1|CJmK)H3H_tM|<3Zw7;^(g+c4a zS4QL_SNnvAbqX+PGA@3}^DS=Jy})_|wtB+T3H7myn4zC6N|fU^|A1EGURYx2o2rWL z$sKOR+fmS~h+zcQ>zGa3oi+L+a_KVh;JQOaJ!=Sp_Io*e*%)640^=(KL+de?O`#78 z+Fg5-$h$ZzGC68|7`As48Yh{Zfg^j^Q=rEsk_@~L9eXgLIzs*Ra8#k7pqbEdF18HM z3>()2jVJBL1F64d{#rx>vJO&Q`vyH5-#WRqqUF(G>H0PCTZtMulp9BkY0xWd2hacO z>k)oyscs|Iy)4jT*_iyoj8wG(lYS=c(!?_y;vLL*&O2~Ac*hW>QiPclvevx48||?- zjx>p(x)`|7;~ks>J*F8vU_JJgxa!D<7k<0tBY4p~cPmC+noMNtR8OoeTK1I?@0!l! zyBz=i)J;Boj@#joN(BXT0u+|1{2}fH^tvXWHSav=MYMtEZv>WgkllZS3#w6&`(sY( znrpv~)V~97V}M8^1&k-1j>A6vHFZ2_RY0pxki7|BtVKoL3Ov~_Q!ThtxenpDSOmSg zNH1VM*dEoZ9E~Df$S8jm2!rjydWB(|cjHKrO(M$j zR!cJ8QHWFrEYU!wuA1*R3ZFojH8R zX?<~Pw`*^KRv+++shwLsXY&I-bCmQh==sz81LK42SFIT@1(4ZcqY5Q!R(TzyZqvo` zdfnQ$8n=P<#4m2auEOQ$5s(ZS-rP5AxPve=lJ$P&%wwO7!UQv z{m~Jad}@wexh#qgrLckWO4)@%vSgtZ7Vw6Yw^&f1O13S>W$nIEo|SuWv6_{$O>OHf zj@}|!S<+Rf<*x(KYfl09cbX^sVLCSpDaHRS!TSpeuGb(>PFF3#Z{>|bG_W4Qv}&4? zdNF$Z9CgG@*IFPw-yG^>xAMfvSwLo!U{*e#atM08({MojDe0#eT<`tv5vI+BMQ!6# z+^R0F@W$V)7eZ-6A?jW=w{o+HYhtV`8qRd)jk zB%fxj-tCCwt3L&=49RCDX{-l$e16^jih}z!(f7L3=KVF)HR$0{bq+xKKT34hx9Fo5 zi@BWiVb6D?dY7D4X_xH|NCOUX!1)Ify~J8pZ@oOje1&5EHXOl+yosu--60zM`I>+>RHYBI4#Yem^HYH!l^GEYJ+!yX0&n^f=eA69pQLlNcKGrwbiDGpvjdb<;lO;PA9{fHw`CQ6!hCEwDt%{1 zBmDgW%_~Z|j8688Vf{u4upYbEa6e6wThD)xhF*{s5C6G_3M!-jfU}rE2`wmuzN+vZ z9`vZz!TEU`>{iFZ63K_}5~Np(xECG`zXjNuEvK~zMe>04gVrB(Jjr_ON-*XHM{p)n zyXmH6uEd`W$8$8c<<0FC&2SMw56J`v_`a5mJ(OD5QeZ1=x+;>VOojFDR0od`O7AK{T#yxD@+E(J8eUSzn9{dKEN&stegMrnPDAyEM$uC8(frYY3;G#>6hp z3-D0sy+i@M+So^6e876u_;93H=ex&ilAuS3U*P&vbRzuoG67azEHHjaYc*Q`t@7!JUQYo@pZ8oe^d|DEDtJkBg`~apD_V4lK|UJP-%w zAMfn@q87Js#nomi1H+}CZ#$Xj3lV}pmbP>51MLqh(ukdw1jXN8uZ|{NdM1^G$I|}1 z>(Pyz>L+~Tmc^Y3Ht0S6Ed<8ni>&lm0m*gb9!cK0*`p7V+A>L#PF?R#*4|5;Q%&p~xB+Z$XEgLuqrT==r*9DM|labAjUKe|7Dv6)X*x7Z@#*)!Pt3-7T{ z0OmVydIbJoDCk>AE-EKdQ=>Jx-KrNix~{aBKDpW$TkLdPHN^9J+mgTJ87pgntk0Ql zp|D7VGRR}e%J)(p(>)JSJfixD2=q9tu7T$-#n>6swOR}{-{iv2O9?@m`u%)51Lm{q zkO!P3h=&$Q`1-r-(2NH8J1!6GVAnsi#*1egzg>l@RxwpglYZ8af*w?g^%JB6p;~Hl z%Ra+x-aJ%Kz={oI5kC%VUh`{KgR1ET?l)st{;(@qxmL}e&b}<4cQ>PWyCz6A+x(L@ zuv!?;vxu(9K+nLK5}0qbzeJnN?ZcyXGFTH<pKG&aepX z@h)dZS8lORPTAq7*!H@>iZcsycDRMZTEGl7=uOTH1MQ{i=QkU?wG|iI%?ot#mLyrj zNn)c?7k#4`WcJ^X^2+N31)K67uj%VT5e5YOFnNA@gCdu~Fg%zrD1*SC&e7qgRqi7YcCObtQI-n^yO{{jp+mC_L zJ8zzZ<#&IEZKkG#EnxsXgg?%dkor6OaeTIYLfCHq`RzyJ4tCN`ZtPjaTw7h_XfY*- zcl3wgwLxonIhAt55S5Wn@&XBZdUBS|(A?WowypVhOcsowM+pBK7(YkOg}y=P@g})` zn;eAvoT-)lm-Veu4*LTd9G*GEYyJzrXh^DV>J#fnuE(nL#rDNH){_KrOm>n8{!DDn zfHe>3@m~z^Lh>EC-bN4m3$l!+@IqIk5ag|xVRLCU^N1~mf2x3Z6Hli0QVG|a7%~^0 z8jP%gbdwG!1iFFrbVU;3a!DI~&;p>>$wmas&xx*R5j7`ji^+>dWtopo+%Ky6UQ?2$ zP%O2>0^`XWmAr%H+KQIp_%@b+&mZS~-f5!FD12!S4qrzbb0yd6Y655?RbLv?YZ#=16D{rYGy92wV#_d+mzCJ?WdMsp{K z?o{thrKb=|pI~dAebLS6GTe-VrxSZzqEEk-H0U8TF5W=AtxJO)x6ENof%6hAvLWco z@Br<%4SfuRbEbB65brXJNP3kBhW0%cQ@;Cc z>Vu~@%z1O&Ebu#sY(-7T;!tB4lHF0N^azrb=&%&5*Z+A22!6oxTsk7!y^k^4NK{B` zSU#4B8tWy-8(h)de&{KB1&G(0W=@r7nseV=U!EqPc#Ma3*iKH_&KS%EMf8<rz+459fjFT%ROhYs-p>dh!Oqtkop@48`%F| zGeJpuk!e~RC0%~TMq5QXwE5kD01tTIJ+A)v<7~@37^OQ^3Sro<8H1d{73=Y`=7R(_ z7RDAL#;i8z5lFR%LcB8KAQ;@1Pjgv3-ixvR1AEY6M924TKZIvP>k%ONUQPBiyhWON z_ti4#IKA^&Ot?4l1GS=AD)c4!%Bg;Db(|jPMSe~P_6vN$xmFq{RAXW0MkwcPef8Y6 zIJtb}Xv3{~lCTc(tc^mPqu1q0qNJ+$2x3hxSQG3rqGGB9&|3BgVUFPZN%cW*F}@SH z9{F1&i){q;H-dis!C%HOJ?FA7#Th=~;1;!)WkWpD{@e-)vWtZ?k-~%@-eex;Lo`iX z>r!#GOrbu}E`ubzhX3jhqY@Zz97dV_4TGtAu4OVdRjtE+f0p0ylaZCrFW_tc9mE^v zbg97CO{m%U{h^)n^nGe4MN3w%#A(70lcR>z-`*F+gB@8nQ6BU@ z4J__hB>F(S%Pob<#Q;H6pgrGw3=uGqdmMw6!GFWur{ArQ^?kNaeOy?MU~JbXfZ|lb z3iO~Eq8cDx^YbXwskQ;(tj{^>Ty%Q(wm8s|FPbKyK70dG7MI3O)yKN??p8kr$*18lQZxZfpK+lYdh7gkPbzR~? zv7eC>UFKuBVQd0f6!bW2_9sBh}Fs#^svss{ikYuqW#;B(Y|yi2Cq5Q40=c|O}|D8Q3+#zcmUcT%57v0dZ&W- zIA@?KQy%4d3r(uyYNzZ_n{aKq!k~crkrU`?uqOle+tKu&N%uP4>C$&Ics5Q#(TIE^ z>P%(^^)cA?&ye~<^Kmlf`CO8LJfijJOI(Rj??;gswySE2-FjYy?iipe;tG1OUW2ue z@-95_r!?B_=Xpd{P0=*b_=@;^n5E3_Ylsrm0^TqDYzhq@BHOB}LepSC>eKdpH?E^# zrX|L&T2a|cY&kHh;sJVxS)9Q5In%;NEa{p-*zI}AYwr#!7v<-vNo;w{4g918;7t^q z!gTST3M|*i&5Deo_S~{)`KnM@zId-3-0G3|vmorBN6eHh2+8;B7m@kZUAePROD*pdNB<1W2+KCiaEPtKT<^09Z(uH(-`JY^;){~`Vx+%{ux(Ox-^e}PYf%Tl+qDQP*e4EZOTGfl$BeYE(WJ=M+Um0v^6VgEccSfHw z;bw4`H#|Knpi`~=#Oh2j94;I#KWPKYeDh=*s_@UF>m>#HXQMj$0hMC8jy4>6hmS)E zTK@JTzGAXnBKl_o?}2=hHT_z&>`_nffxNVCi_Ie8h@$DXhGbJcqy*>5Z~eG~!F>7N zk-+thW3p<3^J;wSJ>o@48`;%!JKHI2+1=eoncEGl4Pf;)WNJ+P2nq4M_Gk%J8pG0e(eumE;$$O0j}Qm^zvJcEN4jy=%!9%S z+^h-p-^fir;ceC1J)_ZL6oBUu+~vWfUXR6VHViEcoLZ9Pp%3P^p3*l8J|=4}Vg-fU z5&yi_79pVi9u%y2d=9pKi6Fv!cl2*G&*(bF#d! ztl|8|do*`tN~Yg-?LX_WOysg6!F-4>UjhBS&-Z0Rc`lc)K~hlzUs zMFDuikn$#c#!A0pCK_$wNVM~vxm+lBlq8hLUhbv$ORN-(M*me43wn8eroeoGyDqoC zyehDnWkadKyDh?4t7^2;Q=E6aX{>_=;@ROHoEb6)83-TK8PD~|yqV}subYCl9C+_7 zYS5P#%2l5LdI1=`!2Spyj6TFQS@@|d0`|kDaSib|wIf#wPBbQ8W$m3I-W~JV_YHbh z9wi3Ha%QOFZwAvz8VdUtq@C*}F=vaYLB2_#=TE-_+#jVvYkHB4M62V*_Rw};jZtIe z6z8_{WdDDTpcF$qL`r@^D9Up;*EGcUI>&Ca62EX0#M9O5f|vvMZN-X{`nY|zVL@dNsox>3U8A(}5_%GiMj z0&Jsa$oo$fJAX5v2_p1>{bA@huWd62G?A8)wX;ZrSjuos%gJG1t-f;88^Jf{>Pe3H z=b_#2g5xVCrw>Zm`5`>E7@Ijzj!*?Doo_Nj5-%j?sDS(TMJR{Z`)3DU#x1jaja3*c znU6(*`xUv+DI}F?-_YiL^K-#`H<}2*`sp`!srNAA3wN3487<5g^+b(k}lk-52(fSL}o+H8oH}fgW zZ8Ce;Ili6?2St+dx#8Bo9jo=n-GtO159VE@Bx)TW%CRSV^} zOXP4}xdos%Z?z5dfBTfF4X9GAS5-9|`k(tgYMyje4htm&a>o6^vV?f`GEvf`ReQRv z4Veu=?}kioMI17f0?vQd+iCQAmJ*$>|MLj`yad)G{y(Lfm~@WCJX*-tI>Tg`x@JMKN93iO`qBPdJ%-T%n5b5N|s! zoJV~PzSd>gu8)?J@dI~x-TDJO4qrxg4pFhg>q3Mw(9^hY1+K4)tbtSEvP<`>)5P1o zKsmorj@2e}D0rp?T$uu03qr4E=b1dLF2zFk| zn{A=N!cIHLfPFlTVJ3P*opGuaT>*OEOp1Z|etbz7{@Azg zH(F7AJ0@-vbga0v`RDBa|9kBiY7WHHDrie6wOVs=NJuFu2 z+R#(Lr~y68AQxbKDwR5V*lKlaXkLsfm*KTqsIR%pKgO?vUo;Pc1o6h9L}PDavl59I4ENlr zopPrs$^g&v1lTvc{I0|9B0WRiGxSdBPgF=k2fVv3$eOSI=JA{Sq5BEuL;AY~ypM;| zZpE^4lr=H@{j;pXOF4O3)_Z9{kowe~6CIdOUq`YWG1|W(XxICDeVE?;Gq}Z259R-V zikYNLn%Ic<8+5G$y`^Ptp#8Otg>P`QtOS%LZ1)cH(@G|eydLvX)wBFKXaKeo1fJ->1kX{6!YG8& zTICP0es!!7)#joYJ6c>Y?*F+Drx+)+eMmC3%v71n9(aG`(#`jk$fZ6mpA;v;d)V`S zYB6f+2B1bow}X*-NN{uS-?dzz>pHV zKHGRi^p}qX&k+$ax0L050_u+c(SWbHDBL7aOE=W%=Qwagfz9j7$cBMZ1AC0O6mi> zH{&0G{$=}UWoAWcYXb)61VtP!_FQDFYTi%%}Y_uG{GQ%G08!&&2a zI7`OY_dK*(@HCA-o!kpKVEaLDzz5uK>-*Y9$Y%cQ{b;mSC%c?qizCrun9Zv(l`0B; zV19%sWS90-_PJ$->|<&&E-DFP5drSpRbA;wIY}RQr-DBc~n2i zW-WaFc|J&D!1et?c8GnMo|NY`Rh4DDVt(28I@2Ol?WzEN&qy5Ny)gPbW1E7tkQ$B= z6)?>apbO`W+;d_UX)ROiBm6znTyX|0FB^uH1f)QkojK{1KjFV)RINqRDT-bskIZQmlf!B3V10%tQ&E@^_f90Fx70v&7=B0K(KACG7 z-HYd+$B|YR_ZsZgZ8dV~gjUXhltmH7`4G=I?8OCt{d%<_RORAn9Bq@nf0XKkzzftm zkHOEg`-#m(^I*Px%30ufj{5@(L4m>OV;q@CjPoQm^()>r6X!^p(MKIiOo*52?LpP~ zHm#hBvyh0|$QYH0S%Kcyo(op{@)hTDnEP(X66g_}kpTU3i;tG^LXXu zf$`tCkTv<2v}8CAtZAqjN_g8t3%V1QIg5Aud#yZ>d_4~3Sy`=p*s3EXMyRarqAPbp zSfK}wY?II;oap@+911I7zLMQ@V7vxfjD%Ko(!h81j^gUur`2U0L$5(G^A<|Vm?7Z) z7=OE~Q%9=tMZMFYy4GgvE!Q1v|MNY2u8^T&B1t}1=3z<;(eE#oohUC_Iu8J-9PP>xB11JS&O`(z_TaGafH{ zMt<3}S=Y1m!hUI-KywmhSc9qlPr45R@fDZaPNU0lWhRd9}tqf zCs-XUA@VDiS>Tx>_^@ecIW*Nw-BTnx{R!grt)1$tEklnTPuMb{V#y~w*+<8h4PP{f zq7AgLjAQ@E`R5^!j?zKOJ0%t3Ri`%N^T}j3)Dv4^%!fs_C-+EXP^F6&IM0%VLf2;b zx}ef!0ZT{ z*WLX^Ao}PeEw8WJi23BLEy~1c2-QMBW=icEnk%xM2!JY4{kL!HMYB-hX4EY&)ef(hB8T%Kv+ialuqmn2$M#8CWl=u<^N= zcuV5C@h9j$4vCT)r_#G~JI2$kbW*eSRA&6>J7Y5g*0TLAwZyXmdb z#oi_6Os35l=#f@$I6&H;hnuRevC9&QHxCaG(I{iiW6jj_4t za=tfXTGd-pB)$)6+BFYSJu41dTZc_pPL`v;06keX@H~Z1v70HqdC4@lS0bfKBrF`B z)}y$-CQ_+G5&K^t`B=|qLtjmO=X*n98}{p_*YmgZ!GZd#mVA*%yQ=9$9PO+t(6fH0 z4Xj60oLhA;*4t~c-(&x9-)?^;C*vK1^hw)tTz769;^`ApS;9_I9yHSldk}OuGUlfc z_wZ!4WW)?vNfG%N#M<6~-t`p)@VSO=sP3C!LLwfW`GSgEIW6ud7(%FJdk6BhDS@O_PKBnfuThhI)VyUTjkoxU_tM;bQZWC2$cDm z7r5|SE+-H3s5~B1wa#d*r!|W!tBLx+{L(1Der*kDvCxSwY$71MW&4g>%rsbhDc{|l zg6uHIa)9ce7me}%e;NM&`!4v5YhP=yHR7uXb;N5g0wuevgUzPb(zja1<{?fJNIo}>mKi@@G3N3S0vc~kNBMwv zM!$ypM+PY=4-v1tXROhXKo3Wp4A?IKFXY~;{*t$gd2)(fndFZSUoA1JkgjRgX1|aQ z#QQT{%#AiJ#h(#q6oD}-$|G`weX(C>LBmsY|H6JuHj5Jl^eiSKfcch|!Ej<871L-* zC0p_o86m?HI-<8;1HSuj%wB7Vhw|L^!@V@+vzW8{+-KJY<}Q)g_v_^>@I5rYViaw2 zeAv-IkHEzQ7;nJMM%kpTJ5|f=gmke+?2ZuK*Qo8&8*r2rZUEC?0oD>jv_jkb6(hkMf8 zLW(QjNeM_kITrm*CgB&JQQIraU#yV0d46geDx2CG1Z}COy;UKy(8LG57cnF>koFSb z*!&AqcwI*65^f=9(YTr2_)cbNM?AT;GD_X2r^n2dK+ixvrU7sRbc$#lj*!7f5bJzfK_@`XY>& zq{U?9eWzm8b4LXM$v35wi3kq98}uMZc~iN_W)(QY0$8+}DDML1eDb$%00FczYz<=V^R!$2=wBYwmyWu8t|sVglk7J~)+`&J=j* zhPrOXKl6;Xa@jLX@NFAD)*(x75$@Ty(1G!_4UGW%8+YiT5(_4h^k(;POB(Ytc!eL% zV`?xu5-k^g0q11~fe|`X7>t*0Hm%&zoAL8LGKT9!aaK*v^ zGv?b0YIr+^F&7fS40=j;RY3iDbpG$^ZqM_YS*uj3&EIPhNO>zM ze8*l*A(s-!i>r}HSz|2}_Eh+{G%WcQHDn9V>GHb01U(qV?+uXgffS(SBX(pFvyCM% z)xj-fAweQC5-+;eUsk2G2k{&`CB}Yw-UQ>rA~AYosT5aithv_BU-tGP^dk;t6ix52 zfF87ge=o!n(OrsMZI2&C&VLl@Hie~&6IW*ZkUqq%r@n|ABE>WP1voc zc>wM=X)eD;Z^0N8rK!d&HXlX}6k1u171tZHky^uqmqML6Ti(Ho z*`nE`NeakJN%M7|yL;hUl3k+#_kkON5G+v*mJREg(v1Z%l*l3u(mZ(1@psd|y)Vw1 zJ9q-%8Qg?PSDtw)ll4% zZ8$E>zon4W_T%A*IXEul!5*$_mgiI$^kkDefcFi!e{t>n2 zFUf1+aw%dQbt-A4w;zlVC0)c;ZBDBjbdMn3E$@pfd5uk!=u6dmh49xE;tq=vg5hXy6lcv-8xJj@2F$MteL#nQMZY5ez$dcd^o}|HGu)~B7)ca znJ5PGOmq2FLlymHO!Nx$zR$h_-VZ246_|fVrtJH&r)2$& z5>wmUcmFRgUy$Q>ZrHLQ9=?kh57u}SFL{lkd~{(#IXjk4^T&*Q4c1lDWHq>TY`>ZX0OHiY+C=AJT!iP;MT1b3^r9+a98kFeH5Qvhx9^T+#b zOCL_x&Uzlqc2chOz) zhKP5TmFH)uEEpd?Oe(NG$PT#`%U2y76+|82go~leHPL^BXBG0hRI(fep7)bJ(O8nh zV7|YmY2Wm!rxsa<(L*>FORZB_28tmb6I)0NZeJR|K5-xgdA^|)PBI;eNy^enss{NH{vss_b=BTx4 zoV@#kDQczpvS2YXmx(gyk))B+K>8mYlX6!uAx#5Spk~8GNpi0vqPz6!I~2wBBKmwt z{Xy+ZQ@d%~M)qEbA`@L~d%aE?Z(+W8L{k~!l^)7`n3 z-~V|LwmTr?vBF}DHXIum-)4#+>1pSMy8uqFg$Yf*L6PCh%pvj1N5XVn1TM{DyLn1 z<%N(_(KpXRET~nQM9!5QwPQ==dXi)X@oIQtWpX!p*e-t&brqM{2pN!Gr_s%EbiJ7i zex_>Of?7?Oebw3$GCl)5|MJPc*F27! z(c=-^>w%_m;yst9<8Yg^Z-_zP)|=1Fvscsty;)mPARm}q4yaGc?jj#kbIa%O7GHKH z71rsxu|B5p#JzyT=SYQuG>@InLYwTNzyJM$U&BEDZ+f50_ShI%Wt&Ty^4$MDCU2ns zL7RqRUb-^AK~U^9@uf^yAM|wju7UT}s2!O_TQySij*8R9 z<={(9801Idspzb%WG^Ow^@jXyF+8(R?jy`ueyY816ozli-@0A9zv6=$m&SB+SR$JL zJiN401xS04+%wzO+IaQX8m`Z8T?LM>zPdNl&A*sq8EM#nly~aAFfyhcwtd+3m*_fa zRVNIi&YLcKxLS))9NRx^8;9-&V0@3kYCw7YiaU;Wi3atPUNAVnnIS>ThM~%C!X4-q zR(ul&@tzAd_%GqvtbYdH;rdX`CpF)G+Q}XFtd9FaJYw@rBY)Wt^rXcqf&EjnBhu$T ziL!587^84$(9kgncjexB7yf8YA$K~1cwN;}5-gacEN6m#i`@!pI_XvB5ixD=30`<^ zgqhjE>X4d%9_tn-upg$e+4$n@f`oz0z;)8-f|=HH4u6 z`+w=ATv+f9Z*j7qv1$M1=*s#?G*;yTD=t*AFBEv;Q8`dAETrnhx3QqGp5^j?W5%s^KY9(c>Z3f z&29{k`1ToGUi30M{x?KIzF^f2G>O4I;>Xz2{cImOIc8MayMwaADwMpSe zi+Hk@WHg7p1>g3BSa_=>R;wPihqeO5Q*$;Y3h|&XK;w1lwR~glGj;>#kt&oyOl|^2 zAA{H(5@`#1wN?Z`c?Y4I@K&ZOMg$|g;A};QU7c|T+cS>w!hYmC0{6M*gxL_%m@C31 zV5P=tq?;vZ-YQ0P^4po(&#b9;qD#K?c@KK#PQ-+e{^y7^rfW;=K0^0HWR;4N?BD}x zJn8BXJ73)((lsQ$oMC5ADr*9b!0v^5t9uwX&$o1KmBz`burqjFStIk$dXAt+)DNEw z@%Ghr6U%O$e-B`+^`mt|SsQ8zu*C8|VO?FB0{eADmwGcSw3jYzr`$2;V=rjO)cb7@ zMbxn73396q#F4xM|9RSFqrm*8fXAT~b8R;pIPP4^9QGtaXycOnR^LDdDP-(DB);Dm zJ&st4`0>xMO`Lvrl#J)BPx{wR12_5#SSCmlwr}!W!1(YTOy(f*J#MDHE&gv^Tp@%P z7eb+2`;CykG7Hy5ORFN}E5s|=QS=Hx%~G>V2qg>+=%NZfnGv4p&E< znNtS#H)f3+9gR}Ujye!aX##!sUJQQaeNs(q|1`0Hk;@{Aa5L-$db|qdK!1@JWyt*I zI+^xzepDVS#^B@GNUO$x8?4mByJX<}oJ775xvl$9>bPje9OGN+H8a$~<|*o6D|xg; z?@O_MLR3G{BV>cpg~Vt0aLoCH7Ah7k?x0dGQ_-)=edewng;~h>Qdk{Q-UwqMk&gL6 zz2r}6S`nybKeUW|xD=nU{$}+>|Ey0oI%xgpC3nFA`Q_+>>J0_7(%&J57j)(6=u^Hy zN$Q)5vS_(&9>DY4K6jSP1%?f|yt2cK@MxsO&I_+L)u)X7aV&|odt!XN*ZyF9bN0hP ze$jLE(!uCwOQxw`nZP+Imu@srb1KHMKxA-#GYN_BZZ-2IWkY%agOcMf0kpOk9__2+ zEmt3rS1?I1Sg$K~vI9X+Kfexm-rxN1Y%uRjSI+5bf{P6{=TZJgjW!bNdO9{q8{qxH zb9N`y-Zn2x7ET?+;We&2O0*n`xNEliKCZgtcWr7VoX8 zi{Pkvm+D{be8+u#lK$0sj@GCCpLhGX2&_*>x29)Dzakpus!3MvOIn6cFQ%&Co)GCd7dsyVRu#qSP9WVBZ-r1I4at_BMcV0jzgkpk~`yVR-I zmi5@8Y22T$fC|A;g0C6TL4XX{tn%F@29V=K8! zcC!JUq5g`hsVx%pcAfEo`Ftc*H&iPim>c%%utAI^zSURxPXk@A5#RNOSOeqZ{ed6l zu~7%x+4?lg^zZhwZ^Zco(dNG4i5)($=n^-~+fo18_u3WkRE5>x9Grr0!D!iXj%U#e0?q4bQxlO$BJg!5_GaLUVtWoSx zigwe(^;sv55;?1=rM}NC2K3aUeSz`Y%6d0Rldpx|+WP4y{zRuBYUy1Z=f@+w^X^YCD~fc{5*t%7Ot3aKCq z8qQjTp0R$})Zs`xPJB?|qZP0}*<*^_Dt|4pUy?o%>2yLI&Kp=Q#yK+V(nZy$;;G1e z{wo%YFH0pCsK2gfJ?K*lhZQxCmOZRYN*gj6b+wLih6^pahaZsmw6?0C;WXr=7HYe` zy(I`DiyKcnN-`;I*qy*5Ke5I|cZdT$yqYd$NPcnPVSKR+uH0}wZhHXouxR8bBQ#t}E-Ku~rfI zyI16D8~5VwTMFn+y8H$1oBb)8Mu{e92_D#jw}ZmT3hoS@|d3 z`Wz0pWr1nu6RrOH*!aC5U3A*i{Y*Qw61Xe2a-rHE-W*Xo-~!!LpM)6ZD+f zB!GM+C`s=-7W;Yg7%>a$1t$R`6@i-|qg>u1Uwqsu#LIjR35tBlRCi!geyhaGYvJjh zs6l7&eOVnwx8l6}_4mL}phvt^2|RD9LGjquhtfo(a?F=lI@U{Rc1$~*n!``WInn^@ zwZ*BLLF@omxY5H1Bmauc!S}gn$A9dW%JV;dsZV9VXiF~uy$8-B;P<<^N!@XvTIt=( zgZEp!Tmmu3+u66}*3NhKg@6Bd!UP2sQ`(wja0TaOsh7ty{hc(ITiCpAtl7$6VO}-! zd!$5gVIk8ge-iaK4b={NuzhSl?v# z<`-@$+g^R={+AVjbbTn}UC+X+enb4AQqUv4z@LEhKl(X05@)4Oq`tb-?@_3)s)b$xpE>I;ctDC^i-wm0!zyK(YF} zPvBq&#rpFMl`vWT`JboD0sfvkek2Zxs>61NB=Vw`b_X*}+|)4z$*Y$xXAZ!2GSnrX zS)V2qu|x|@)NMsAL41^RGx?aG<6G__mfE+QDev^E!T2UdHh_FjLC8(@jV6a~((BeR z`#Z{0l(GWj+M5H-_I)Yf{B6;KiR~AE*>ObI+Eb`Y3lg2lCj=(Fp<((Q@pWrPAtErmc68&$5!Z#(pV@^luXl&1g)HS#O4hi= z{c(Z&bo2Qg!5ZBV7NIcs0SDaAiNyQa{`(H?ZtDYLF8efDj1U~wa3oR6@mjnx z3UT&p<>;@VX99N)JWq>Q+nfGM%wTO(9K|9wBr~R)l3a3vF=?+4f&uz-7}?`ldkI4= z+C)GxacpTe);TlBlZQL65{1Z|+_JgErqad|o#RcTPS+5fwr{!3Z3T6p;6ZHV`-<&${IaG*H9AC`e=%j>KVv^>Q+ zg|FV^IK>77%}c4rU7+`crvSL0GgulR?I}?q@@s3!bWMZcfChfrU8w%LGHq=%!<420X>ATe!zOIdk!fwmxX&izBtx# z#@c|1!lm5-=FkS6wg_nf;x(|FUsfNh#Y%oJD;U}$X)(e=Z1IvpKd2n|lKcGMo4Cb& zpr=@t59E96IHkjydJl6w7kLNN0rRbk4{#;MQ4wlb32meh59TG&BRws_ra|y8(y8>r z65%NqeDjd<_I?jhI9XgnOY45nE6a8S=JQ;}#c?D*EJxzWv%jcaJswi0QWYpvIM=m< zU!5QxFjz-|_4#mluWw;K z%8Tr6hN2svLHiMwXg=(wkD2ZSSRc^RSSKdO7bA99eZKDdkrUIQpo_3TH7J}dI&7!D zEtIV@0LCZI2EK3bd#2oXi<#8-z;(wN8KWVY?7h#Yw+KN!#?;M`koY1oj1+Orp{r+B zd|Ed2d29~w7#ED|-@Ilrh;`;4DLE<{20b`!Wev!9%XZ9w8dwh|p$Y7R6=Y~`iRKmU zv#0v+*5!h_8N@5Yc5GCn!Xlrlc0qs&z=a*k>Zr>8NyV%OIr{~^J^&*f8*?w_vXmTzEu-0~#A{_`_NC;}p$lc)xY1=Sf| zT*4AtPLAo~a&^qn9&kRxsYie5zqnf`^|&BRijBl}AWTqGVi9IDxBk=(XJq>!4 z45=iL`l~v1qrQk23OIO})h!xX&>NSHf28zvYLtQ_D1gMr!YA|6?sJ{b=nnV%PD6XV z*pI>6!VIlVGn^4GWBo5n(X*getLO%d53>Dk|N2tIC3+#r=`TM+U-oBXw)V+j806_4 z?m|4>5Nw47O-g=sPQ6#6K3v-2T8qj{ro7ZBzs1|dq^z1;=0LCC`VEkuv63|5P~A_o z-LW(pQAFNDzr@;eeN*)1lIit6ke@xNktcbHc6<{R%&#Z2&rC6xmp4(?W%!&phzrba zIcAaPLC;bE6Br*a%q(jM1OCp#kpv27k2hpY*PPJ7{nf*Mu(@rA#8ZI*i9VTTRao{yeP+9cQGWX=T!>F+UdP?{Qz2{w8!DPcqRFFt;Sw{e7MKU*YJ- zyRx{6TX}2ty4OGtA(p5S(!Ltup~7xv&sx?Q1VT2$6bg9QI}M=b%EkanC;I zqET%6ETtep%y@VxUjrI ztCH8aIP@*WN21FSiyY!jXlJ#R@Z2}^juGg{ydH@?p9qXf_o7m2>g3HETEt4~{pXST z`JMp%538rp+?HEFXia=oAX6B%pK5W%Yispx?rWDT#2d4cR)UGom_S3i)>izOsI*Jh z^>`)pu36AuTS!D*(_&)}jPKgT37FryNZDAm&+ngfgML^cyA3GsSiSG5=+PyAUxDZb z@hs)h?Ct`5OO5XaGC!YVk`sJGZ10RT7+Nlh`P95?|B+`O^d4AlfbmP%n{Zg#K(;~& zJ7V52g=78SkCMHJ6f`NnFaB@q;lDqdmN$=<&x5TTA3rDR99MPz3TUtH`W~muz4&@u z*PDg)^8x6QGF1Za6W2^~&bEL0_yL<=5UqY)bu;;HZgWwST_}6Pi5udTKA))m9C7*7 z_@>S0`+i&Qi2_ORYZ2p})_11wT9t1L#g9P`X$aN;Qh$Zy=I+H28yIV8rX)H?hZI>g zDPbr=hn)!sL%@3Itp>ToxDJBZY)A0YjTi~<+aD+a+gCm~rqITSKX=WJbk9JqkU|`| ze<1id|3eLwY0Z4&PsPCGI9yw5ujFtQgI*~gS~W;~V)N)ZnA=iALp zID2S%yt+IZFP1xj_75U$KZu99&TAxx${J=^hA`$m`5r;{NvO}B9>>IWIuE&YT@GF9 z7wE-o8Ug*qWMl8uJp9h^$iV><+DU&}sR+to?mXonMges_#N)pxEMKQ`KMiFl7cI-5 zzuJ>Pf;oCFAnH&u+OE!<;QMtAdY`D=fcTQE1!(ao%Xo^AcOy~Iis6GiI_QEQYwki3 zrGfreXCS0mDMm)woJTZ`2i4~Y*|ZK{ssyP75CA@0B?Q8-gXkP512b!dps&n>H$ zr#ynCcc3R~iwLaOuC~&@TJP}}?rKb~oZKWin#o@zoVGswCH3WxhIsR9M7hnbi@ym1 zhuB_!NiA)eXnY?mLp>)Q<4&JR12NE)q0XG}9t!5qC*!^lVun}fYipvO(i4(z{} z+nfF7G@*7W$KM+6;bswh5vzN-*7G9zXXsZTpOP~(9r$^l=vn7I6~lTxW0CMvc%!CN zq?vJMUd7DXa?(A69+8@bJ7j!(eiyGUUSIR5fJo@DO6}CTslERCOC6?iB@dQ)j{g#ry+4O zx7PH-7d>GFLVIBtId!Tp4>#P!_t8Pm%%}_a-q#D!s!`U!W^d*{2+vKU+`ayOCb7=0 zYtU|}okS3icLI0c0kKUmOCTSWv|Y)a*2nUNRc6);(_C5$Vv^P@0!+};5zGMgOQIPP za_H%J*hu_84*vIh!f^~#^Fof4c7F7g--aMwY}{$dclKZsA%PK&zr?|YF8U$RPYDHg zFG76kInu(|1pj#^2$jJ8AN5PyR(6}FS}ccFGulqOCA_PIoqI$iYTR%gNOeFxYrH)z ziFj0L!6jr<`#BQKdy(<8jC@1scu3w-)JXZ=B|aD*j1N6M79#(L=Rk&tLa4BX_6u~V$kzn{REuPR4urCeqUa+ zwP4dDnwgOK1_1*@HDhXGHDl(G9pdc}- zR0p1j9F?%2rs6ME8h(A(2thqHXwotI=S9_X0`03}v}oySmI5;n(qMt3`kRsVG>75%r- zk(+ukSHk9Afa);rmSn3e9Hz-zXc(5`#jQdQ@$>^s`w$Y%St7-)X%xz83{K6NUW*Zo zj(vYkc)<20V{nTa^x$IZxgnk&4*l7e-CKF;4%=7amISuN6nW<1k7wSMSTk@C&lodw zBGB{$wwQT!j3BLxNA%g{rC*8Af4@e^=<+zJ*!b%O=qV060Qq1yi6re|y-Fd8_jDgk zPySPXSS5m1*tC)R;U8dsjmpF^-+}p{e2b68lL&LqSJi5(uhJaWb$Ip=^TPg~!=uGo;# zsrFGY>)*JhKc{)vU5#?qn{j~NZR8WszGS<4Fwf12WbdW-F5r#pLI|ZKIMA%6XX-wF zMu3!8OPTj+dugC*u4{stso3C6%p&sq`0v8vHK`G~`$v|&d9Hu;m*Fk|sXr{PV1xg@ z`TAHm-2M^j-crl-`fi#|F>FBmO`JQ#lO-NFGa;uZOs@B>z`w@Zn@^MjnUS?}A2W8X*L-VlDb49w*KEEDVTO82*l~kU~8r z^p@?UY|ZA@eUU+I!G`Crh|esF3*p1t4gt`M^63WVUw$6$cS6YUe^higlKzr%1YPVn zGpNGNvPo*WBtpD!=->}5#ZAlWT-px$%N0uVXGW`gLQ{rWdb`O#r!$zF+xgI>(`IFO%DlNt^5_uG6~m~FV! zrxuVkSU&}$4rI$7Lx=PL@tF}&TvoMpBNkyZ>O)oM1n(UW9S+exfbewP5f z^V?9svxukBl^kU58kP~d!`#p+U{Exp4Dj6Zqw_bSf_S-)579nJY}OXOeH5FQ4n3n` z+%pmU#9~+E4n1j^6?$TlpjUI81LQv%y{GOv#CO7y1??5Ao&40^VwBT}C3%UH2nxXS zTNU>?t5!TMmr`M3%78%QIVDcm1C~-W-ZD#vQc?&%&6o`65llG%&-+LTv0FP-VZ=PG zP}&5{5#uU-`?E$+vOJ|DQx=f;W*83ZySR}fo9wk88`wt+ddD0)Xq7(4aU@Gjre~3$ zz{-N2;ODg?2UFqk{cvwzQb z4>w9zVG&!`m)S|Aaj;!sPy5JsAP0J+ti8bf(`G*ygXc^MgO$dyxtzA23@isSPrE^; zb8!J5f&9{|eHx76`DP!#a!V~jWNkCuQI4c@SP4(y7{l(yVdAIl`G|C0X2 z7kRPN&TA1x&@25q4XnpCE%V4Mh@r55XotsntWaMJ5(>k9sOB3^d|z7&Detm^Oe@V} zXQIJ3?Oe<y7sPy!(aoqG1}e zO`ezuoL#IBrAvY5BZY*qTGv52QMYd@LWJLNWUEJemwZ(vloA>R3~iqVc?>l{k0L-G z*snvv>E1-y71u`HjsF`!;^&k2`Gxv=48b0Dm_N{8aICbHFwWm6w4~2N;rpr$ zZ3uc5pT~gw;`Yfk%JJ?TCnIwZNs8Nl9naWc4d>zfwqtJ^IG_IfV(`D;L~@!Rg;5e> zG?@~Bf|G|aHr#3O4K-gvkB13yGXg!N`VpXg^QWw|m;2*XoQhP}ZW0zSXkB+_8RiQ2 zs5TaeA@QwD+T*@&XT)dB#S=G3{T>k^(C@zZ1JPo6-~GE>Tf6ttKaZIPJYUuBiDRou zUL4$`^ZJxJ1bpu-&@lhNc&*2X_?x@ipXGy)qEZ1u&uza*q=BF$RQGWz2_ z^Nmwu&l2K2LgI6|Y^_iAAGo-t%N^x*68c3MvpaDqpI+{pF|E*H0(bmi4#wB=t_)}o zy+OY3zx^g&D`>eAA`>RbowV^xsx6R^DJ)+A^QEk~J1j*utg?{i@;U<7g~nHMp>R9nU0?NB9hUs_nAX~WeAV1NT{V#6`8h{6pls3d z1KU}-tWwgiHrb$KK43qmi>HQC<$HzJ$(nq9QbzB>AYEIi>62*z)ac`E7>8Rrxg{8% zYBc!$2%~}}OLx)IN_{5t>*^i-x>|*{FISm#1lB1-!@8MsGUz)sX-)h)=`NUu~D?7F{Lt&pIYgTI-eKnP+)=l2Z1aECa-YatuHWBf~sdFJPeU zSCTnPUQO(P6M89OF&b#H(XpX#_Rqur9Rhqm8-CZKbly7{M=JXBdf->-z>z1X(W(9) z8nu~r6%ekJ{{wu~D;hqH!eL|tj9DKNWEj$F|M-($wA~^xPIzK8Yp}dCt)@VKhT?U= z{Jq9cDlRJKyu7flxm<})E>Ng1Sf)l>4e^ktWn{MP@Rls-tWnSjf6D4yKR+yB+_2GU_n^Iy%7Zq7ij3##@RhUy;~N@g2kys)(G-~Fh-ClZ+1(clCheJ= zYHopplMH;LFxLg-XAbFDPH~$`Z0#cHZ?Ok&3%bdyr4r+a;!l-z;fD3Y=DhxS(GJ+a z`rvv~6Mi%SWnEpnaaY6pVhNMNfkN=*@*QuMJ{zRG@v{4!1>`*BiC#`P-}_Z6%U~** zx@Ym<-#N`Ltd?*y4LE}FoflpK`x~kqT3Y9hszQ_s)uaqZTMcm%<>cFj9NVvoV$C4l z&Rv^me&`6NYhmS3-0y0J7KTfO4ie`!@_P6#Fa% z+NiSlCu8UN*E(AVXRJvl@|SjBZ5Va`Uz|O|E90C`UP0bgU(2nr z-9fLaas*h9yIM&7l&-(=9UtF`3VGKVF&ugkCGoLf5s!o*6ylA1MQ6}kU9+FRzAkJY zMhM=gX=;iHA{Gmpbv<#^dmhpD06l|-6d>O_tWEBZKe$?Eo%{B%eSAGX_`|%Eh4ia@ zL~0ALKB!yVd(Bw5K#R@(I%;u#5t`r~1u3a&&e50TUYvAksCVn0pohm50C@0)GaB-r z_Cj*T?2iVhLOOyS(d8MHUWBNvhTmu}1Ht%ED1?Cc zxaD9fA321I#s@Vz$T5ur?|}OZ0T@1<;}UTzN_Uk-HMm6ih*s#df9B=CY^V#ogm~Zi zLa8KdQlXsI+;io8f`^c1FV9)nEfrtlxe10Kki^4=kTux*g+bVN% zB~y$~{2j;9_Y9s+L<`0fD~LxD@KK1~Qvk}Ac04%43nNJ{k}|Urp{cO%%PaLcaW{gL zf8KB!2{0cOIxf=Bh|f3Q{;f~&kf!JhNjA?wvv-@VBplC!c>i6_Z@3hX$5bSFlTLV- zdbqF{GN$o3^&80a^pZM}%Ju zwcrjqVKW@`Mp+Mm=NbNv2wG0&Ubf@q=->bSoMEcZ0>jGdR;IDH6TbKm@6R^uR={(h zSRDbSaXNy)myMs=PHZ0v-g?Zud_d3COJ|7!y+^eFKCAfOzn|KD#VYJo)Vy<(C+cB! zHNL44wW%Pv`}x?UOBLb`+#?cG!TlIUar3V3#zoSrU0wW`H*9pjOBUKKzdbEe9SeG` z{13o-*JA(eTj?TMDngPgq9(ULY@SVg5}fo`=I5_u)*zk?-jgxWe_o5GT)k zqD9#UqBCm)sW_hAp^2;1IM9nEe*u)Y;vRc0^sK^H@du3S*QshHF^j`CYJK#^{`ZvV z5D!KPzLvkjY09yX=tphbue}J8yZfXu*~3G$G_ynZIfc-nhJ46Q(=&Ie*V%VxUhzAwN-tVQU5F9-8(9&}7PP1BG;r(OjY%0SZte|o4 z3=DSy=!qdm0R2yZ>aC~DM>oB;^24t(ahhjIS7X?wLwGjnrzI{BE_Tv##O)M^i8t3y z*kzROB69fsW1spjMJc+^`Gul0+*OI7_gbhGc-~i=-Ih8};3dH;APai2^HbY9+$T`! z?6(40$U9_+hbKBM<$x7LQbr8xP_DD#NnyC^Nfn~feYF<-Rzs~(oi-Wt5`W_W@p0LF z-p}T=oeekrY(F5kj360?Y;VrJ#P!KC7sxLpgp@kr?{Yl(7+(yOSv#&a9LYd0^ccvo z)n?%-g>{qv-f~vCzUyJ`L=%%m6BU8qE8VoE%C^NPG)f3?4e; zdUP>0Vzr?YACP~`pLg~01n)v~Vhp(@c<-pBfbqp-umbaWiM?m#)YZ=W@RW>)s2Z!2 zObZ3a_V@x_?pPz>ev`wJVq%AiBg0=F0d^(3!X~RCD%n<9U(3#UR27?}Px(jbp!d?f z0eJs6kN`;n+i)nFQQ4_+s(Wvrb9_u&FQF%v=BEE6BtCo3kJgVVF%UwC)^eZmV+Q|gHwys0KBTerZO)nDq{T9}z zQKIWMD#$Q&SWJvnl{X552IBEk>+1F243s%qrl1rL6{XNlvRg>=PavqEd|{P37SVyp z0=-J4QXpSpaNXmhGlhTY4fMj$CV^Meu2Rc%Gd@_Njqve?cnBi0!(nS#A8+PJS9UY& zp6A4{$f~C~En{O&W3hX8EyHp^kEr5N4KhB|5SPev3saQ#<~k(|HeHa7LL5mQq?8^O zQv;|VUW^#uSjl@f-va^5yu}?yUug$s6WPANAB(DXMfmsQGqky&wqRm=yY2u%sNSDQygZ;{f7F*c(LzH8;> zC0kVC+ZFzc&sY@reTYuJqD|deao*D1(lJJ#Y;!2nTaJv69x!mSD`JrNY*A&0Pdpw9 zlF)D&IHTozWG^hxs>sei%>?1ev{#OF#{Bb&sKEOXLgyO+*IF@TmN_!i#M3z7|EX{yU&_sUSlHQW*B}=o2eYOjreNvnTsr{7>tjMf@vR8 ze<^TZwzf_UxGQZeQRBEn|g{13MY(-%82T( z-izZkA|;*f4&;~5C7`Fig9WT#=4oIP45Hs%m1boeBqXN3htWK4e2U2Jm-f_P7O z!cUha?et5d#-V5?Wkvdbo6-O9z8c({I7riofs-vQ2R&M+Gax^oOkTc)LqLV0`R#P% zF;klL?ZBpv+2cOiknn{y#6vd=r8=bY9D&`Rq}rnyL4LbbUwt;@RUI^LD%KhP<({+x z^!5jQf%VH#RWC2!N0TU`A3i3D#jFzi;b=v}#}wgxKWc&f2wcLft1)hLl8eo}<{84<8+xs7wx}2Lq?=w`pDy04<$v+sPc=J11F`cr0y5{?a6&-9CksvuNnm)|`joA#GzI0<(R>ZjKJ#Exw5 zKaXZ<&VJttdISk_zWTB~_=#0-G|zzj*pCk@Z^N%& zKg(|w`u{2+xa>Zdn!utnXEW5$^6WIJrhd}_dL0em`~?TVSttS$B(*=Ev^&vZUPd3 z`Esx1Hbv>xrA%IRd!RQzF*z4qx@wP?PblUev_B9p>UFHqCCsOp58g~n26C#x_~hP( z4$ORb+$fHpo^1;YTzf$e!Ehcp&udWXeCg>@NHo)j&?DVN6X_No)Bk3g`;7a=Xa>ad zN;TW7)!j8pzaI+48SMB~A@i4Q8JUxO&|fKfXZ=tIwh#1n5{Q6&KwBSuIxSE}LQV>4;0iu?@e565?$nQ{$J?rG9oS_x5PbOioe8?+B|<^jj2_<#$%bWJ!7V z&vT-x2IeF5CaUSWpAVS7_d>Ha zR8?YImQ?zd;x&RO>x23jhyG53b z^|%F;wd@G!NuZhm@4w9jc3fY_wI5k68kKJ_hA-<-FOv!eIkiw}N%TU>t5XLhvuVLk zvF(8oUBD-jy!GSn8&;=t;nf5hWNYbf-9Ns89+GJz@cow~9~m-05TR-2lOf-X3{x5lB{9BZxtvggJ3-m)%#5#zFx!M^U{aN%FEfQ5XJ<<=QSg@iB zNqn}$hH~;Ao*9vJ`k%Kd&H%K>XOzR*ej}@z$0ukKmj>C@3suGV#Fj?!R^we2h==>T zo1*KMiw#;4{p+*GsZ?#d>hNpc%ySHvJQ6sO)KI2LFg_*4Ent0RtSbEeyA|g`653P` z<#KIlbz@=M@V&A|Qg;ZDuT=6KFH5BRl278tT_U;>5q}R+OZuN83q3v~42LGh$zM-_ z9?1gKS4h4RSi$}t+oU@n`H1Qvq81>R=Ab`d8OtslB^7D|iEos#Yd_PEDl)=y6s5?5 zZb$qiV5#!Y>vZxkiJ=v%IaTaw&~q#{2I`Nwak0AZ^YDrclkYNTHJ#}fqd!{k@=f0y z8KGW5yg??WwDxy}DLL8_3O~&McFh%Wl%nsY3LaT8{@nM{c{2Ow73X^b<74Mk-&vJo zw!jVBX`ydlR~70;vHc>y1#9WI!3xBCPl~Q%G&j@)wd$E}vKY1;iMroVriMfJ@k=#A z2}_oW-V7KY{PLzVq`ac(2ne?=Px2-^IfD;}H3tS_rAcmR2W0qk(!lv|x`X`H-ILyo z*JQ}CTWWh|##?sSsqRM8*FoxcqZB_Gq31x)9VQ%@-%?TdRMj1&SE=-y+U4Mw)^L*Y za|61vO^>@q)FAQ6PdL#S$A}l%qoItqclm~+UmMM-Wc+<~a(ly0FX=AKxd?i^vz5U3 z@I7hVt>!Vtu0q2$UenNtz-|e(OcrNcTb)q7f_P0wNxj0m}FA*tskdP4zaKzS8WuX22#()ri=;ax4d zD6IS@sxaxQ#6#b;8+t&zuMg#PlUHLp_Scyb>eic9WON@p)|r(hz-EH^-p z=zuc|(jKVm?^w)>7u9n@fl!B$|IWkYzSuZ|7JSFks(=6$iI6u?3 z#)=K3+oF?~Ew8Yn`vq$Pu|AWqs;2()RAIp1qwnRpWu)=*ln7qHad6MBedBd+KyOHq zboYgI9T>m1K0Q%LOK-g-Q#Oa~A`^@`N$D&U|Kub6mJxfJNfWOe`RAEheFes^DmlTg zPZb5sXn9MQk0l=hbZ7PPeGrfA37GxvAn_?PO$o4W^te1~xmU|s|3tMypZjE`mHK2* zVN0FGH-c8V1D4l99Q?iGg|9B(v0uIDHeYzVbLnU$;)TF9YWx==%;018F~qZn8PgVD zbk(tBDf%@?|}WKOL``u$Pg{dkV|X*#N!zH-*5csYM|Mjh^G5PylfLzKQ)YVy*|>QHU$JFSKmg` zmTA#v7%QP!yNn?H52gRSPOb*PbD`Wfs77U(>DYe0d6VhVjrN8Ykc6%YW61@S)V zB?_>dd_5}5LS_0x1Q#;Dxr&UM3O#;BS?{3XP43gb2bPz#Hoq9spOIg^V?FjrQA(7l zf?JiCi`#Or;EWkbb@gRw1-|DY>l`;uIdZ%nW6^$;jFlT5gME$v`i8cTOYF;}KZEE( z`9A3J6(a-d7n_<(f89(NUyih*cljJ&?&&>04VCE4S5o zuQ9`IYakvO^iEH14AL)2{yZ#foeDaR_=kHlDzEd;DmW z@K&iyTW5vi^V5F*COZxe(B>O!?@>z-`M_c(XC& zCL({iy!$l*nhw!2q`azc2ggwQEwH*q>ya!;ig&2{eA*1J=9Mo}7zMd3ZE{`zfZhj8 zbl`b)=0?)H)x2hv>3=lcWmp!?0tR4Oy1N9VLkVf5Te`cu8)=XR0coT=q&uagyF*F@ z1nH8HI^Vm?`OS6RJhL;iJGJ}Ho-VEHDvIS;SGwZojv62i-~i)s$zP|T_&Dj#hOi`E zUgdi9-!}X{eJvf0;`-cka99ns$@BzzhA*&y^)OM@EZ1wdFdn7UFzHn{`?btp>NZdQ z9Q~tT%mX3$s^z5*)2(w2K9w~y4yLW!I*O0E5;%QfOA5{oRXV+z(|PtBPr&ie1x!0W zjPm*^w`ELQv}2{_$PkKs#&5Q)E3}NC5HFHXh^9>IEE0#Ur#Q;*vO!SS`0Efy$9|A) z)DC9STc!Vd*^cl){|FU>N_tsj81D1+I&^!Z`?PZ8?a@9bD|6?X%2$ZTJ2LR9U?!^C z-j9MkTUd*ba6cd;$aTIgahGKbZ-lh};W;0vmM%Dd^Yu0EmJ&*QV&<~(dF#6xfhuUa z!2FbAJo0>aJz=9sMm-8^By}Wv2W9rW!4&XSJH@i~0Eod=v5z0Uu@l*cqXI~)s z25~f0bt=pD`5zt%8<-EM`Lv%{-y#;YSb4uhl<%xqZ+!Ot@lpfVZ?UYF>d!qRgGmgX z-1(8IrbwODqn&8w(WiGi!2aNHe@AT7-?|QQm8S?wz2m6&N9aC`m!>;=3#cJ7vnGf9 z@L;~9`gGv@S_0bBhmmbtXPiI#Xk4#oR_L_E+C@qlF4#n0p+fRSguX$$2^QMtT@KN` z=y}ht`wOY3N+yFbi)L$_g19F04HD=rnB4>CX+k9)DS5|ui3Q6q4TBV1J|un*i!>OQ zr4Q1&9)Nh`m1gK8j2Hsmk+zTDJae(hbtqVC$O1Q5TqIz7NEc+%pFRFra-e=qoronp zI{91JHy^$l=KLXYg39})yrYM7m?ZNS;^Cf>eQ!vg{#lfT5mxixZ@YC|ck})!4p}sp z>ikC}G53=T70icEBL?(01ByNILPIlDX~Q;BI%&@HyUU4nDS8!MONMsf{;bX~`q5Af zNdS82H&j$``N6H{+**CX{r4MYMw3?Qy=J9nZ-yHDe%<2O*QBSy5j5>qlI$PXtfUb? zIR!Ce?NX(TUjWyysSJ_&@S?Sp|;fw=ZKW^^L zm@`r$&8@&8QuCi&Uvw+&naoa>%?)-Ax=3a9C9^QWd|nCzz6ossS$9X*c33 zKDDgjPoKClR>dD(`OXcH`fz4~{>HLK0B2F`96P#zDwcR_Rn5o9Famph&wij`C-(^p z^bq@?fd0lX!$>@Ov_4NW(RXpeKg3{3)`v5aym2ChEK>;aUd8s@yhfT`FLQ}=9uShk zJ@)V2s9O`3^lGqzMHAq;Qo;wlZ&f8g`@=q96)6AUqk}i}OvC;drylJIX z2J|A4q!+4{p@Kn_5$rMwOv7U@0W)| zZ!+B@<%98JuQ0amMcEo5GD`j|B;Vjz$fI}vL+;ryUM6$E;5`NqmJQ!9~4(k440NG+bql+Iu+@GcsG>ohVSO#OmgUj?34Kk>4l}|rhjn4 zxnFtEvbi?jipe~CVeNK6dAG^y#kD8@1@f08B+$9zen5%;%z>vxpn(}gL<8|O3=qCU z{p~^c_gakRUT7M|?xtCx*XxDJy2dfQ@wl$1txG|T=wN7fa znA=Ju&o<3pW+go^$pFs}Q=!pBCI#eh^7URvHwPQrxR*Ie`{yYxu1gM{h;$pW1dN~u zFPu^bxqkWyz3|@-Q(ei|cFq%L9OwCJa0*(|^VbKcpN=5;#=RN_8NX++`Pj+A+Z`RE zrW8lFbHp=aI9^-~C?pxDJ3V__2;lh~_Z*^Jdkw|q^?bpX@h|!553g+DZ%9s9362cw zAzt}`UE}Dc308cf0S156yqos$_Z!JZTU$38bQa8__=xsrkI(ZnaQz;Q{P51pV~4{@ zh5f9Y8~!o7ClkNKL?sFy#s&7HM9j)IVHH(NDu0hGoz+dHhY%39c4k*5AdQKdJq77;N}lS``AggN|B4OW;tsUeL~#ASpuxr$+wP-%6za7&wNo5 z7>6mAk?~U|M>VZ9YhI3Ua_PpJHIfzdxQ+9H^;kS2Q9XueeLooSZj>^PpkfDkVjiq) z?H9UuW*d<5njdoWLW@}(WY8%f6K<&6hfKa;GMq(-&f7`4cQ0+f{Q2zZXtx37ef7l^ zd)2!6kyFAEUbl6_wU7`?(Eq2cTYSDNFh2De3Q2O$`_4fTE+F0N-e%S`jY3Tiz!4owidQMy%5|EzkGw$r26(M9eM>VQ zihQ>&u*6Ks-cdHZ2CHepOC>7mjJ*Ln7tRiPS0w1b{h;bAjaNP$-7T_q+nv6GN*5ludqnHMIAGNW@T{jzk9#|J;Nn$kiXaM^?q9G_aa{utZ2>C_x;lo5V2%|H< zzM7*ekKf55`(TJTfF%feh?MaQkoL?Rh23=UW;5+k(_^I)-A{y#B&81pHma_A;FSp^ zUm%4d*`46OY@6dB9)&BzZg?*pN64jsM}40Z^Co??ePa6iCzV5{$8y?O{Q z|H`}miuVUo67&=*o<1LwaY!n}bK;7wn=Ks=5$iH~WfH#b874K#?AkqNKr$Y4OrzG| zVj~WE89R-@`w&_pdh04tEH_XxFv5%Z8vhni15jZmIt$_8=^r6p5bjmx(S+v$A|Z-Y zQ`riAoUf^yg!K<$R*HAn-Xi_IxH6!JaJ~kt|9N;e{$-y&hLTy66b&6_PeeXbl)8*I@spNN+ERO?0%ss? zKJrQjzO*e!9`q1P2mtRUOy}qCU1y$=JuU9M8LD?`lLg|4!iiK|>#tu7$DM z?Yr+mSv19yr}(@FgQKU*#l3aCm?5l+)=n z&w*MmwA^QeUw-u4wQVU!^5#4-6t3B4-v$?Z7^`>Xke-+4Of%%rHX`bWDd3Xx`cUGCi z(i$J@xcrTx+GIs0J-_5=9*e1ws(@a~C3t=VJ^r2Y(bqId?|nbqm^tzpqiI^f2b%mN zP7&*JNWR0bF|oo}3rV(${Q(QQi<%4E9m}G+(``ucZi{mfzXYPyKu^-M9XRjkRX-0q z*3_wJnldASAK2m4Yrs2e!64;j)6xjkuSDGNH?yq9VbsWJ=doio)E8{ku~@(LQ9h*m zFzY0uZqllQ9<0v+u>axxwNUmmX8%$?{Oe@Bi9)*7w8Qvhd0T69+Em~?HA9?aH_1C| z9+UF(l1cjxCtos(bT-LF@j}lrhBntzXm2ghLl{zGfLuR56{Hl)NcEREQ<1ZbX8|8c zvKflwQ3QoANBPtt<#jY?*!fFbl{CR+R=i359+9uu-09zN8saf6?Jv_E^HWPb&_iUD zdIj-P&#O;$n=@SU6~77niV_+cL-jfEX~57ko_VPR@%G#uZ$_Kc${+u@hzyG`mgctn zO=m4${5I#ZrNlf=o~mdJdZYGC!1u^@d#0Oq7Ipm_X~@NRJ~w>+>b2!+oGjsR?5Rfw z@i@M-3NS5|`3~KVxZL}^Y;;UqEx4e}&i5T@n2^zOz-@l^h(>pS@y31X5A09L$b8TT zCu%&1!6YS8#0PFZq`mMjW}P9PqIFx^4+Q5D36B`g$Eb!BLYt9p|KtXwm&5QX8sB~` zT3dqo^j&y>_q)B(SJeYXX>ti`D=laoa~0-x1w2C0Y*(of%MBr3VuNXwGVLGZ0>qpH zyZ7+2+@hZpD{3ULQq%PjPYrX$JDfld)#R2Da{W9va<>Z78V_0{7!?-_7iMG0k_a?%NIfMDM&DY$chdI1A9C*Ir!>dJkQ@1% zIZN-EeCl1tTtz}9MV%9u-yA9LkJT6Wwh-`VgTQn3KJsjgWeEBZs^2gN)GM~Gt7QZD**mPE6V+w&o2;e6aF$rNFyl!O{7IG&OV!1(8K!D#RAC}a5J+zgz{tO1t$+mt$8{Z3mx(S$`ZkQT~S6V zNWTBxYSsUt`p2W9RY3t)U_|vQgub**guZQwRbpmeh3Z?~t^<7IdSTfQu&-F5%)=!r&&|;+`tQ{wCf*;6MiC(eg z5{>dFgWh$JJMjEfAD=k><=TmO{$A{w8*afDD^ajca=`oqFrTFS&k= z)-0u;1$8eWTsHz_J6xc>U9c|{J7S|$b7`o#)#LIMt z{Ud>B&8Igec4&b?Na#1;|8+H@-b`X{H@q+g&Rs4W^hn31fcaL^(*pT$o z5$_7kLCRYiCz_i>>#ZriQkm%GtgT&q{44nlwjC)hk6IYS3sJ{z6e6@}FKbc?`s!Nd zXZH!!b=#&h5qWoIk0JeoDS0XAA?%<4*RPf1B?de+Ou4{aKRf1D>ZR3bGA3&d-v3FKOL(L8u{ z`>z{z6e<@!!ZL+v>hOI~?&mqwsymO#X3!JwY6SXkU&4GSIrpt&z30qG8(KXhswZw@ z{WjOi^2jHVwQ2iiB;rij%MLNIb5)OkurCVjphui*_6L#= zJ@ZC?8CuXu^uN&%7ELi+59&Eh^wiGC;TP&}5bwXAd*w3dQMn~az^3cYf;tW@{BCki zJ-R{KPLTbxl_cp`Kj>9`iJ%1PS8MRk=TqOyg@;gXsXD0qOY5(Di;~V))QGnp5HH~n z!EuE?AY%lFFv-hZlW)N+3FY{pAoAGOdT4O#vyjUG=%rHO0`rf=J?+Y(1JAfSkqSl< z9t(r2r$jn+eS1EhFzFnKhw^13R+8?p52N*jRM#ekhQks=5$BW2ZR4jYCa0!epQgB?8V^LV>e}!bBoQb+|E#e_A+l+GSVjE zuojZfJlERhi}@kHpaqG1H3A7GBIV)b>=6f-j?|~9pKFF8&Eufw>6i-C@32_Z3Z<59 zRGGn}BFB^Qfu4mX5inov zHr`wkSVpp!bH#*(D!;EfXO(e_Vr#}gkN&9(@uF?_8h8I4yK(QYaa2*iz?D9gvxFM9 zHkzN?!+l9Q)Rg?}B_k69cl9Rt=+^*c4+ii+PiR(9}>dY8B`i~Yz<9?+lv_IESE&iMf9v&SOn z1$2Pl3%{W1@?Y6u5=^%}{cJBMiHSm8mH@w1U~D>Q*AFT0&Nltx0~TtN6}u?^ZHdM1 zSf{Njj^pbA%4ChtVjp@x76-4q=272i$p~GtpIY0mM&jxsD%?PjU;IP>*LgG^mCyVhwfccC*~)Ki?`pT ziH2IX|2u60>@OgBVq`$t-+(%r-&7I9vh|x-=zYuj3{GaGJ>?ekn+f!fY!L6o@ryV$ z=)J4cU1R>*IdmB)t!kU6aLET`NXb+`4Fm{ zfc~aTFcGYDy=<_&F2-lLHb=!_j_yED=m=WI{cv*_d4ruTk2 z1-+sOA7Fm|Qpp}WMd`1+eUD!gb)fU@EPcVji*0XK_Mu$h{G>w0NhV2>zal&?Y~=FDlrTz{WLXf3;TCQ5^I*E z>Z=B{zuIQnki8;FMa+@^Hu+>C%#D52OTMNC{Y^^av2%O#?UDQ0d+}!63DRD$Z$xtG z6G*iYH#fS4YKv-WD5<9FM5zUIi#`DBYZ8=V`o4Y}+faS2p-1|53k`~C^ZaCOZWv8u zF%t#X1;5V0e6eY=zI4E-|}SMqcS}(0i$G16;pp&1|mk_`VMP$}j;@wr`xM z(fhmWwZuN6*40u#Jb4WAeB>n@_ULX5KE3#q6Ey`x<~uZQIH{C z?WK~K(ujIp0zB8y(~gv%o;lmT+~@w;xCxWRyNjOzBG;goZORRNU%*uI=R?Jr0(;ik55CS99) z1lwHV;UFG8yHy>#d!w0^)){@+KaAcvj=kPIYdQhXVg z$E-nti+?E3t0TT7Q&Ots&C)sRBS|qJA3ALp+R~qdl;VV$-*Du56()`J9eilctyEKS z7II!ke_lL*`TQ>#fbqfpYHL_#r84Ha+a^bcd$!eq(5KOttS(? z{bh9PPa~dxL2rC7$5#pqdhl^}J&^17TS?X};r4?#-8Wzd-i+K9`py+b7A541rL(GtThjbNYaKrM$^E#v( z%C=FsU%!S2`oe2eeETk6Hh7&_{He;M1;7Oy@~D3^nOPOJ0X&7x(Y+Y z$oi~O_iKpf6ymegVrxkCEyRV3`}YfPEvKXK?7idZ{*b8PDxj{WoY3F38G*~B*2itBIN1@6!JO)bP!+kTEEza;6sDzq$=%}3yK|Cq1{PEUH zGU(2{`ePBdaEDio)14RtvdBEC*o&r314p*VpqFHI1&sd$IUbuCmDObsRtMKR2S_)M zsRW7t`>>&7f$})8UOYQm`bnGrN_VfB%H!9Uz^`A3R~sq*`+mj~DnZMKM&=?j6wn*{ zI|KBOUDOYRnr-Xy3^{+=s8+>{Ov`YKw9`Dq}sfjDSQ5VMiZdLtg z6XMZ|E`+(S6%KbxooKWltUqoVPR}1_B8Q_P?gW=b@_&@V1U>g(c0hltO{I9U{oO^B zV4u~ZZRbrSufe>Us)?GUUHohaa?vU9LMEL(o*9@QZx*aLw8uA^pvM zsZMLR<||8x*Bo%nVUT7biZwEAswuP*w%2FeX>oX=k#>UNDA1`t7Gs*()Q~v5ZEMll=)ySkzCC?xDO26Eugo*jrvN>Y z(JD8{^;`WJn?-2)`d?2f+84TfHJz1}B}{@(j{4~;Z-MzV`&v1Z?#dClxvj7;o`Qp^ zOz|_h z4tO5r@cU@r&2p)!)GmDc$hwg)bf0Zwb#9T1u4KA_@Q&;Y1vThZ(}3RxVR3T_n4WFK zXK49nUKsJDx+No|nb-uyfi{u=%(ray@+xh$Z_hi=lBC`p)AWp+*DFfVZp}op4r`?e z$5jQ;fF2C)q8B7zUSs<7#AI-UbIVdGEao=_NeA>VuNWKzoYlC2^)SLRmN;-`x;uxe%Hs^WjfFcbrS&Y zFXLn6uxgcBwu}UhlcDI)D*Gzlh(&|zGzW>9Kz+1bbgGU^+hq{@+4>C>U43jH%GylI zkC&LMGAgO`f8jNT@=Rm+ii@#faG&G zK0rROOQ~s&Z80s*pAQPV4@}0~mmmx07wfHyY{lcYn^Iun61&f9|>6wBGSJuB`dlL0* z&)yFupuAJKyMfqQr2NM+0|D&Vf2ZD&(1l4|zseKqdu0R3=ZM2E7&NvPWoj-ND5!mS zA>dad%%k=o9_1nt%)8v0_T$;Zyz~X;NA5*jR@$$xSqlSAJ^ET}OA7g%u=sx*TSBjJ zK`sZBR?1SkBhJsimTQW(+Kn&nU+}>;+ziKjJu$T8JHm6NrDF&4<-Ljo>i32T;kXNf z!j4EI97cv;(&P30e7G%jGVA4_Kd?R?N7foS*^_33D)7`N*ip)$EqAeN+pm&G0z_mF&ku`(BpJqdN5 zT+x_Ts0Mg4RUGZbbJrS7*H#zCa=0Q}&mJ_wTo9x{DG4Sqx66vb)8;CTYa0b`X5S7( z6E&x?JdPY#K|Cg+su#b6e$d5K7;D?8SNl7Y^rpge1jN>O(N#7u1=%U{fcc&d8i4%( z_OP&Hsy%lWmWgKIJZ8Pku^{6JZC2i;t9ob=dV4)b=g^48 zVx3`+3+kfF$V8w3=pFhR1M7(!&6*UiP1?*N-zUi!B|v`>`mPeqo9jF8v+z0)k`ITC ziXiS>O6G$BHh;GN!5w*HHwrWF`c6h3=ABa6*6|T}!Bjrn{kas;$j@`r2D{ZGfv-Ru| zAi}vouAdf?qgK)J&#~Wh0mi0F`b#0F^Tuo(xRXPwAvroBE&!sAJz9OB%g_Fm1mRN zk>uBaaHyNk?WU&eysdvtFpEE?Z6+c4E(vY2%WMQmxzS(>TB@#!8WaHie3}8HD9pF6Pplt89OiB>V4Z>lAlEw0_NwB+o{geV`OIA zC&Gz)`(ptc+Kd>nmvs()E?hII3bLY{YM@6tH3-Z<;QKmF_@*0`yC#nnikQbTTU$;{ z#fF9&5_V94^9L>dyBJcY&~XZy&}2?YpGXGkM$yXoU^V$7H8SMAhZ`G|Ko3dkH8-TZ zJ1JE6=E`I|Ga5b+5sSl4exSQ><$umvpAmyb*Rb`l+roMOmnqMpAXuyqb9wN`Y z1lPp(q(INVEONR0oNqdH8+ae$Y1XVYw0r3eCthQnJS4)WHrN>>jmv|>J8``T;)OP7 zHhg&H1jRd<(2n-9mysxvcClAvqrz%6taCSH*m7JQ%tvTq3p~$_HfRPaI_Q&|6vSBk z&B}ar=jfGot4^{l^D;xOI*} z&0p&oW$cex9IMWhoWz)8^^BM`=J+AyC3l<&N)1$rgNqdU8{}f;|H`q|lZDaOtJ~W) zkt6-9C7luI;RQ);1MRsc7G|SchgZ3-XdQ~R&`6+KC2LPAVr|AY^c>>JeX1A!R$n8t z&&FXCD}F6*b-z}Lli|C#{PpYOCoATXG7HeVFKQu!cKK`$)n0cbAQv|)Ccl=ZF^~1*5O{?+oIHS#N)*opJ@8RjL%9M zRVNS+N?^R?rMlMgqO86@%oxmS5OIU681y3H0^Uvd_DeISfM-unnHOl!Db}b=rjy0} zhwwh_*`5+5DRud5{b;@OIB*fOVH87N$=2XeVuInnkr-W~)@O$vsVIo+i}JwuekRoW3nrRy*+!Y0rlq^MbKi_qX59W( zfl2Am4}aoGXCV*JW6@^<##hL}iN1r(^MuUS#WY;RJ}tZj&aGI%{`jx53nA471wZzu zVq+`4El^|Rk8CV&3oS3H%55vZ?gc5ig7k4AL-MmHR%Hx~hhE|#6WkdP(D*H1=cs(6UWVX+_3mh+_Ae^hnw^mlV&XWudQ2f*hwVY8ytqwJ;8h? zU%>AZGIbr6lp92w)U*(P_z)x0d$soSNjvs8aXVHkH6-8b4@Yi&^sp{{pN=>Lu(ye5 zcB71=wv^!C^m;?_8GbQ@`2c!pKM{cWbo?k!=m$7l?~Wv=?k3?DgWg#Q9>mLs{NM*l za)|f&UO0KrT|e*dYzu=+;9~~@ru2u%8#FnbJE2J!Sk?l5FVNFZOaZ(W{TavF*ZKnQ z@gr-(PfhN*2zCe;nGBhr!?w2|9+?#nJ2j1zDvd{QWi82^uDOL)Ew)<6#Y24P*@y8K zJaS*qqY)7W&Qo`uHR%#sNgIvikP&kGx3>+5!TXpuSvYZW1_AGbrN(ui{Psy;g*Dgj zzn!)jHaQSRKf(?qA85^v4z4__m3{WedU}BNOwDN+ftPpK|JFxK@qD#PG~+fVR%-ms zFe=LN1SFreLBRupL!dmu%=PV6{oNR^5>!SvsZEGXMhn^Bn9n5~0boAKAHzVtQEErY zTx_}O^H{m)wC{qjObaDsmpLu=`5hJP*l-=@)j0_96YM0zP2Xnys)Ebv>2SsWf?s-g}PoJ1JlMuTao) zN-_Y(FRk=hnp7mH4|uhfuW*mYCnHbvCbr9H@aw{F93kGrQbuZZSsE-J?d6@kZu^Ud zVT8|1I0w6tN4y_!m*6Av!$I%#VjJ-2(&F=jI+aO|HYI*Wu^f+e(jnQ`w0MDb8R}|Oc zv({-tqU@7m6??En#ARQOjkFG9n85E@#&tRjS=v#&#m%7(P1?7R!rdk7^N?rC^P?SL zI}08OB##HZ{&y3={g3YcAQa;`z3PeY!eDX@j$&ixb(#l_o@S2I?gJ!W!y3oKcsmAN z84i}i;)IwA(;MxiFtZw|Q*tl)4Vw0Z{v^=bTxJH=uNGgtO?UQxxibyNBX{Zc`}|g9 zG8ZY*3X|4&s|?~DIvvrYyPC;R-LU)4$WCg!^ZmN%_rZ$FQJE1AXn$YPixoVFVWle9Xn36Z^Ifh|t!OcK z4}+XSBr%BI+MTzjf*uZU8&JQdmzeOy<+$7qr4knd*vzcm--i2q_71MwTV1;#`3n0F zyzh3uwGHL1D(ape?Kc`}p?(WsD@F-w6>TMSx}!`7y;TKSU_N6->~8ySy7_T*N5wsI z9Om7Y0>Z9-&=h{#lUX9fvo;bA4*!iV{LVR@uLc^c3(gDoWB9W1jOCndz!&qx#@=Ud z47(jzzdA?%A^DdM1@i&s@sCaCyueytVKa0^1xpiR-6q5{AHoS((Te)$#b3N*hflya z>cwV2CJ4uL=mS-CP9Dr0mcgB_Qv>d9`Ri@*`JTXBb+h^yM?G#jp#3o+kGRlEj~zUY z7@qUHjf}Vu{iDcigfU`Mmc5R0^Z4ao40`avd)knEQMSemzp)Gr`?TqCmTkRcAFsu* zxHs7yRI^*NA=l5Uw#D#f)*{plJzr)&Vl~;oBr$(XWM;XaJ2>fcr3Rr>4d?~4#R2En zS~I22^i8uWt_3gmbdQY^?6g~09AK#8)OVt?AYQc$&ODl!ITy*ho8YX4azu8MS0QWb zRJ9oIykD`DQ0QXTg5K!S7Er%kpV0C-5oChpD;iNO zk6lO1LPtj%f?A^8`mYk=g_L#v3CkUK*WwwirE2y)y8Mmlt;cTf&B==m>kDn28(R;0 zHE(x-`Am!ev%+I^VHdP$GoM3U3wwU{nOm9^vXtJmTO-74%-SPQQsEoD|9Cx7)~37*W;_aRt@TAlS0xhpyjkI) zI>hT#;gBRLAvR%5%lmFe1Lra!Y(jb;NK>3 z(O&%PTA!I|`c)fBdbm5a3e^qFKN7^M;q`O3ezaX<37k0b=t9Bd3B7TK|JKvsgCfx9 z)kV_;dO=2Lz<6!@ddC=Nq+{BQe&}$@xc$zfGk$DX_#9`zPz`eV*X?=lDrln z9e0TjDl)y&c5+NWyylu3@rokayr^ygJ#2-q!1zG?Pqbc)N*zpqD~4KpRgUQWUNSjj z>Z;c9lo>t5D?>yUFqfZvGV4bcS!+2PS>1&l?JDopa-zpC7Uno(p=|@bWVL&s|Cany zjA*D1NF55weXEb?qvwp4bOfy--X=xd*beauB$|%QG+YKpMSPmM<^~X1|2l-83kJXp zm|cxaTD_T}YzIAJLW5jL{|GEAy1BvIDIxopu;VC?`+lFshGH}2liH}fBrsk>UOX4l zMkJdd`ZPya>EeciMo`Ioqayo$&VPJLXxNm!>)9iXYX;^YHX8c3yoTI$-#J<B9hN~V6dcl0T8^pkQ<<&o;Ep9=Qz7(ZR zHKgcmZrA^Qu4Y8>lbUJCaX`xZ;%vHliNhf7`sIgs@0wVLWkkhac-U8jzdpuzXC=jp z-adOzwczh>(GhgC=OLoeud%JzNYbx;^Iq0OPxeMr0x^Pr@HcDmNZKY zPR?`HW;l`n`tSEka#<0?Wk+5jlikk;f(52or_^a>ECRozsVHKQBKM<*K<|;}6L7zJ z(NZq!C8DJHXG>(gER6Pp&LQUVXh0*@^U1LjM@X>2IwmlXh)T zuo*(>&u`9^)1^(%o>Is$Fg~pzt7*?b=BlVPN9vY*>wYnqRle#yS#!n9sYw7S?@+|V z9XqGSUE5#&&x#b)KZU1078o%VQ!s|BuhQG!$G;s0^L^_D&#N$eM~BAQa%Erd-P-8% zTxIywcX_0a6iHIVQ2Ptw8IHLOvrWGosYB#?fs||no6^}ypiusaK@4Gdr7~6x^==gO z>_6lK`@fm!AxkG=qzPO7whstrd187Y+%8ssh(8Ss8v*+%&3J5~d5Zp;?I*$KDye$m zjXouk6$1gal&r+=%>o(lFULTSfg}?sFI@&YLR~SIJ`uZmCHYL28N0J1Ataw;>Rjje zqDrhs5Jf3--HEsDZbcWHY@$b8@CnhIa0Q$61<-r=%?FfMcN5*}vpB!UnJvM&jpOmW z`(m)LP^t*7?g9M*#Pc`Zuv{Vcf->vKDE!q~L5tgI8lZI5D28RfGuKYn7H+WwdQd0G zqmcf4v2WtU&6p4YTFuj}F`Z@? zqCbx@QqkFzcO>33OqD--2M8WO`%}rv_i=h!(99$l{H@bF@coim{Ce_>@#&;RH3B4` zUDhV$?rHB~q#rdw$&(9JZc&wUu>?uxw_&bGRjNQo`eiU5aliubeCy>PLDSedODe=f ztCygyFyeb%L0>VbMKIX?#uwrZpBS3zP*QiID{C8@z+2>Zy<#eH5eXH9(^aoy@p}=y z_Uz&876IS)2@GjWHH4ldmhb(Crx$avIf(wV?rR~k!4b>rpAgUaago@(xUc*IHa_8Z z>H)L0P-X zQecBz2=R(ekS#WFQPo7HGO$_Oh*BiqP{s2tWPGhGuRGi9`OR#;33_a`SmcoUz<;dz zB_~3bE53ac4}a9j{H{~aUU+KOHqMd`7{5%+HT}NOY3oVnsq2waupPfOd;7}z8%@c( zwn%jQ6q5qk9niz6leK_&_sL;HA8Tjf+v;+YbMB5DCf1>-TAL{!S_>CNAo+-!@Pvt5 zZngT-BVpemlC2$FEB^B$?4?zQbG;d7#l!r- zI-rgh&qi|cdrrFjb`LD?WWzP^J~0QohLg!9a-;yJ<9U*9zU*Gf`&g~w1P?Mv{|$)8 zy}kK({*XqRk~W#`@y(Yn;`^sye~mZx=MFlx8g53bx2K>7!=C>da{W@A&#QHi#-sFP z1YNSml4#e^RowngoAz7oeByA`0AJPVKd$$cSA69*_E%#qy>Tj1twBdUm>x zIkQ|DA^8&6YKQNjC1DHn!m``3rCT+Os+{*&{}!qiT)$76bd_Yi1ib=&d7yregF`S3 z-d#Ib=-j6Lb!BYaZLhEjD+(%!-O(?Fp%m8_Nts z#&$x|@9};1@QPp$AlHv!+~y8bHZ)^kCTXfBwTc^7Oy(TA>QxOZ*w8=o>zWSru!#7^CF|vWH@!rw-2MPm0wxDu#vsJ0?W%@ zs1IDf=&;@_1M5UQp(sCk;thLr(&`*eCdFGJ5?Hn=>Pl(f_2RV9 zB|@RfqQ3O9<_cvqc#ysZy|&Mf!2P+-GqdXUy#wM&N9VT{+PDa_46?&-R252p>B-C> z`Jj2qZV0_8T#hb=RUFD=`xZGK=$4>%CA(Z}ZSXG;=8$ecZ^IrOpZbb8G$-5b2k_e| z$a9XxNzAox=D()r5Mx!F2F_oFyFcI&>hVykm$9!(1VIUrM=MXTPE>M?#>6r`RCP>G z`~y9nKMO$r2&wA5cPYp3t4Bz}-EAvNEMhdJ`!FBCT-C`4oL3={R^HnigKGIP(KKk# zHl1Mgr!VApeeQH-AH!7IN#*d`Bj^c>kpkzh(t6eu-|MS>5V>Z@t}>jmIOjZ75@dO( zx=Ri#LK0=+LxhQRnwlp-V} z19ppDFBtWu%Yr0asT0(oEbIuj=p`I*{>o)~cpJ9)z!x=;U_#Fu)a&A0S9=Rx%B04D$7<-ef%$)x}{7l zw@f!J`agN$BCcIRJk=Ttwoqa2MOQ4QHxUJGFG71?&3axRCl~w{iTRCj@__vU^hy;R zf%}1EnO`l&jSKYW#IG6J6EUyJq%=(|2Ty|~kX3Ub-ib1&Od@{c^gFsMUgLjK0s>Md zi29@iV{a%kFnd_P_IDtH-d7$tV7^-2Add;p#Lj{qg+-K@Xzd9V;RyA{6p!I;+8h_e zOL3|zQiN+pSeD0o)YI(^SSuU0+)`@niBG}!bi19U>0+p`vG)BlYgfnB+nCf?{Ky|5Ug&ohL9BvoHXRCIvu{@s%*<%R903U-TmPUw zb4=yEIS$7GJrBEPpng%Y!-bg1UE{HZnAy?Q?)LQahIo1-18;fl(SY_$|4~3J=r@aE zx}x#AJWTZ*v&9;Dpl}0i zx)G#Xx}_1M1ZkwD^Exy9X02zv->_%TuC>pB)qlsLk4#uc+5s;Fi}b%-tUDci;+V`( zwrH_UEEpw{HgA^cCsRei$j|Ye4_;&9AFzMMuW_tSnVTFnnnD+l>d+&>rWoPD9#Rx} zn`HvNZ`6|UCWG&83aDTU?|QX$wuioO@-|;rqR^jehEd|}4V#ca^{RFfg8hLB)nWoi z(Ko99!Zum|s}3j(_=_MoZ0{~ol%$9bkTUv^BtAK zp8t2N;4ovZL}(eyimw=rBa8H&(8FcNG;Tocloc!S_2kP7n6lx z*kV};bbWX#G>w3FE}!JoZGs=^MZOuGwiy(Nsl9P5Y_j2oI6v=BmYS3Pk@6wmn?}$} z>Bj%5!qdOf9)?$Vudh?4k-19bcD`a_QqKqO&#aq=sA{DczWGTV)tnse`jX!Akaog4 zf(C;q^=zc`hU5APyHh_S}Ahx0V7d-%_QeDKN6 zCsCzN9;Xu~cCMnv>}X1Mu=Qw!w>ElE7^Y1+&Mrnx$c)d6&GByRvta% zox>r4`G&RJUXt7=sm;w0;32{z;hd*X18&LI+4R5IT zsDBm4OJ6cj=H2L@oTZxZnFaEQ!zu%T_hZ-c-ledYM3zUbqT{rrNSBM+wIa2wUiX=l z$0Xn>*sE&nufB`%dSaJ|_ajw|`Hj)bo~N{J@>VRNc|QNn^s_;pu81etUdGm)P_(v~ zgx<%*1l;Ae_SC5J^FJ%AhT&^yVgO!k@UiXRbn~?d&oRkH-w4O6q4f@Lot+pN!uM1! zN38AxxFBz70Y9uStmmRe- zD(ZrNM-C^r{%o&Jz0=KEu+Mghb@0mr9X0NwjC3#(7aCqq{p^2}dG&;lMD zzgG2AKd-~)mqHG)lFMu&^60G>L;YK>-Ae<&pD8zC%&5fT&rD)@=!sRxFM@Trdh)lL z%Fob+5`^mceAxNi|Kcr*_?I9dc9I8wu@<<^#n8j9^oaOK26fD-*20g2KEsc7*UCZO z;{7(bU)FMG*m;*jo1%VNU}7`KEovIE_vX%w931-Z{kcT`%W4r+1`E?M7h~T(;HDmbF5j)@}a#^03`_hl}R&vvimPu_)qq;PGdE&r?h07{6_TVinj)3cbEp8W8VtwcV z1S^&9OgJR&_hT9YPA+{*cbvofK)riO3Aj@wVKz6d7gBRUy(7heF~dRr-xyeBXlh;& z$nIzq#7&rpPH+u@tP$!q7K`(}rJRobkVZKU%+h(!}Gsi}4qbM@*&)e$VfsRN(Nv%3*2_$=)_HBAc1SQjhkU4W2!;kw**13|1rcf)EG~D4gipJz zFS15>Rk^^(_TbgQV!-dwX|9G{WoI;o|89%nQcBV5`=*P|sf4&1jQO%`px(>M#<`fO z#Me2S{V4|oCvEb5JuQ67(LB_pj5i>&3gof26jlr>|sg3B`8gvdu;Lf#k& z4|tx&qzJAty7LiDco}NCMgx7UY3Qp}A`PtkjObx8z{3}!HTy5nYXV(&7yX=rf~>tc z%N1qxzfwIdE#I+dH5p5N$a|kpLkRqTU8ml$yU^zS$+~}16hE-#kzmtqYd`rN!(PAP z8{o;X8=v9E5S7&}kRQHeD>h*qkd|O9SJrYHWmtn_SfCs+fV_VPuE73}^fk@UW=6D(!Bbe7TuXEuKI z^!+2OPL)W$_~4Ne`eXtBkI~F&Vt$gq%%G!{%`C0e;R`~B5XtitiQd5MZXjQTKHGpN zr~0EsiRV#LjS}Qa2tF5oa+K&bm^N1K2OQT5O`&{sHU(h&<6Cj~j;Z7RJ!0Us6rr<6 zfw}o{1YQ3b>9MTBC%|hFc2(Q^Yu2I9`{pP>!`cNO(^Q9+`6ZldkovN=*w@cAW{{Vc zKMX#Es5BeZx?YT1Fs#~@DDitYay%My22t=cs4AD4KKm=R4Yfwd%dX(=2K@| zeP-G|m43LY%%WzgAlDl7J?d-E*P`F$>wf_6y#vE{68twucGRj?e--IdlrQwP@nmGH>zYiO@E>RUA#7$6+lSCgP2Rv93n;%{` z4Q2A{oU-3n9K(hO@k&if-{g*2i8}_p-?>h{h4LXh^ZX99XLiy<1rN;^E|NA`J(Q^l z2PYPhhjzt#j|Zt=jsxDfTbkQ+tfd9~B^pM0w%LDC@f>vUx%}*nG?`B^__U|GogifAk&xd~p2lU+Eh9|N1D@@lu+l&NuL}%N)#V1PzyGIXwI?Tz?d9lyiQB71-0M>8 z3VDTD)Zlp^R!)zrp8XzcqR$~K=mPRM7;m(64t&zFQR5DZ058Xu3Y~@Q-!0WHiWthC z@{dREQd0?LgnoKwRyQfra+NjKt&?yFR!%$LN8sIq5exDFQ|`8M;2 zd$n|n0k1-XtMPNS_McmSlX8V`5NnHLP(wwk+spael4VoxgA zpSlJlc9fVE!r&0>?Az(tgfp?%3H<@3UVvjf0G@RafUC?z#fYk`B2gKfc?kmou# zX6Nht#0E*%iIXcDKN#|I6`|k9*5*eW2no60gNYV>pF`TzKaf3{E|A&WGwAgM&#U}2 zxXPr>*Ba|>+w6lmqRh-Cq|=vwN4zjk;}y*FwYhp60(q@6jo|z7SDy}z)q}lOV|0fw z(XYm;&lG_^l^#t}VI3V0$j2sblso(E!`ECdEkQ9RXO9Y<63gEsrGyOi8%t8jEnMyo z9t!*d*q(QuB3s%uzj)1}u2NvgZw{ z+ba0|VCVK(5iId_&~8fYhzvAG@G=?bh>Ue=X_rvYh@HxafaaC+`H9>Y6A6&H+<}Fi$NS(#nd!13={WAn z-jC}wancJ7*$nmjGbfSh_P?-;ew0Y4-o}k5;Cd&yWkRpY#=b;;b)_aenS@&=Z#4%3 zrSgAe24#e${RBp$pXA$b(oZ;mULX;M#SOo>U!=QPt(j+3C#4RKeAu8TYO~j;vo;o zV{j43cmFP2EU5E?j$VS_Utfpn3XW*A!(MGU^GL1%aKB6{M~onVRj%PcGL9r1_6IJY z8e>(r-@Mv`Y5 z1oCkqigq-pDTQ`6eZ<+1I{OTxm6BbGKo-T@{vC29-XlK#;9-6n0NXP=sj_#%q9O{d zzY;B)0+B`+!LK(d!=WM(*`(n2vX@~#tUFIWeG8@Kju5xQ0z=f|Vxx~*e@)fTZ9Yl7 z<69DxPqlOjY=4%29^twVP7c#5;dv=3C_FufXA7qujHg#l3IYGW8_iBS^|+!P2mJ@? zl6a%)xy|ix3;a?9?i)8HSdX4QYEOkc1ojbdeqKaPO;>|^`C`Ia*|gUtGokB~_*zn& z$j5z=m&ic9@OF!NZodR~R*LvjRf(h5mpAMV`RSMSIs<+bs^ehM-9C8BYZzerORm%) z-CSIH7tA+%d}lz6lN2&IMR|Z@r>Zs!wrBhKJH~pEM&|eAUTUqp2_0>)srfq5gi%@C ze2rLYMfs%2$vkXMoX@YDomA1L{B4b#~O%Pvn=AhG#`soa+x$j8njqwiN= z?xRqI)`RQd_46c0-Rm~U(QjPo%d|x!aa!Id$osmW2ln^Q*9D%&B`_UABbpD@ez%EY znKyYBGZj^vgG1o_qc(G3!bq)PHJVNpDqTMSF&Aam{Z&=UYE%YTw*%p`NtZ8 z?YW2?fk%1rjI%6`zwv}FbcZ%5L5^6}Xq5ls+$oUn#g$9DckIIG6e;rfuN?_}b%PYq z11G%S^=D{arQO$vk{OVPczg@)Z?Vw{P^1$f;c2EZd$Gh%ccbpEAGMh)8?D$Lg7d8~ z(W(V$g4TuV*(E2ZUe~9Vm(#woa|6~xXXU^~ zcKo^}u6fYOJz9xV^`&fSHjwWcleY+ou-4;Ax#N+ z9^^?kGlJuB`d^fYC&Y0!x-n_7`<@kt5!9Qidp>K@T{V@D0WXH`CpuF+XD>}$Qeww8 z9GgOh&bS&I+-G6QKOwerA!pz6Ay3Rp032^TFGYZFNObZY%oe-o5_@Ke>gBDF(VdZK z&9)5g2f)weq(3rM*!5)Y$?NYI`q)VQA@R<73D#lS#(@1!lS;M#^0Z7e!S|yngZIfg zW{o z9VPck8|J;NmTgJs;OKWlG@hBw5Uj>JOTz@E zcRl3EHmIUIfVX})#nTa>n7XyN)Q)z>dlKvP4&7^ho;Y&rG`^KdzCgMZs#n>Ag&gSr z@|3@7v&7)ox~mzkRHqL8yCkFldC>*){^IBp4d99F9n!j!8&t=tid%##T-A21rd-;V zNq$+ZKiM>{;SDP!!(hH^)`|3^Vd>NRl8^qFKXCGB>Kcv4;bBG#mmA>zf`hA< z#oPA#mc;%_-%>|KkKp3@2z<=9XwsD_^n<*55U|o^Igj!Aav-cNKMM|JvH#dC)&jhnTfAnQ!E=jRK zc^!COSF7#V;}nnLj&NOx!$!!f3zGz&A9Bf~DJHEgjZAj~l(z2FZ}GF+lma)l^;OxU z;CdLUG(&gOdUi$(>JrxHG?*Eh8zn8p>yY!z>rHsOn&=#^Cdlh;X9WAd5*+eXb_x6Q zCFTR13$H5^ck*3!pA7P$S^l5kesXO#zap)Zkb(aA?%Qr!&uG4C@9`>sYsVOC><`S9 z?`z*RL!Q&KO|af5&14S2nOE`337_(?wxqR9CI5C|kl?i4@?)g{^il7jIdz z)%S~OmMB$#M^;-LX)>}1N2e9)6j533Ey-n*BNS+*)=9G2%Fi0*SpVQz!Z(2R!l=^K zbF#Occ|Fm&R10iNnUgIDLiElYxbLttsQGuutAX4Ft4Md0us zKk{X)$k>EdD4$@$3fSMD$iwN&)7iLhk^BEULO(2HxPAC5JubN96Pn`_!2594J3sz% zgn-Q5qLSCh{fQv~GC>4&!{hf->k?9eHiA{(ATPzc4O}mt@Yu?5&Bi*Avs7~sn9 zKPh7z?El$0H||&gc%z8)4HCueN7keTyQQ~^8Cro$lbZO{?mY1YBBD4@#YXS`2|8aG(z1z7$;n@M@Bgp6j=Wo?MZSfj-xpNxTZyJpIhkAY^9j_id^EbXEx7G$c z&T%K<^J7B>b%DcjOTzEe!~VIX)&e=9gtX3!@4Hgd&O0Gb{44}~e>L)X$UGI9!y1SR zyDG(Bn9kYs%X~H(jSk~Qk_Eg1eZsv>9K?Qww4UvEA{%-hNB(tRo~551f(OA9>{a*sRr{M7#=#dVMbu&R=4WiH@cv9F*oXqQ~n|_ zB@qVa(_FO@1IYEQ7?}M{biLV*ePLn3$PBOkx&-*`XA+STgv>m6z6@Dle~+_!YDn3K zW;7~du}&LMBpdeBf($n}S{gT9#x?`xgvckk(S%~ZG z%_WR@`|sxy@9*I#c&}5ydK=Bwh<>u6TTR-8`_VTlUHZa>6c!2^@1|sifa8sf@=ou@ zk_|UEI`*I<_(>Tl_$?+WXPR(wMO$yCN^0h_2k!+E2l#&QR(3vTA%LsPefO5>T=g<; zSpa2{RmKzDeJlo?pO>mBXBJh3tQv9_`ccmW#>{+fy`j7jJt?fj3Fc1y&nKxL%4aye z2G*Nc@3tL;tv~?Js#j|H*j(ii2OsM9zARK4xIu8dt5s*TH2MOeL0s#7%TP{}JY!eX z`Ih{f%*0ef=YY&a*SQhM+mJq>2ih}_7W)QFFr1?Ft5KRY<3Pj5+&Zhi2$j?%v=wlF z!6-{szK3rKw>bXF{X;mzP4rkTOTi~8V`=lw=E@JvpCrd1PbQ!iY|lTAK3uBIau3cU zJzX#~Q!h;of5y+uQ58HZwP6Xgm*9qJ4$oW~3nVRh+}veE;m|+l5l=p}+@IH4N+rZb z^LsydZg}e8^Q#wlTRKI$K8ycFW$8><{ZB=QGg4Qsm!EQorXJwYz9I@NO_R`h;o$B5 zx;k_1P-<1VW@t7FaU-8sxFKeTdJ@WqiaD4I)EnTn&@@0LMzTz#v(p;Y?kxP0Cjm|} z1P?WGW)1M3vK0AZ_~+~e+vCIAe6PDSNq!sy9`V2P-MS-5yR?TB)MGd~^qQ2GlI$&Pr~-`Th&?7JtB=0`;1n1WcB>waduCb+B?5(v=`L z=pEGa9w9yVc9R4=MK628Ll`*`>5Sm?;}NJj@$% z6zm2n^QwPgeQIo7}iLYKnArF?$r5vq5`SdKQz4$eQ=QC={s2vou z=sxb#?061jcg1}dT+DzcV&pd_C|9$F-}`Ckj5_+cC(h5w<<=#O9;YdLf?9?nnct9? z$@dY=SBwGwm99jgDwmX2jS@dxFb`SCSd4X(#6A#<5Ad$-pN*63^%9eDs20g77Iukk zwAx?GZ$FCkd4!$61=nEu;Mvt>fc+o4p`U_sIngDDqV9N{7|-yV(dYCk=5J%UtBgbe zud{%2{_a*!t5|R{@%{K*Io0tX&64ioErEGW(gxWO63#Z1Z?!85Jl|=>vW9%yxOSZD zcV&se9fKd674fm}OPT=7J|i~Z@jTu8!tRu+rCx@bs%1?)j)Stx&B1!Z??ut}l1Y4rNjSJRaH~W;1ykDiTwO7t5N|WR7L?sobO< z9*EUwR3F|GC_5fQ9zLHjxL(JRPd3?$`}em?bR$D5wP&dkf&GQ_MoE6w^JWjgyB_{1 zz+|i%8VrBdqJ|nN?RlwIp^I%4D;~pSxFmr=&U_AeWTS#$|JVCoU-`fL0)zSWX9|6! zZae Date: Tue, 20 Nov 2018 22:59:58 -0500 Subject: [PATCH 241/383] drop [test,server] extras from travis and tox.ini --- .travis.yml | 2 +- tox.ini | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 105b20b43..3169a13fc 100644 --- a/.travis.yml +++ b/.travis.yml @@ -11,7 +11,7 @@ jobs: install: - pip install git+https://github.com/PyCQA/pylint.git - pip install mypy - - pip install -e .[test,server] + - pip install -e . script: - pylint --rcfile=setup.cfg torba - mypy --ignore-missing-imports torba diff --git a/tox.ini b/tox.ini index 853b9a3d7..f57adac09 100644 --- a/tox.ini +++ b/tox.ini @@ -9,7 +9,6 @@ TESTTYPE = [testenv] deps = coverage -extras = test,server changedir = {toxinidir}/tests setenv = integration: TORBA_LEDGER={envname} From 0fc864c2d528e2667e6983878d414d221f286624 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 25 Nov 2018 11:08:13 -0500 Subject: [PATCH 242/383] update ignore path for bitcoin_headers --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 3a20b56c5..dccab0560 100644 --- a/.gitignore +++ b/.gitignore @@ -7,7 +7,7 @@ dist/ # testing .tox/ -tests/unit/bitcoin_headers +tests/client_tests/unit/bitcoin_headers torba/bin # cache and logs From b2bcf39872b5955bbce21979310b60bf96cf2385 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 25 Nov 2018 11:08:49 -0500 Subject: [PATCH 243/383] 0.2.2 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 8926851ad..6e6b4e6d9 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.2.1' +__version__ = '0.2.2' From 9e5246c6193883f7e9ac31b314f4909745e8a664 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 25 Nov 2018 20:51:41 -0500 Subject: [PATCH 244/383] drop old style classes in torba.server --- torba/server/block_processor.py | 4 ++-- torba/server/coins.py | 14 +++++++------- torba/server/daemon.py | 2 +- torba/server/db.py | 4 ++-- torba/server/hash.py | 2 +- torba/server/history.py | 2 +- torba/server/mempool.py | 6 +++--- torba/server/merkle.py | 4 ++-- torba/server/peer.py | 2 +- torba/server/peers.py | 2 +- torba/server/script.py | 4 ++-- torba/server/session.py | 6 +++--- torba/server/storage.py | 6 +++--- torba/server/tx.py | 2 +- torba/server/util.py | 4 ++-- 15 files changed, 32 insertions(+), 32 deletions(-) diff --git a/torba/server/block_processor.py b/torba/server/block_processor.py index a27c48737..2cbafe041 100644 --- a/torba/server/block_processor.py +++ b/torba/server/block_processor.py @@ -24,7 +24,7 @@ from torba.server.util import chunks, class_logger from torba.server.db import FlushData -class Prefetcher(object): +class Prefetcher: '''Prefetches blocks (in the forward direction only).''' def __init__(self, daemon, coin, blocks_event): @@ -143,7 +143,7 @@ class ChainError(Exception): '''Raised on error processing blocks.''' -class BlockProcessor(object): +class BlockProcessor: '''Process blocks and update the DB state to match. Employ a prefetcher to prefetch blocks in batches for processing. diff --git a/torba/server/coins.py b/torba/server/coins.py index c83b7522a..a73cd6948 100644 --- a/torba/server/coins.py +++ b/torba/server/coins.py @@ -58,7 +58,7 @@ class CoinError(Exception): '''Exception raised for coin-related errors.''' -class Coin(object): +class Coin: '''Base class of coin hierarchy.''' REORG_LIMIT = 200 @@ -268,7 +268,7 @@ class Coin(object): return h -class AuxPowMixin(object): +class AuxPowMixin: STATIC_BLOCK_HEADERS = False DESERIALIZER = lib_tx.DeserializerAuxPow @@ -284,7 +284,7 @@ class AuxPowMixin(object): return deserializer.read_header(height, cls.BASIC_HEADER_SIZE) -class EquihashMixin(object): +class EquihashMixin: STATIC_BLOCK_HEADERS = False BASIC_HEADER_SIZE = 140 # Excluding Equihash solution DESERIALIZER = lib_tx.DeserializerEquihash @@ -311,7 +311,7 @@ class EquihashMixin(object): return deserializer.read_header(height, cls.BASIC_HEADER_SIZE) -class ScryptMixin(object): +class ScryptMixin: DESERIALIZER = lib_tx.DeserializerTxTime HEADER_HASH = None @@ -330,7 +330,7 @@ class ScryptMixin(object): return cls.HEADER_HASH(header) -class KomodoMixin(object): +class KomodoMixin: P2PKH_VERBYTE = bytes.fromhex("3C") P2SH_VERBYTES = [bytes.fromhex("55")] WIF_BYTE = bytes.fromhex("BC") @@ -339,7 +339,7 @@ class KomodoMixin(object): DESERIALIZER = lib_tx.DeserializerZcash -class BitcoinMixin(object): +class BitcoinMixin: SHORTNAME = "BTC" NET = "mainnet" XPUB_VERBYTES = bytes.fromhex("0488b21e") @@ -524,7 +524,7 @@ class Emercoin(Coin): return double_sha256(header[:cls.BASIC_HEADER_SIZE]) -class BitcoinTestnetMixin(object): +class BitcoinTestnetMixin: SHORTNAME = "XTN" NET = "testnet" XPUB_VERBYTES = bytes.fromhex("043587cf") diff --git a/torba/server/daemon.py b/torba/server/daemon.py index 979d00154..dd53ae63c 100644 --- a/torba/server/daemon.py +++ b/torba/server/daemon.py @@ -37,7 +37,7 @@ class WorkQueueFullError(Exception): '''Internal - when the daemon's work queue is full.''' -class Daemon(object): +class Daemon: '''Handles connections to a daemon at the given URL.''' WARMING_UP = -28 diff --git a/torba/server/db.py b/torba/server/db.py index a72093610..d1af32592 100644 --- a/torba/server/db.py +++ b/torba/server/db.py @@ -33,7 +33,7 @@ UTXO = namedtuple("UTXO", "tx_num tx_pos tx_hash height value") @attr.s(slots=True) -class FlushData(object): +class FlushData: height = attr.ib() tx_count = attr.ib() headers = attr.ib() @@ -45,7 +45,7 @@ class FlushData(object): tip = attr.ib() -class DB(object): +class DB: '''Simple wrapper of the backend database for querying. Performs no DB update, though the DB will be cleaned on opening if diff --git a/torba/server/hash.py b/torba/server/hash.py index 9fd9d6fe2..d24433972 100644 --- a/torba/server/hash.py +++ b/torba/server/hash.py @@ -84,7 +84,7 @@ class Base58Error(Exception): '''Exception used for Base58 errors.''' -class Base58(object): +class Base58: '''Class providing base 58 functionality.''' chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' diff --git a/torba/server/history.py b/torba/server/history.py index 00d746baf..70fc2948a 100644 --- a/torba/server/history.py +++ b/torba/server/history.py @@ -20,7 +20,7 @@ from torba.server.util import pack_be_uint16, unpack_be_uint16_from from torba.server.hash import hash_to_hex_str, HASHX_LEN -class History(object): +class History: DB_VERSIONS = [0] diff --git a/torba/server/mempool.py b/torba/server/mempool.py index 765e66a4f..1f725aa5b 100644 --- a/torba/server/mempool.py +++ b/torba/server/mempool.py @@ -22,7 +22,7 @@ from torba.server.db import UTXO @attr.s(slots=True) -class MemPoolTx(object): +class MemPoolTx: prevouts = attr.ib() # A pair is a (hashX, value) tuple in_pairs = attr.ib() @@ -32,7 +32,7 @@ class MemPoolTx(object): @attr.s(slots=True) -class MemPoolTxSummary(object): +class MemPoolTxSummary: hash = attr.ib() fee = attr.ib() has_unconfirmed_inputs = attr.ib() @@ -79,7 +79,7 @@ class MemPoolAPI(ABC): daemon's height at the time the mempool was obtained.''' -class MemPool(object): +class MemPool: '''Representation of the daemon's mempool. coin - a coin class from coins.py diff --git a/torba/server/merkle.py b/torba/server/merkle.py index bdb0a90a9..a96921936 100644 --- a/torba/server/merkle.py +++ b/torba/server/merkle.py @@ -33,7 +33,7 @@ from aiorpcx import Event from torba.server.hash import double_sha256 -class Merkle(object): +class Merkle: '''Perform merkle tree calculations on binary hashes using a given hash function. @@ -157,7 +157,7 @@ class Merkle(object): return leaf_branch + level_branch, root -class MerkleCache(object): +class MerkleCache: '''A cache to calculate merkle branches efficiently.''' def __init__(self, merkle, source_func): diff --git a/torba/server/peer.py b/torba/server/peer.py index 850e6bf75..c59c84a34 100644 --- a/torba/server/peer.py +++ b/torba/server/peer.py @@ -33,7 +33,7 @@ from torba.server.util import cachedproperty from typing import Dict -class Peer(object): +class Peer: # Protocol version ATTRS = ('host', 'features', diff --git a/torba/server/peers.py b/torba/server/peers.py index 86e8a292a..d24810fde 100644 --- a/torba/server/peers.py +++ b/torba/server/peers.py @@ -49,7 +49,7 @@ class PeerSession(RPCSession): await handler_invocation(None, request) # Raises -class PeerManager(object): +class PeerManager: '''Looks after the DB of peer network servers. Attempts to maintain a connection with up to 8 peers. diff --git a/torba/server/script.py b/torba/server/script.py index 9ff0047d6..00f7472b6 100644 --- a/torba/server/script.py +++ b/torba/server/script.py @@ -91,7 +91,7 @@ def _match_ops(ops, pattern): return True -class ScriptPubKey(object): +class ScriptPubKey: '''A class for handling a tx output script that gives conditions necessary for spending. ''' @@ -177,7 +177,7 @@ class ScriptPubKey(object): + bytes([OP_1 + n - 1, OP_CHECK_MULTISIG])) -class Script(object): +class Script: @classmethod def get_ops(cls, script): diff --git a/torba/server/session.py b/torba/server/session.py index b8e84881e..14e4668ef 100644 --- a/torba/server/session.py +++ b/torba/server/session.py @@ -79,7 +79,7 @@ def assert_tx_hash(value): raise RPCError(BAD_REQUEST, f'{value} should be a transaction hash') -class Semaphores(object): +class Semaphores: '''For aiorpcX's semaphore handling.''' def __init__(self, semaphores): @@ -96,7 +96,7 @@ class Semaphores(object): semaphore.release() -class SessionGroup(object): +class SessionGroup: def __init__(self, gid): self.gid = gid @@ -104,7 +104,7 @@ class SessionGroup(object): self.semaphore = asyncio.Semaphore(20) -class SessionManager(object): +class SessionManager: '''Holds global state about all sessions.''' def __init__(self, env, db, bp, daemon, mempool, shutdown_event): diff --git a/torba/server/storage.py b/torba/server/storage.py index 4cb8edde9..f4c92f90d 100644 --- a/torba/server/storage.py +++ b/torba/server/storage.py @@ -22,7 +22,7 @@ def db_class(name): raise RuntimeError('unrecognised DB engine "{}"'.format(name)) -class Storage(object): +class Storage: '''Abstract base class of the DB backend abstraction.''' def __init__(self, name, for_sync): @@ -121,7 +121,7 @@ class RocksDB(Storage): return RocksDBIterator(self.db, prefix, reverse) -class RocksDBWriteBatch(object): +class RocksDBWriteBatch: '''A write batch for RocksDB.''' def __init__(self, db): @@ -136,7 +136,7 @@ class RocksDBWriteBatch(object): self.db.write(self.batch) -class RocksDBIterator(object): +class RocksDBIterator: '''An iterator for RocksDB.''' def __init__(self, db, prefix, reverse): diff --git a/torba/server/tx.py b/torba/server/tx.py index b1d578c7e..a85a2ccdb 100644 --- a/torba/server/tx.py +++ b/torba/server/tx.py @@ -85,7 +85,7 @@ class TxOutput(namedtuple("TxOutput", "value pk_script")): )) -class Deserializer(object): +class Deserializer: '''Deserializes blocks into transactions. External entry points are read_tx(), read_tx_and_hash(), diff --git a/torba/server/util.py b/torba/server/util.py index 37694373c..7f36d8cd7 100644 --- a/torba/server/util.py +++ b/torba/server/util.py @@ -70,7 +70,7 @@ def class_logger(path, classname): # Method decorator. To be used for calculations that will always # deliver the same result. The method cannot take any arguments # and should be accessed as an attribute. -class cachedproperty(object): +class cachedproperty: def __init__(self, f): self.f = f @@ -178,7 +178,7 @@ def increment_byte_string(bs): return None -class LogicalFile(object): +class LogicalFile: '''A logical binary file split across several separate files on disk.''' def __init__(self, prefix, digits, file_size): From 8cb811ca1d510d535ea8eccbb8414637e1560266 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 25 Nov 2018 20:54:59 -0500 Subject: [PATCH 245/383] force older astroid --- .travis.yml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 3169a13fc..6f6c9aa18 100644 --- a/.travis.yml +++ b/.travis.yml @@ -9,8 +9,9 @@ jobs: - stage: code quality name: "pylint & mypy" install: - - pip install git+https://github.com/PyCQA/pylint.git - - pip install mypy + - pip install astroid==2.0.4 + # newer astroid fails in pylint so we pre-install older version + - pip install pylint mypy - pip install -e . script: - pylint --rcfile=setup.cfg torba From 56fc003a961d84b1f887073af04f9010f70059bc Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Sun, 25 Nov 2018 18:30:55 -0300 Subject: [PATCH 246/383] log errors from wallet servers --- torba/client/basenetwork.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index 7ce2663fb..d193d6d47 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -3,7 +3,7 @@ import asyncio from asyncio import CancelledError from itertools import cycle -from aiorpcx import RPCSession as BaseClientSession, Connector +from aiorpcx import RPCSession as BaseClientSession, Connector, RPCError from torba import __version__ from torba.stream import StreamController @@ -21,6 +21,13 @@ class ClientSession(BaseClientSession): self.on_disconnected = self._on_disconnect_controller.stream self.bw_limit = self.framer.max_size = self.max_errors = 1 << 32 + async def send_request(self, method, args=()): + try: + return await super().send_request(method, args) + except RPCError as e: + log.warning("Wallet server returned an error. Code: %s Message: %s", *e.args) + raise e + async def create_connection(self): connector = Connector(lambda: self, *self.server) await connector.create_connection() From ca67c56222e56bc75481b3c35cd46943164edcff Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Mon, 26 Nov 2018 14:01:14 -0500 Subject: [PATCH 247/383] catch decryption errors and verify seed is valid upon decrypt --- torba/client/baseaccount.py | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index c3665111c..bfa8e2637 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -309,11 +309,26 @@ class BaseAccount: def decrypt(self, password: str) -> None: assert self.encrypted, "Key is not encrypted." - self.seed, self.seed_encryption_init_vector = aes_decrypt(password, self.seed) - pk_string, self.private_key_encryption_init_vector = aes_decrypt(password, self.private_key_string) - self.private_key = from_extended_key_string( - self.ledger, pk_string - ) + try: + seed, seed_iv = aes_decrypt(password, self.seed) + pk_string, pk_iv = aes_decrypt(password, self.private_key_string) + except ValueError: # failed to remove padding, password is wrong + return + try: + Mnemonic().mnemonic_decode(seed) + except IndexError: # failed to decode the seed, this either means it decrypted and is invalid + # or that we hit an edge case where an incorrect password gave valid padding + return + try: + private_key = from_extended_key_string( + self.ledger, pk_string + ) + except (TypeError, ValueError): + return + self.seed = seed + self.seed_encryption_init_vector = seed_iv + self.private_key = private_key + self.private_key_encryption_init_vector = pk_iv self.password = password self.encrypted = False From 6c4f6dd59ade0b3ee9e58d31fd61d26ff848632d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 29 Nov 2018 16:28:32 -0500 Subject: [PATCH 248/383] do not install plyvel on windows --- setup.py | 28 +++++++++++++++++----------- 1 file changed, 17 insertions(+), 11 deletions(-) diff --git a/setup.py b/setup.py index de5d748d8..bd8206135 100644 --- a/setup.py +++ b/setup.py @@ -1,4 +1,5 @@ import os +import sys from setuptools import setup, find_packages import torba @@ -7,6 +8,20 @@ BASE = os.path.dirname(__file__) with open(os.path.join(BASE, 'README.md'), encoding='utf-8') as fh: long_description = fh.read() +REQUIRES = [ + 'aiohttp', + 'aiorpcx==0.9.0', + 'coincurve', + 'pbkdf2', + 'cryptography', + 'attrs', + 'plyvel', + 'pylru' +] +if sys.platform.startswith('win32'): + REQUIRES.remove('plyvel') + + setup( name='torba', version=torba.__version__, @@ -33,17 +48,8 @@ setup( 'Topic :: Utilities', ], packages=find_packages(exclude=('tests',)), - python_requires='>=3.6', - install_requires=( - 'aiohttp', - 'aiorpcx==0.9.0', - 'coincurve', - 'pbkdf2', - 'cryptography', - 'attrs', - 'plyvel', - 'pylru' - ), + python_requires='>=3.7', + install_requires=REQUIRES, extras_require={ 'gui': ( 'pyside2', From 9525bd6ca0246f9e2b2aad440c201241c94b72fb Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 29 Nov 2018 16:39:59 -0500 Subject: [PATCH 249/383] do not run 3.6 tests anymore --- .travis.yml | 2 -- tox.ini | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 6f6c9aa18..bbd6772b5 100644 --- a/.travis.yml +++ b/.travis.yml @@ -24,8 +24,6 @@ jobs: install: - pip install tox-travis script: tox - - <<: *tests - python: "3.6" - <<: *tests env: TESTTYPE=integration diff --git a/tox.ini b/tox.ini index f57adac09..3e2c2e424 100644 --- a/tox.ini +++ b/tox.ini @@ -1,6 +1,6 @@ [tox] #envlist = unit,integration-{torba.coin.bitcoincash,torba.coin.bitcoinsegwit} -envlist = py{37,36}-unit,py37-integration-torba.coin.bitcoinsegwit +envlist = py37-unit,py37-integration-torba.coin.bitcoinsegwit [travis:env] TESTTYPE = From ba5fc2a62722f88b75bdfb542d72669b109e1cfe Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 30 Nov 2018 10:40:03 -0500 Subject: [PATCH 250/383] allow 3.6 for now --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index bd8206135..2ba288f98 100644 --- a/setup.py +++ b/setup.py @@ -48,7 +48,7 @@ setup( 'Topic :: Utilities', ], packages=find_packages(exclude=('tests',)), - python_requires='>=3.7', + python_requires='>=3.6', install_requires=REQUIRES, extras_require={ 'gui': ( From 899a6f0d4a93b59feacab994159b5d26a4878b04 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 5 Dec 2018 00:40:06 -0500 Subject: [PATCH 251/383] merged aiorpcx into torba.rpc --- setup.py | 1 - torba/rpc/__init__.py | 13 + torba/rpc/curio.py | 411 ++++++++++++++++ torba/rpc/framing.py | 239 ++++++++++ torba/rpc/jsonrpc.py | 801 ++++++++++++++++++++++++++++++++ torba/rpc/session.py | 549 ++++++++++++++++++++++ torba/rpc/socks.py | 439 +++++++++++++++++ torba/rpc/util.py | 120 +++++ torba/server/block_processor.py | 2 +- torba/server/daemon.py | 2 +- torba/server/db.py | 2 +- torba/server/mempool.py | 2 +- torba/server/merkle.py | 3 +- torba/server/peers.py | 3 +- torba/server/session.py | 9 +- 15 files changed, 2582 insertions(+), 14 deletions(-) create mode 100644 torba/rpc/__init__.py create mode 100644 torba/rpc/curio.py create mode 100644 torba/rpc/framing.py create mode 100644 torba/rpc/jsonrpc.py create mode 100644 torba/rpc/session.py create mode 100644 torba/rpc/socks.py create mode 100644 torba/rpc/util.py diff --git a/setup.py b/setup.py index 2ba288f98..075bd0c8f 100644 --- a/setup.py +++ b/setup.py @@ -10,7 +10,6 @@ with open(os.path.join(BASE, 'README.md'), encoding='utf-8') as fh: REQUIRES = [ 'aiohttp', - 'aiorpcx==0.9.0', 'coincurve', 'pbkdf2', 'cryptography', diff --git a/torba/rpc/__init__.py b/torba/rpc/__init__.py new file mode 100644 index 000000000..ce96bd517 --- /dev/null +++ b/torba/rpc/__init__.py @@ -0,0 +1,13 @@ +from .curio import * +from .framing import * +from .jsonrpc import * +from .socks import * +from .session import * +from .util import * + +__all__ = (curio.__all__ + + framing.__all__ + + jsonrpc.__all__ + + socks.__all__ + + session.__all__ + + util.__all__) diff --git a/torba/rpc/curio.py b/torba/rpc/curio.py new file mode 100644 index 000000000..2e9d53bff --- /dev/null +++ b/torba/rpc/curio.py @@ -0,0 +1,411 @@ +# The code below is mostly my own but based on the interfaces of the +# curio library by David Beazley. I'm considering switching to using +# curio. In the mean-time this is an attempt to provide a similar +# clean, pure-async interface and move away from direct +# framework-specific dependencies. As asyncio differs in its design +# it is not possible to provide identical semantics. +# +# The curio library is distributed under the following licence: +# +# Copyright (C) 2015-2017 +# David Beazley (Dabeaz LLC) +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# * Neither the name of the David Beazley or Dabeaz LLC may be used to +# endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import logging +import asyncio +from asyncio import ( + CancelledError, get_event_loop, Queue, Event, Lock, Semaphore, + sleep, Task +) +from collections import deque +from contextlib import suppress +from functools import partial + +from .util import normalize_corofunc, check_task + + +__all__ = ( + 'Queue', 'Event', 'Lock', 'Semaphore', 'sleep', 'CancelledError', + 'run_in_thread', 'spawn', 'spawn_sync', 'TaskGroup', + 'TaskTimeout', 'TimeoutCancellationError', 'UncaughtTimeoutError', + 'timeout_after', 'timeout_at', 'ignore_after', 'ignore_at', +) + + +async def run_in_thread(func, *args): + '''Run a function in a separate thread, and await its completion.''' + return await get_event_loop().run_in_executor(None, func, *args) + + +async def spawn(coro, *args, loop=None, report_crash=True): + return spawn_sync(coro, *args, loop=loop, report_crash=report_crash) + + +def spawn_sync(coro, *args, loop=None, report_crash=True): + coro = normalize_corofunc(coro, args) + loop = loop or get_event_loop() + task = loop.create_task(coro) + if report_crash: + task.add_done_callback(partial(check_task, logging)) + return task + + +class TaskGroup(object): + '''A class representing a group of executing tasks. tasks is an + optional set of existing tasks to put into the group. New tasks + can later be added using the spawn() method below. wait specifies + the policy used for waiting for tasks. See the join() method + below. Each TaskGroup is an independent entity. Task groups do not + form a hierarchy or any kind of relationship to other previously + created task groups or tasks. Moreover, Tasks created by the top + level spawn() function are not placed into any task group. To + create a task in a group, it should be created using + TaskGroup.spawn() or explicitly added using TaskGroup.add_task(). + + completed attribute: the first task that completed with a result + in the group. Takes into account the wait option used in the + TaskGroup constructor (but not in the join method)`. + ''' + + def __init__(self, tasks=(), *, wait=all): + if wait not in (any, all, object): + raise ValueError('invalid wait argument') + self._done = deque() + self._pending = set() + self._wait = wait + self._done_event = Event() + self._logger = logging.getLogger(self.__class__.__name__) + self._closed = False + self.completed = None + for task in tasks: + self._add_task(task) + + def _add_task(self, task): + '''Add an already existing task to the task group.''' + if hasattr(task, '_task_group'): + raise RuntimeError('task is already part of a group') + if self._closed: + raise RuntimeError('task group is closed') + task._task_group = self + if task.done(): + self._done.append(task) + else: + self._pending.add(task) + task.add_done_callback(self._on_done) + + def _on_done(self, task): + task._task_group = None + self._pending.remove(task) + self._done.append(task) + self._done_event.set() + if self.completed is None: + if not task.cancelled() and not task.exception(): + if self._wait is object and task.result() is None: + pass + else: + self.completed = task + + async def spawn(self, coro, *args): + '''Create a new task that’s part of the group. Returns a Task + instance. + ''' + task = await spawn(coro, *args, report_crash=False) + self._add_task(task) + return task + + async def add_task(self, task): + '''Add an already existing task to the task group.''' + self._add_task(task) + + async def next_done(self): + '''Returns the next completed task. Returns None if no more tasks + remain. A TaskGroup may also be used as an asynchronous iterator. + ''' + if not self._done and self._pending: + self._done_event.clear() + await self._done_event.wait() + if self._done: + return self._done.popleft() + return None + + async def next_result(self): + '''Returns the result of the next completed task. If the task failed + with an exception, that exception is raised. A RuntimeError + exception is raised if this is called when no remaining tasks + are available.''' + task = await self.next_done() + if not task: + raise RuntimeError('no tasks remain') + return task.result() + + async def join(self): + '''Wait for tasks in the group to terminate according to the wait + policy for the group. + + If the join() operation itself is cancelled, all remaining + tasks in the group are also cancelled. + + If a TaskGroup is used as a context manager, the join() method + is called on context-exit. + + Once join() returns, no more tasks may be added to the task + group. Tasks can be added while join() is running. + ''' + def errored(task): + return not task.cancelled() and task.exception() + + try: + if self._wait in (all, object): + while True: + task = await self.next_done() + if task is None: + return + if errored(task): + break + if self._wait is object: + if task.cancelled() or task.result() is not None: + return + else: # any + task = await self.next_done() + if task is None or not errored(task): + return + finally: + await self.cancel_remaining() + + if errored(task): + raise task.exception() + + async def cancel_remaining(self): + '''Cancel all remaining tasks.''' + self._closed = True + for task in list(self._pending): + task.cancel() + with suppress(CancelledError): + await task + + def closed(self): + return self._closed + + def __aiter__(self): + return self + + async def __anext__(self): + task = await self.next_done() + if task: + return task + raise StopAsyncIteration + + async def __aenter__(self): + return self + + async def __aexit__(self, exc_type, exc_value, traceback): + if exc_type: + await self.cancel_remaining() + else: + await self.join() + + +class TaskTimeout(CancelledError): + + def __init__(self, secs): + self.secs = secs + + def __str__(self): + return f'task timed out after {self.args[0]}s' + + +class TimeoutCancellationError(CancelledError): + pass + + +class UncaughtTimeoutError(Exception): + pass + + +def _set_new_deadline(task, deadline): + def timeout_task(): + # Unfortunately task.cancel is all we can do with asyncio + task.cancel() + task._timed_out = deadline + task._deadline_handle = task._loop.call_at(deadline, timeout_task) + + +def _set_task_deadline(task, deadline): + deadlines = getattr(task, '_deadlines', []) + if deadlines: + if deadline < min(deadlines): + task._deadline_handle.cancel() + _set_new_deadline(task, deadline) + else: + _set_new_deadline(task, deadline) + deadlines.append(deadline) + task._deadlines = deadlines + task._timed_out = None + + +def _unset_task_deadline(task): + deadlines = task._deadlines + timed_out_deadline = task._timed_out + uncaught = timed_out_deadline not in deadlines + task._deadline_handle.cancel() + deadlines.pop() + if deadlines: + _set_new_deadline(task, min(deadlines)) + return timed_out_deadline, uncaught + + +class TimeoutAfter(object): + + def __init__(self, deadline, *, ignore=False, absolute=False): + self._deadline = deadline + self._ignore = ignore + self._absolute = absolute + self.expired = False + + async def __aenter__(self): + task = asyncio.current_task() + loop_time = task._loop.time() + if self._absolute: + self._secs = self._deadline - loop_time + else: + self._secs = self._deadline + self._deadline += loop_time + _set_task_deadline(task, self._deadline) + self.expired = False + self._task = task + return self + + async def __aexit__(self, exc_type, exc_value, traceback): + timed_out_deadline, uncaught = _unset_task_deadline(self._task) + if exc_type not in (CancelledError, TaskTimeout, + TimeoutCancellationError): + return False + if timed_out_deadline == self._deadline: + self.expired = True + if self._ignore: + return True + raise TaskTimeout(self._secs) from None + if timed_out_deadline is None: + assert exc_type is CancelledError + return False + if uncaught: + raise UncaughtTimeoutError('uncaught timeout received') + if exc_type is TimeoutCancellationError: + return False + raise TimeoutCancellationError(timed_out_deadline) from None + + +async def _timeout_after_func(seconds, absolute, coro, args): + coro = normalize_corofunc(coro, args) + async with TimeoutAfter(seconds, absolute=absolute): + return await coro + + +def timeout_after(seconds, coro=None, *args): + '''Execute the specified coroutine and return its result. However, + issue a cancellation request to the calling task after seconds + have elapsed. When this happens, a TaskTimeout exception is + raised. If coro is None, the result of this function serves + as an asynchronous context manager that applies a timeout to a + block of statements. + + timeout_after() may be composed with other timeout_after() + operations (i.e., nested timeouts). If an outer timeout expires + first, then TimeoutCancellationError is raised instead of + TaskTimeout. If an inner timeout expires and fails to properly + TaskTimeout, a UncaughtTimeoutError is raised in the outer + timeout. + + ''' + if coro: + return _timeout_after_func(seconds, False, coro, args) + + return TimeoutAfter(seconds) + + +def timeout_at(clock, coro=None, *args): + '''Execute the specified coroutine and return its result. However, + issue a cancellation request to the calling task after seconds + have elapsed. When this happens, a TaskTimeout exception is + raised. If coro is None, the result of this function serves + as an asynchronous context manager that applies a timeout to a + block of statements. + + timeout_after() may be composed with other timeout_after() + operations (i.e., nested timeouts). If an outer timeout expires + first, then TimeoutCancellationError is raised instead of + TaskTimeout. If an inner timeout expires and fails to properly + TaskTimeout, a UncaughtTimeoutError is raised in the outer + timeout. + + ''' + if coro: + return _timeout_after_func(clock, True, coro, args) + + return TimeoutAfter(clock, absolute=True) + + +async def _ignore_after_func(seconds, absolute, coro, args, timeout_result): + coro = normalize_corofunc(coro, args) + async with TimeoutAfter(seconds, absolute=absolute, ignore=True): + return await coro + + return timeout_result + + +def ignore_after(seconds, coro=None, *args, timeout_result=None): + '''Execute the specified coroutine and return its result. Issue a + cancellation request after seconds have elapsed. When a timeout + occurs, no exception is raised. Instead, timeout_result is + returned. + + If coro is None, the result is an asynchronous context manager + that applies a timeout to a block of statements. For the context + manager case, the resulting context manager object has an expired + attribute set to True if time expired. + + Note: ignore_after() may also be composed with other timeout + operations. TimeoutCancellationError and UncaughtTimeoutError + exceptions might be raised according to the same rules as for + timeout_after(). + ''' + if coro: + return _ignore_after_func(seconds, False, coro, args, timeout_result) + + return TimeoutAfter(seconds, ignore=True) + + +def ignore_at(clock, coro=None, *args, timeout_result=None): + ''' + Stop the enclosed task or block of code at an absolute + clock value. Same usage as ignore_after(). + ''' + if coro: + return _ignore_after_func(clock, True, coro, args, timeout_result) + + return TimeoutAfter(clock, absolute=True, ignore=True) diff --git a/torba/rpc/framing.py b/torba/rpc/framing.py new file mode 100644 index 000000000..6a5c2b9be --- /dev/null +++ b/torba/rpc/framing.py @@ -0,0 +1,239 @@ +# Copyright (c) 2018, Neil Booth +# +# All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +'''RPC message framing in a byte stream.''' + +__all__ = ('FramerBase', 'NewlineFramer', 'BinaryFramer', 'BitcoinFramer', + 'OversizedPayloadError', 'BadChecksumError', 'BadMagicError') + +from hashlib import sha256 as _sha256 +from struct import Struct +from asyncio import Queue + + +class FramerBase(object): + '''Abstract base class for a framer. + + A framer breaks an incoming byte stream into protocol messages, + buffering if necesary. It also frames outgoing messages into + a byte stream. + ''' + + def frame(self, message): + '''Return the framed message.''' + raise NotImplementedError + + def received_bytes(self, data): + '''Pass incoming network bytes.''' + raise NotImplementedError + + async def receive_message(self): + '''Wait for a complete unframed message to arrive, and return it.''' + raise NotImplementedError + + +class NewlineFramer(FramerBase): + '''A framer for a protocol where messages are separated by newlines.''' + + # The default max_size value is motivated by JSONRPC, where a + # normal request will be 250 bytes or less, and a reasonable + # batch may contain 4000 requests. + def __init__(self, max_size=250 * 4000): + '''max_size - an anti-DoS measure. If, after processing an incoming + message, buffered data would exceed max_size bytes, that + buffered data is dropped entirely and the framer waits for a + newline character to re-synchronize the stream. + ''' + self.max_size = max_size + self.queue = Queue() + self.received_bytes = self.queue.put_nowait + self.synchronizing = False + self.residual = b'' + + def frame(self, message): + return message + b'\n' + + async def receive_message(self): + parts = [] + buffer_size = 0 + while True: + part = self.residual + self.residual = b'' + if not part: + part = await self.queue.get() + + npos = part.find(b'\n') + if npos == -1: + parts.append(part) + buffer_size += len(part) + # Ignore over-sized messages; re-synchronize + if buffer_size <= self.max_size: + continue + self.synchronizing = True + raise MemoryError(f'dropping message over {self.max_size:,d} ' + f'bytes and re-synchronizing') + + tail, self.residual = part[:npos], part[npos + 1:] + if self.synchronizing: + self.synchronizing = False + return await self.receive_message() + else: + parts.append(tail) + return b''.join(parts) + + +class ByteQueue(object): + '''A producer-comsumer queue. Incoming network data is put as it + arrives, and the consumer calls an async method waiting for data of + a specific length.''' + + def __init__(self): + self.queue = Queue() + self.parts = [] + self.parts_len = 0 + self.put_nowait = self.queue.put_nowait + + async def receive(self, size): + while self.parts_len < size: + part = await self.queue.get() + self.parts.append(part) + self.parts_len += len(part) + self.parts_len -= size + whole = b''.join(self.parts) + self.parts = [whole[size:]] + return whole[:size] + + +class BinaryFramer(object): + '''A framer for binary messaging protocols.''' + + def __init__(self): + self.byte_queue = ByteQueue() + self.message_queue = Queue() + self.received_bytes = self.byte_queue.put_nowait + + def frame(self, message): + command, payload = message + return b''.join(( + self._build_header(command, payload), + payload + )) + + async def receive_message(self): + command, payload_len, checksum = await self._receive_header() + payload = await self.byte_queue.receive(payload_len) + payload_checksum = self._checksum(payload) + if payload_checksum != checksum: + raise BadChecksumError(payload_checksum, checksum) + return command, payload + + def _checksum(self, payload): + raise NotImplementedError + + def _build_header(self, command, payload): + raise NotImplementedError + + async def _receive_header(self): + raise NotImplementedError + + +# Helpers +struct_le_I = Struct(' 1024 * 1024: + if command != b'block' or payload_len > self._max_block_size: + raise OversizedPayloadError(command, payload_len) + return command, payload_len, checksum diff --git a/torba/rpc/jsonrpc.py b/torba/rpc/jsonrpc.py new file mode 100644 index 000000000..6cbd5f11a --- /dev/null +++ b/torba/rpc/jsonrpc.py @@ -0,0 +1,801 @@ +# Copyright (c) 2018, Neil Booth +# +# All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +'''Classes for JSONRPC versions 1.0 and 2.0, and a loose interpretation.''' + +__all__ = ('JSONRPC', 'JSONRPCv1', 'JSONRPCv2', 'JSONRPCLoose', + 'JSONRPCAutoDetect', 'Request', 'Notification', 'Batch', + 'RPCError', 'ProtocolError', + 'JSONRPCConnection', 'handler_invocation') + +import itertools +import json +from functools import partial +from numbers import Number + +import attr +from asyncio import Queue, Event, CancelledError +from .util import signature_info + + +class SingleRequest(object): + __slots__ = ('method', 'args') + + def __init__(self, method, args): + if not isinstance(method, str): + raise ProtocolError(JSONRPC.METHOD_NOT_FOUND, + 'method must be a string') + if not isinstance(args, (list, tuple, dict)): + raise ProtocolError.invalid_args('request arguments must be a ' + 'list or a dictionary') + self.args = args + self.method = method + + def __repr__(self): + return f'{self.__class__.__name__}({self.method!r}, {self.args!r})' + + def __eq__(self, other): + return (isinstance(other, self.__class__) and + self.method == other.method and self.args == other.args) + + +class Request(SingleRequest): + def send_result(self, response): + return None + + +class Notification(SingleRequest): + pass + + +class Batch(object): + __slots__ = ('items', ) + + def __init__(self, items): + if not isinstance(items, (list, tuple)): + raise ProtocolError.invalid_request('items must be a list') + if not items: + raise ProtocolError.empty_batch() + if not (all(isinstance(item, SingleRequest) for item in items) or + all(isinstance(item, Response) for item in items)): + raise ProtocolError.invalid_request('batch must be homogeneous') + self.items = items + + def __len__(self): + return len(self.items) + + def __getitem__(self, item): + return self.items[item] + + def __iter__(self): + return iter(self.items) + + def __repr__(self): + return f'Batch({len(self.items)} items)' + + +class Response(object): + __slots__ = ('result', ) + + def __init__(self, result): + # Type checking happens when converting to a message + self.result = result + + +class CodeMessageError(Exception): + + def __init__(self, code, message): + super().__init__(code, message) + + @property + def code(self): + return self.args[0] + + @property + def message(self): + return self.args[1] + + def __eq__(self, other): + return (isinstance(other, self.__class__) and + self.code == other.code and self.message == other.message) + + def __hash__(self): + # overridden to make the exception hashable + # see https://bugs.python.org/issue28603 + return hash((self.code, self.message)) + + @classmethod + def invalid_args(cls, message): + return cls(JSONRPC.INVALID_ARGS, message) + + @classmethod + def invalid_request(cls, message): + return cls(JSONRPC.INVALID_REQUEST, message) + + @classmethod + def empty_batch(cls): + return cls.invalid_request('batch is empty') + + +class RPCError(CodeMessageError): + pass + + +class ProtocolError(CodeMessageError): + + def __init__(self, code, message): + super().__init__(code, message) + # If not None send this unframed message over the network + self.error_message = None + # If the error was in a JSON response message; its message ID. + # Since None can be a response message ID, "id" means the + # error was not sent in a JSON response + self.response_msg_id = id + + +class JSONRPC(object): + '''Abstract base class that interprets and constructs JSON RPC messages.''' + + # Error codes. See http://www.jsonrpc.org/specification + PARSE_ERROR = -32700 + INVALID_REQUEST = -32600 + METHOD_NOT_FOUND = -32601 + INVALID_ARGS = -32602 + INTERNAL_ERROR = -32603 + # Codes specific to this library + ERROR_CODE_UNAVAILABLE = -100 + + # Can be overridden by derived classes + allow_batches = True + + @classmethod + def _message_id(cls, message, require_id): + '''Validate the message is a dictionary and return its ID. + + Raise an error if the message is invalid or the ID is of an + invalid type. If it has no ID, raise an error if require_id + is True, otherwise return None. + ''' + raise NotImplementedError + + @classmethod + def _validate_message(cls, message): + '''Validate other parts of the message other than those + done in _message_id.''' + pass + + @classmethod + def _request_args(cls, request): + '''Validate the existence and type of the arguments passed + in the request dictionary.''' + raise NotImplementedError + + @classmethod + def _process_request(cls, payload): + request_id = None + try: + request_id = cls._message_id(payload, False) + cls._validate_message(payload) + method = payload.get('method') + if request_id is None: + item = Notification(method, cls._request_args(payload)) + else: + item = Request(method, cls._request_args(payload)) + return item, request_id + except ProtocolError as error: + code, message = error.code, error.message + raise cls._error(code, message, True, request_id) + + @classmethod + def _process_response(cls, payload): + request_id = None + try: + request_id = cls._message_id(payload, True) + cls._validate_message(payload) + return Response(cls.response_value(payload)), request_id + except ProtocolError as error: + code, message = error.code, error.message + raise cls._error(code, message, False, request_id) + + @classmethod + def _message_to_payload(cls, message): + '''Returns a Python object or a ProtocolError.''' + try: + return json.loads(message.decode()) + except UnicodeDecodeError: + message = 'messages must be encoded in UTF-8' + except json.JSONDecodeError: + message = 'invalid JSON' + raise cls._error(cls.PARSE_ERROR, message, True, None) + + @classmethod + def _error(cls, code, message, send, msg_id): + error = ProtocolError(code, message) + if send: + error.error_message = cls.response_message(error, msg_id) + else: + error.response_msg_id = msg_id + return error + + # + # External API + # + + @classmethod + def message_to_item(cls, message): + '''Translate an unframed received message and return an + (item, request_id) pair. + + The item can be a Request, Notification, Response or a list. + + A JSON RPC error response is returned as an RPCError inside a + Response object. + + If a Batch is returned, request_id is an iterable of request + ids, one per batch member. + + If the message violates the protocol in some way a + ProtocolError is returned, except if the message was + determined to be a response, in which case the ProtocolError + is placed inside a Response object. This is so that client + code can mark a request as having been responded to even if + the response was bad. + + raises: ProtocolError + ''' + payload = cls._message_to_payload(message) + if isinstance(payload, dict): + if 'method' in payload: + return cls._process_request(payload) + else: + return cls._process_response(payload) + elif isinstance(payload, list) and cls.allow_batches: + if not payload: + raise cls._error(JSONRPC.INVALID_REQUEST, 'batch is empty', + True, None) + return payload, None + raise cls._error(cls.INVALID_REQUEST, + 'request object must be a dictionary', True, None) + + # Message formation + @classmethod + def request_message(cls, item, request_id): + '''Convert an RPCRequest item to a message.''' + assert isinstance(item, Request) + return cls.encode_payload(cls.request_payload(item, request_id)) + + @classmethod + def notification_message(cls, item): + '''Convert an RPCRequest item to a message.''' + assert isinstance(item, Notification) + return cls.encode_payload(cls.request_payload(item, None)) + + @classmethod + def response_message(cls, result, request_id): + '''Convert a response result (or RPCError) to a message.''' + if isinstance(result, CodeMessageError): + payload = cls.error_payload(result, request_id) + else: + payload = cls.response_payload(result, request_id) + return cls.encode_payload(payload) + + @classmethod + def batch_message(cls, batch, request_ids): + '''Convert a request Batch to a message.''' + assert isinstance(batch, Batch) + if not cls.allow_batches: + raise ProtocolError.invalid_request( + 'protocol does not permit batches') + id_iter = iter(request_ids) + rm = cls.request_message + nm = cls.notification_message + parts = (rm(request, next(id_iter)) if isinstance(request, Request) + else nm(request) for request in batch) + return cls.batch_message_from_parts(parts) + + @classmethod + def batch_message_from_parts(cls, messages): + '''Convert messages, one per batch item, into a batch message. At + least one message must be passed. + ''' + # Comma-separate the messages and wrap the lot in square brackets + middle = b', '.join(messages) + if not middle: + raise ProtocolError.empty_batch() + return b''.join([b'[', middle, b']']) + + @classmethod + def encode_payload(cls, payload): + '''Encode a Python object as JSON and convert it to bytes.''' + try: + return json.dumps(payload).encode() + except TypeError: + msg = f'JSON payload encoding error: {payload}' + raise ProtocolError(cls.INTERNAL_ERROR, msg) from None + + +class JSONRPCv1(JSONRPC): + '''JSON RPC version 1.0.''' + + allow_batches = False + + @classmethod + def _message_id(cls, message, require_id): + # JSONv1 requires an ID always, but without constraint on its type + # No need to test for a dictionary here as we don't handle batches. + if 'id' not in message: + raise ProtocolError.invalid_request('request has no "id"') + return message['id'] + + @classmethod + def _request_args(cls, request): + args = request.get('params') + if not isinstance(args, list): + raise ProtocolError.invalid_args( + f'invalid request arguments: {args}') + return args + + @classmethod + def _best_effort_error(cls, error): + # Do our best to interpret the error + code = cls.ERROR_CODE_UNAVAILABLE + message = 'no error message provided' + if isinstance(error, str): + message = error + elif isinstance(error, int): + code = error + elif isinstance(error, dict): + if isinstance(error.get('message'), str): + message = error['message'] + if isinstance(error.get('code'), int): + code = error['code'] + + return RPCError(code, message) + + @classmethod + def response_value(cls, payload): + if 'result' not in payload or 'error' not in payload: + raise ProtocolError.invalid_request( + 'response must contain both "result" and "error"') + + result = payload['result'] + error = payload['error'] + if error is None: + return result # It seems None can be a valid result + if result is not None: + raise ProtocolError.invalid_request( + 'response has a "result" and an "error"') + + return cls._best_effort_error(error) + + @classmethod + def request_payload(cls, request, request_id): + '''JSON v1 request (or notification) payload.''' + if isinstance(request.args, dict): + raise ProtocolError.invalid_args( + 'JSONRPCv1 does not support named arguments') + return { + 'method': request.method, + 'params': request.args, + 'id': request_id + } + + @classmethod + def response_payload(cls, result, request_id): + '''JSON v1 response payload.''' + return { + 'result': result, + 'error': None, + 'id': request_id + } + + @classmethod + def error_payload(cls, error, request_id): + return { + 'result': None, + 'error': {'code': error.code, 'message': error.message}, + 'id': request_id + } + + +class JSONRPCv2(JSONRPC): + '''JSON RPC version 2.0.''' + + @classmethod + def _message_id(cls, message, require_id): + if not isinstance(message, dict): + raise ProtocolError.invalid_request( + 'request object must be a dictionary') + if 'id' in message: + request_id = message['id'] + if not isinstance(request_id, (Number, str, type(None))): + raise ProtocolError.invalid_request( + f'invalid "id": {request_id}') + return request_id + else: + if require_id: + raise ProtocolError.invalid_request('request has no "id"') + return None + + @classmethod + def _validate_message(cls, message): + if message.get('jsonrpc') != '2.0': + raise ProtocolError.invalid_request('"jsonrpc" is not "2.0"') + + @classmethod + def _request_args(cls, request): + args = request.get('params', []) + if not isinstance(args, (dict, list)): + raise ProtocolError.invalid_args( + f'invalid request arguments: {args}') + return args + + @classmethod + def response_value(cls, payload): + if 'result' in payload: + if 'error' in payload: + raise ProtocolError.invalid_request( + 'response contains both "result" and "error"') + return payload['result'] + + if 'error' not in payload: + raise ProtocolError.invalid_request( + 'response contains neither "result" nor "error"') + + # Return an RPCError object + error = payload['error'] + if isinstance(error, dict): + code = error.get('code') + message = error.get('message') + if isinstance(code, int) and isinstance(message, str): + return RPCError(code, message) + + raise ProtocolError.invalid_request( + f'ill-formed response error object: {error}') + + @classmethod + def request_payload(cls, request, request_id): + '''JSON v2 request (or notification) payload.''' + payload = { + 'jsonrpc': '2.0', + 'method': request.method, + } + # A notification? + if request_id is not None: + payload['id'] = request_id + # Preserve empty dicts as missing params is read as an array + if request.args or request.args == {}: + payload['params'] = request.args + return payload + + @classmethod + def response_payload(cls, result, request_id): + '''JSON v2 response payload.''' + return { + 'jsonrpc': '2.0', + 'result': result, + 'id': request_id + } + + @classmethod + def error_payload(cls, error, request_id): + return { + 'jsonrpc': '2.0', + 'error': {'code': error.code, 'message': error.message}, + 'id': request_id + } + + +class JSONRPCLoose(JSONRPC): + '''A relaxed versin of JSON RPC.''' + + # Don't be so loose we accept any old message ID + _message_id = JSONRPCv2._message_id + _validate_message = JSONRPC._validate_message + _request_args = JSONRPCv2._request_args + # Outoing messages are JSONRPCv2 so we give the other side the + # best chance to assume / detect JSONRPCv2 as default protocol. + error_payload = JSONRPCv2.error_payload + request_payload = JSONRPCv2.request_payload + response_payload = JSONRPCv2.response_payload + + @classmethod + def response_value(cls, payload): + # Return result, unless it is None and there is an error + if payload.get('error') is not None: + if payload.get('result') is not None: + raise ProtocolError.invalid_request( + 'response contains both "result" and "error"') + return JSONRPCv1._best_effort_error(payload['error']) + + if 'result' not in payload: + raise ProtocolError.invalid_request( + 'response contains neither "result" nor "error"') + + # Can be None + return payload['result'] + + +class JSONRPCAutoDetect(JSONRPCv2): + + @classmethod + def message_to_item(cls, message): + return cls.detect_protocol(message), None + + @classmethod + def detect_protocol(cls, message): + '''Attempt to detect the protocol from the message.''' + main = cls._message_to_payload(message) + + def protocol_for_payload(payload): + if not isinstance(payload, dict): + return JSONRPCLoose # Will error + # Obey an explicit "jsonrpc" + version = payload.get('jsonrpc') + if version == '2.0': + return JSONRPCv2 + if version == '1.0': + return JSONRPCv1 + + # Now to decide between JSONRPCLoose and JSONRPCv1 if possible + if 'result' in payload and 'error' in payload: + return JSONRPCv1 + return JSONRPCLoose + + if isinstance(main, list): + parts = set(protocol_for_payload(payload) for payload in main) + # If all same protocol, return it + if len(parts) == 1: + return parts.pop() + # If strict protocol detected, return it, preferring JSONRPCv2. + # This means a batch of JSONRPCv1 will fail + for protocol in (JSONRPCv2, JSONRPCv1): + if protocol in parts: + return protocol + # Will error if no parts + return JSONRPCLoose + + return protocol_for_payload(main) + + +class JSONRPCConnection(object): + '''Maintains state of a JSON RPC connection, in particular + encapsulating the handling of request IDs. + + protocol - the JSON RPC protocol to follow + max_response_size - responses over this size send an error response + instead. + ''' + + _id_counter = itertools.count() + + def __init__(self, protocol): + self._protocol = protocol + # Sent Requests and Batches that have not received a response. + # The key is its request ID; for a batch it is sorted tuple + # of request IDs + self._requests = {} + # A public attribute intended to be settable dynamically + self.max_response_size = 0 + + def _oversized_response_message(self, request_id): + text = f'response too large (over {self.max_response_size:,d} bytes' + error = RPCError.invalid_request(text) + return self._protocol.response_message(error, request_id) + + def _receive_response(self, result, request_id): + if request_id not in self._requests: + if request_id is None and isinstance(result, RPCError): + message = f'diagnostic error received: {result}' + else: + message = f'response to unsent request (ID: {request_id})' + raise ProtocolError.invalid_request(message) from None + request, event = self._requests.pop(request_id) + event.result = result + event.set() + return [] + + def _receive_request_batch(self, payloads): + def item_send_result(request_id, result): + nonlocal size + part = protocol.response_message(result, request_id) + size += len(part) + 2 + if size > self.max_response_size > 0: + part = self._oversized_response_message(request_id) + parts.append(part) + if len(parts) == count: + return protocol.batch_message_from_parts(parts) + return None + + parts = [] + items = [] + size = 0 + count = 0 + protocol = self._protocol + for payload in payloads: + try: + item, request_id = protocol._process_request(payload) + items.append(item) + if isinstance(item, Request): + count += 1 + item.send_result = partial(item_send_result, request_id) + except ProtocolError as error: + count += 1 + parts.append(error.error_message) + + if not items and parts: + error = ProtocolError(0, "") + error.error_message = protocol.batch_message_from_parts(parts) + raise error + return items + + def _receive_response_batch(self, payloads): + request_ids = [] + results = [] + for payload in payloads: + # Let ProtocolError exceptions through + item, request_id = self._protocol._process_response(payload) + request_ids.append(request_id) + results.append(item.result) + + ordered = sorted(zip(request_ids, results), key=lambda t: t[0]) + ordered_ids, ordered_results = zip(*ordered) + if ordered_ids not in self._requests: + raise ProtocolError.invalid_request('response to unsent batch') + request_batch, event = self._requests.pop(ordered_ids) + event.result = ordered_results + event.set() + return [] + + def _send_result(self, request_id, result): + message = self._protocol.response_message(result, request_id) + if len(message) > self.max_response_size > 0: + message = self._oversized_response_message(request_id) + return message + + def _event(self, request, request_id): + event = Event() + self._requests[request_id] = (request, event) + return event + + # + # External API + # + def send_request(self, request): + '''Send a Request. Return a (message, event) pair. + + The message is an unframed message to send over the network. + Wait on the event for the response; which will be in the + "result" attribute. + + Raises: ProtocolError if the request violates the protocol + in some way.. + ''' + request_id = next(self._id_counter) + message = self._protocol.request_message(request, request_id) + return message, self._event(request, request_id) + + def send_notification(self, notification): + return self._protocol.notification_message(notification) + + def send_batch(self, batch): + ids = tuple(next(self._id_counter) + for request in batch if isinstance(request, Request)) + message = self._protocol.batch_message(batch, ids) + event = self._event(batch, ids) if ids else None + return message, event + + def receive_message(self, message): + '''Call with an unframed message received from the network. + + Raises: ProtocolError if the message violates the protocol in + some way. However, if it happened in a response that can be + paired with a request, the ProtocolError is instead set in the + result attribute of the send_request() that caused the error. + ''' + try: + item, request_id = self._protocol.message_to_item(message) + except ProtocolError as e: + if e.response_msg_id is not id: + return self._receive_response(e, e.response_msg_id) + raise + + if isinstance(item, Request): + item.send_result = partial(self._send_result, request_id) + return [item] + if isinstance(item, Notification): + return [item] + if isinstance(item, Response): + return self._receive_response(item.result, request_id) + if isinstance(item, list): + if all(isinstance(payload, dict) + and ('result' in payload or 'error' in payload) + for payload in item): + return self._receive_response_batch(item) + else: + return self._receive_request_batch(item) + else: + # Protocol auto-detection hack + assert issubclass(item, JSONRPC) + self._protocol = item + return self.receive_message(message) + + def cancel_pending_requests(self): + '''Cancel all pending requests.''' + exception = CancelledError() + for request, event in self._requests.values(): + event.result = exception + event.set() + self._requests.clear() + + def pending_requests(self): + '''All sent requests that have not received a response.''' + return [request for request, event in self._requests.values()] + + +def handler_invocation(handler, request): + method, args = request.method, request.args + if handler is None: + raise RPCError(JSONRPC.METHOD_NOT_FOUND, + f'unknown method "{method}"') + + # We must test for too few and too many arguments. How + # depends on whether the arguments were passed as a list or as + # a dictionary. + info = signature_info(handler) + if isinstance(args, (tuple, list)): + if len(args) < info.min_args: + s = '' if len(args) == 1 else 's' + raise RPCError.invalid_args( + f'{len(args)} argument{s} passed to method ' + f'"{method}" but it requires {info.min_args}') + if info.max_args is not None and len(args) > info.max_args: + s = '' if len(args) == 1 else 's' + raise RPCError.invalid_args( + f'{len(args)} argument{s} passed to method ' + f'{method} taking at most {info.max_args}') + return partial(handler, *args) + + # Arguments passed by name + if info.other_names is None: + raise RPCError.invalid_args(f'method "{method}" cannot ' + f'be called with named arguments') + + missing = set(info.required_names).difference(args) + if missing: + s = '' if len(missing) == 1 else 's' + missing = ', '.join(sorted(f'"{name}"' for name in missing)) + raise RPCError.invalid_args(f'method "{method}" requires ' + f'parameter{s} {missing}') + + if info.other_names is not any: + excess = set(args).difference(info.required_names) + excess = excess.difference(info.other_names) + if excess: + s = '' if len(excess) == 1 else 's' + excess = ', '.join(sorted(f'"{name}"' for name in excess)) + raise RPCError.invalid_args(f'method "{method}" does not ' + f'take parameter{s} {excess}') + return partial(handler, **args) diff --git a/torba/rpc/session.py b/torba/rpc/session.py new file mode 100644 index 000000000..144cc2f02 --- /dev/null +++ b/torba/rpc/session.py @@ -0,0 +1,549 @@ +# Copyright (c) 2018, Neil Booth +# +# All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +__all__ = ('Connector', 'RPCSession', 'MessageSession', 'Server', + 'BatchError') + + +import asyncio +import logging +import time +from contextlib import suppress + +from . import * +from .util import Concurrency + + +class Connector(object): + + def __init__(self, session_factory, host=None, port=None, proxy=None, + **kwargs): + self.session_factory = session_factory + self.host = host + self.port = port + self.proxy = proxy + self.loop = kwargs.get('loop', asyncio.get_event_loop()) + self.kwargs = kwargs + + async def create_connection(self): + '''Initiate a connection.''' + connector = self.proxy or self.loop + return await connector.create_connection( + self.session_factory, self.host, self.port, **self.kwargs) + + async def __aenter__(self): + transport, self.protocol = await self.create_connection() + # By default, do not limit outgoing connections + self.protocol.bw_limit = 0 + return self.protocol + + async def __aexit__(self, exc_type, exc_value, traceback): + await self.protocol.close() + + +class SessionBase(asyncio.Protocol): + '''Base class of networking sessions. + + There is no client / server distinction other than who initiated + the connection. + + To initiate a connection to a remote server pass host, port and + proxy to the constructor, and then call create_connection(). Each + successful call should have a corresponding call to close(). + + Alternatively if used in a with statement, the connection is made + on entry to the block, and closed on exit from the block. + ''' + + max_errors = 10 + + def __init__(self, *, framer=None, loop=None): + self.framer = framer or self.default_framer() + self.loop = loop or asyncio.get_event_loop() + self.logger = logging.getLogger(self.__class__.__name__) + self.transport = None + # Set when a connection is made + self._address = None + self._proxy_address = None + # For logger.debug messsages + self.verbosity = 0 + # Cleared when the send socket is full + self._can_send = Event() + self._can_send.set() + self._pm_task = None + self._task_group = TaskGroup() + # Force-close a connection if a send doesn't succeed in this time + self.max_send_delay = 60 + # Statistics. The RPC object also keeps its own statistics. + self.start_time = time.time() + self.errors = 0 + self.send_count = 0 + self.send_size = 0 + self.last_send = self.start_time + self.recv_count = 0 + self.recv_size = 0 + self.last_recv = self.start_time + # Bandwidth usage per hour before throttling starts + self.bw_limit = 2000000 + self.bw_time = self.start_time + self.bw_charge = 0 + # Concurrency control + self.max_concurrent = 6 + self._concurrency = Concurrency(self.max_concurrent) + + async def _update_concurrency(self): + # A non-positive value means not to limit concurrency + if self.bw_limit <= 0: + return + now = time.time() + # Reduce the recorded usage in proportion to the elapsed time + refund = (now - self.bw_time) * (self.bw_limit / 3600) + self.bw_charge = max(0, self.bw_charge - int(refund)) + self.bw_time = now + # Reduce concurrency allocation by 1 for each whole bw_limit used + throttle = int(self.bw_charge / self.bw_limit) + target = max(1, self.max_concurrent - throttle) + current = self._concurrency.max_concurrent + if target != current: + self.logger.info(f'changing task concurrency from {current} ' + f'to {target}') + await self._concurrency.set_max_concurrent(target) + + def _using_bandwidth(self, size): + '''Called when sending or receiving size bytes.''' + self.bw_charge += size + + async def _process_messages(self): + '''Process incoming messages asynchronously and consume the + results. + ''' + async def collect_tasks(): + next_done = task_group.next_done + while True: + await next_done() + + task_group = self._task_group + async with task_group: + await self.spawn(self._receive_messages) + await self.spawn(collect_tasks) + + async def _limited_wait(self, secs): + # Wait at most secs seconds to send, otherwise abort the connection + try: + async with timeout_after(secs): + await self._can_send.wait() + except TaskTimeout: + self.abort() + raise + + async def _send_message(self, message): + if not self._can_send.is_set(): + await self._limited_wait(self.max_send_delay) + if not self.is_closing(): + framed_message = self.framer.frame(message) + self.send_size += len(framed_message) + self._using_bandwidth(len(framed_message)) + self.send_count += 1 + self.last_send = time.time() + if self.verbosity >= 4: + self.logger.debug(f'Sending framed message {framed_message}') + self.transport.write(framed_message) + + def _bump_errors(self): + self.errors += 1 + if self.errors >= self.max_errors: + # Don't await self.close() because that is self-cancelling + self._close() + + def _close(self): + if self.transport: + self.transport.close() + + # asyncio framework + def data_received(self, framed_message): + '''Called by asyncio when a message comes in.''' + if self.verbosity >= 4: + self.logger.debug(f'Received framed message {framed_message}') + self.recv_size += len(framed_message) + self._using_bandwidth(len(framed_message)) + self.framer.received_bytes(framed_message) + + def pause_writing(self): + '''Transport calls when the send buffer is full.''' + if not self.is_closing(): + self._can_send.clear() + self.transport.pause_reading() + + def resume_writing(self): + '''Transport calls when the send buffer has room.''' + if not self._can_send.is_set(): + self._can_send.set() + self.transport.resume_reading() + + def connection_made(self, transport): + '''Called by asyncio when a connection is established. + + Derived classes overriding this method must call this first.''' + self.transport = transport + # This would throw if called on a closed SSL transport. Fixed + # in asyncio in Python 3.6.1 and 3.5.4 + peer_address = transport.get_extra_info('peername') + # If the Socks proxy was used then _address is already set to + # the remote address + if self._address: + self._proxy_address = peer_address + else: + self._address = peer_address + self._pm_task = spawn_sync(self._process_messages(), loop=self.loop) + + def connection_lost(self, exc): + '''Called by asyncio when the connection closes. + + Tear down things done in connection_made.''' + self._address = None + self.transport = None + self._pm_task.cancel() + # Release waiting tasks + self._can_send.set() + + # External API + def default_framer(self): + '''Return a default framer.''' + raise NotImplementedError + + def peer_address(self): + '''Returns the peer's address (Python networking address), or None if + no connection or an error. + + This is the result of socket.getpeername() when the connection + was made. + ''' + return self._address + + def peer_address_str(self): + '''Returns the peer's IP address and port as a human-readable + string.''' + if not self._address: + return 'unknown' + ip_addr_str, port = self._address[:2] + if ':' in ip_addr_str: + return f'[{ip_addr_str}]:{port}' + else: + return f'{ip_addr_str}:{port}' + + async def spawn(self, coro, *args): + '''If the session is connected, spawn a task that is cancelled + on disconnect, and return it. Otherwise return None.''' + group = self._task_group + if not group.closed(): + return await group.spawn(coro, *args) + else: + return None + + def is_closing(self): + '''Return True if the connection is closing.''' + return not self.transport or self.transport.is_closing() + + def abort(self): + '''Forcefully close the connection.''' + if self.transport: + self.transport.abort() + + async def close(self, *, force_after=30): + '''Close the connection and return when closed.''' + self._close() + if self._pm_task: + with suppress(CancelledError): + async with ignore_after(force_after): + await self._pm_task + self.abort() + await self._pm_task + + +class MessageSession(SessionBase): + '''Session class for protocols where messages are not tied to responses, + such as the Bitcoin protocol. + + To use as a client (connection-opening) session, pass host, port + and perhaps a proxy. + ''' + async def _receive_messages(self): + while not self.is_closing(): + try: + message = await self.framer.receive_message() + except BadMagicError as e: + magic, expected = e.args + self.logger.error( + f'bad network magic: got {magic} expected {expected}, ' + f'disconnecting' + ) + self._close() + except OversizedPayloadError as e: + command, payload_len = e.args + self.logger.error( + f'oversized payload of {payload_len:,d} bytes to command ' + f'{command}, disconnecting' + ) + self._close() + except BadChecksumError as e: + payload_checksum, claimed_checksum = e.args + self.logger.warning( + f'checksum mismatch: actual {payload_checksum.hex()} ' + f'vs claimed {claimed_checksum.hex()}' + ) + self._bump_errors() + else: + self.last_recv = time.time() + self.recv_count += 1 + if self.recv_count % 10 == 0: + await self._update_concurrency() + await self.spawn(self._throttled_message(message)) + + async def _throttled_message(self, message): + '''Process a single request, respecting the concurrency limit.''' + async with self._concurrency.semaphore: + try: + await self.handle_message(message) + except ProtocolError as e: + self.logger.error(f'{e}') + self._bump_errors() + except CancelledError: + raise + except Exception: + self.logger.exception(f'exception handling {message}') + self._bump_errors() + + # External API + def default_framer(self): + '''Return a bitcoin framer.''' + return BitcoinFramer(bytes.fromhex('e3e1f3e8'), 128_000_000) + + async def handle_message(self, message): + '''message is a (command, payload) pair.''' + pass + + async def send_message(self, message): + '''Send a message (command, payload) over the network.''' + await self._send_message(message) + + +class BatchError(Exception): + + def __init__(self, request): + self.request = request # BatchRequest object + + +class BatchRequest(object): + '''Used to build a batch request to send to the server. Stores + the + + Attributes batch and results are initially None. + + Adding an invalid request or notification immediately raises a + ProtocolError. + + On exiting the with clause, it will: + + 1) create a Batch object for the requests in the order they were + added. If the batch is empty this raises a ProtocolError. + + 2) set the "batch" attribute to be that batch + + 3) send the batch request and wait for a response + + 4) raise a ProtocolError if the protocol was violated by the + server. Currently this only happens if it gave more than one + response to any request + + 5) otherwise there is precisely one response to each Request. Set + the "results" attribute to the tuple of results; the responses + are ordered to match the Requests in the batch. Notifications + do not get a response. + + 6) if raise_errors is True and any individual response was a JSON + RPC error response, or violated the protocol in some way, a + BatchError exception is raised. Otherwise the caller can be + certain each request returned a standard result. + ''' + + def __init__(self, session, raise_errors): + self._session = session + self._raise_errors = raise_errors + self._requests = [] + self.batch = None + self.results = None + + def add_request(self, method, args=()): + self._requests.append(Request(method, args)) + + def add_notification(self, method, args=()): + self._requests.append(Notification(method, args)) + + def __len__(self): + return len(self._requests) + + async def __aenter__(self): + return self + + async def __aexit__(self, exc_type, exc_value, traceback): + if exc_type is None: + self.batch = Batch(self._requests) + message, event = self._session.connection.send_batch(self.batch) + await self._session._send_message(message) + await event.wait() + self.results = event.result + if self._raise_errors: + if any(isinstance(item, Exception) for item in event.result): + raise BatchError(self) + + +class RPCSession(SessionBase): + '''Base class for protocols where a message can lead to a response, + for example JSON RPC.''' + + def __init__(self, *, framer=None, loop=None, connection=None): + super().__init__(framer=framer, loop=loop) + self.connection = connection or self.default_connection() + + async def _receive_messages(self): + while not self.is_closing(): + try: + message = await self.framer.receive_message() + except MemoryError as e: + self.logger.warning(f'{e!r}') + continue + + self.last_recv = time.time() + self.recv_count += 1 + if self.recv_count % 10 == 0: + await self._update_concurrency() + + try: + requests = self.connection.receive_message(message) + except ProtocolError as e: + self.logger.debug(f'{e}') + if e.error_message: + await self._send_message(e.error_message) + if e.code == JSONRPC.PARSE_ERROR: + self.max_errors = 0 + self._bump_errors() + else: + for request in requests: + await self.spawn(self._throttled_request(request)) + + async def _throttled_request(self, request): + '''Process a single request, respecting the concurrency limit.''' + async with self._concurrency.semaphore: + try: + result = await self.handle_request(request) + except (ProtocolError, RPCError) as e: + result = e + except CancelledError: + raise + except Exception: + self.logger.exception(f'exception handling {request}') + result = RPCError(JSONRPC.INTERNAL_ERROR, + 'internal server error') + if isinstance(request, Request): + message = request.send_result(result) + if message: + await self._send_message(message) + if isinstance(result, Exception): + self._bump_errors() + + def connection_lost(self, exc): + # Cancel pending requests and message processing + self.connection.cancel_pending_requests() + super().connection_lost(exc) + + # External API + def default_connection(self): + '''Return a default connection if the user provides none.''' + return JSONRPCConnection(JSONRPCv2) + + def default_framer(self): + '''Return a default framer.''' + return NewlineFramer() + + async def handle_request(self, request): + pass + + async def send_request(self, method, args=()): + '''Send an RPC request over the network.''' + message, event = self.connection.send_request(Request(method, args)) + await self._send_message(message) + await event.wait() + result = event.result + if isinstance(result, Exception): + raise result + return result + + async def send_notification(self, method, args=()): + '''Send an RPC notification over the network.''' + message = self.connection.send_notification(Notification(method, args)) + await self._send_message(message) + + def send_batch(self, raise_errors=False): + '''Return a BatchRequest. Intended to be used like so: + + async with session.send_batch() as batch: + batch.add_request("method1") + batch.add_request("sum", (x, y)) + batch.add_notification("updated") + + for result in batch.results: + ... + + Note that in some circumstances exceptions can be raised; see + BatchRequest doc string. + ''' + return BatchRequest(self, raise_errors) + + +class Server(object): + '''A simple wrapper around an asyncio.Server object.''' + + def __init__(self, session_factory, host=None, port=None, *, + loop=None, **kwargs): + self.host = host + self.port = port + self.loop = loop or asyncio.get_event_loop() + self.server = None + self._session_factory = session_factory + self._kwargs = kwargs + + async def listen(self): + self.server = await self.loop.create_server( + self._session_factory, self.host, self.port, **self._kwargs) + + async def close(self): + '''Close the listening socket. This does not close any ServerSession + objects created to handle incoming connections. + ''' + if self.server: + self.server.close() + await self.server.wait_closed() + self.server = None diff --git a/torba/rpc/socks.py b/torba/rpc/socks.py new file mode 100644 index 000000000..cc4b63f13 --- /dev/null +++ b/torba/rpc/socks.py @@ -0,0 +1,439 @@ +# Copyright (c) 2018, Neil Booth +# +# All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +'''SOCKS proxying.''' + +import sys +import asyncio +import collections +import ipaddress +import socket +import struct +from functools import partial + + +__all__ = ('SOCKSUserAuth', 'SOCKS4', 'SOCKS4a', 'SOCKS5', 'SOCKSProxy', + 'SOCKSError', 'SOCKSProtocolError', 'SOCKSFailure') + + +SOCKSUserAuth = collections.namedtuple("SOCKSUserAuth", "username password") + + +class SOCKSError(Exception): + '''Base class for SOCKS exceptions. Each raised exception will be + an instance of a derived class.''' + + +class SOCKSProtocolError(SOCKSError): + '''Raised when the proxy does not follow the SOCKS protocol''' + + +class SOCKSFailure(SOCKSError): + '''Raised when the proxy refuses or fails to make a connection''' + + +class NeedData(Exception): + pass + + +class SOCKSBase(object): + + @classmethod + def name(cls): + return cls.__name__ + + def __init__(self): + self._buffer = bytes() + self._state = self._start + + def _read(self, size): + if len(self._buffer) < size: + raise NeedData(size - len(self._buffer)) + result = self._buffer[:size] + self._buffer = self._buffer[size:] + return result + + def receive_data(self, data): + self._buffer += data + + def next_message(self): + return self._state() + + +class SOCKS4(SOCKSBase): + '''SOCKS4 protocol wrapper.''' + + # See http://ftp.icm.edu.pl/packages/socks/socks4/SOCKS4.protocol + REPLY_CODES = { + 90: 'request granted', + 91: 'request rejected or failed', + 92: ('request rejected because SOCKS server cannot connect ' + 'to identd on the client'), + 93: ('request rejected because the client program and identd ' + 'report different user-ids') + } + + def __init__(self, dst_host, dst_port, auth): + super().__init__() + self._dst_host = self._check_host(dst_host) + self._dst_port = dst_port + self._auth = auth + + @classmethod + def _check_host(cls, host): + if not isinstance(host, ipaddress.IPv4Address): + try: + host = ipaddress.IPv4Address(host) + except ValueError: + raise SOCKSProtocolError( + f'SOCKS4 requires an IPv4 address: {host}') from None + return host + + def _start(self): + self._state = self._first_response + + if isinstance(self._dst_host, ipaddress.IPv4Address): + # SOCKS4 + dst_ip_packed = self._dst_host.packed + host_bytes = b'' + else: + # SOCKS4a + dst_ip_packed = b'\0\0\0\1' + host_bytes = self._dst_host.encode() + b'\0' + + if isinstance(self._auth, SOCKSUserAuth): + user_id = self._auth.username.encode() + else: + user_id = b'' + + # Send TCP/IP stream CONNECT request + return b''.join([b'\4\1', struct.pack('>H', self._dst_port), + dst_ip_packed, user_id, b'\0', host_bytes]) + + def _first_response(self): + # Wait for 8-byte response + data = self._read(8) + if data[0] != 0: + raise SOCKSProtocolError(f'invalid {self.name()} proxy ' + f'response: {data}') + reply_code = data[1] + if reply_code != 90: + msg = self.REPLY_CODES.get( + reply_code, f'unknown {self.name()} reply code {reply_code}') + raise SOCKSFailure(f'{self.name()} proxy request failed: {msg}') + + # Other fields ignored + return None + + +class SOCKS4a(SOCKS4): + + @classmethod + def _check_host(cls, host): + if not isinstance(host, (str, ipaddress.IPv4Address)): + raise SOCKSProtocolError( + f'SOCKS4a requires an IPv4 address or host name: {host}') + return host + + +class SOCKS5(SOCKSBase): + '''SOCKS protocol wrapper.''' + + # See https://tools.ietf.org/html/rfc1928 + ERROR_CODES = { + 1: 'general SOCKS server failure', + 2: 'connection not allowed by ruleset', + 3: 'network unreachable', + 4: 'host unreachable', + 5: 'connection refused', + 6: 'TTL expired', + 7: 'command not supported', + 8: 'address type not supported', + } + + def __init__(self, dst_host, dst_port, auth): + super().__init__() + self._dst_bytes = self._destination_bytes(dst_host, dst_port) + self._auth_bytes, self._auth_methods = self._authentication(auth) + + def _destination_bytes(self, host, port): + if isinstance(host, ipaddress.IPv4Address): + addr_bytes = b'\1' + host.packed + elif isinstance(host, ipaddress.IPv6Address): + addr_bytes = b'\4' + host.packed + elif isinstance(host, str): + host = host.encode() + if len(host) > 255: + raise SOCKSProtocolError(f'hostname too long: ' + f'{len(host)} bytes') + addr_bytes = b'\3' + bytes([len(host)]) + host + else: + raise SOCKSProtocolError(f'SOCKS5 requires an IPv4 address, IPv6 ' + f'address, or host name: {host}') + return addr_bytes + struct.pack('>H', port) + + def _authentication(self, auth): + if isinstance(auth, SOCKSUserAuth): + user_bytes = auth.username.encode() + if not 0 < len(user_bytes) < 256: + raise SOCKSProtocolError(f'username {auth.username} has ' + f'invalid length {len(user_bytes)}') + pwd_bytes = auth.password.encode() + if not 0 < len(pwd_bytes) < 256: + raise SOCKSProtocolError(f'password has invalid length ' + f'{len(pwd_bytes)}') + return b''.join([bytes([1, len(user_bytes)]), user_bytes, + bytes([len(pwd_bytes)]), pwd_bytes]), [0, 2] + return b'', [0] + + def _start(self): + self._state = self._first_response + return (b'\5' + bytes([len(self._auth_methods)]) + + bytes(m for m in self._auth_methods)) + + def _first_response(self): + # Wait for 2-byte response + data = self._read(2) + if data[0] != 5: + raise SOCKSProtocolError(f'invalid SOCKS5 proxy response: {data}') + if data[1] not in self._auth_methods: + raise SOCKSFailure('SOCKS5 proxy rejected authentication methods') + + # Authenticate if user-password authentication + if data[1] == 2: + self._state = self._auth_response + return self._auth_bytes + return self._request_connection() + + def _auth_response(self): + data = self._read(2) + if data[0] != 1: + raise SOCKSProtocolError(f'invalid SOCKS5 proxy auth ' + f'response: {data}') + if data[1] != 0: + raise SOCKSFailure(f'SOCKS5 proxy auth failure code: ' + f'{data[1]}') + + return self._request_connection() + + def _request_connection(self): + # Send connection request + self._state = self._connect_response + return b'\5\1\0' + self._dst_bytes + + def _connect_response(self): + data = self._read(5) + if data[0] != 5 or data[2] != 0 or data[3] not in (1, 3, 4): + raise SOCKSProtocolError(f'invalid SOCKS5 proxy response: {data}') + if data[1] != 0: + raise SOCKSFailure(self.ERROR_CODES.get( + data[1], f'unknown SOCKS5 error code: {data[1]}')) + + if data[3] == 1: + addr_len = 3 # IPv4 + elif data[3] == 3: + addr_len = data[4] # Hostname + else: + addr_len = 15 # IPv6 + + self._state = partial(self._connect_response_rest, addr_len) + return self.next_message() + + def _connect_response_rest(self, addr_len): + self._read(addr_len + 2) + return None + + +class SOCKSProxy(object): + + def __init__(self, address, protocol, auth): + '''A SOCKS proxy at an address following a SOCKS protocol. auth is an + authentication method to use when connecting, or None. + + address is a (host, port) pair; for IPv6 it can instead be a + (host, port, flowinfo, scopeid) 4-tuple. + ''' + self.address = address + self.protocol = protocol + self.auth = auth + # Set on each successful connection via the proxy to the + # result of socket.getpeername() + self.peername = None + + def __str__(self): + auth = 'username' if self.auth else 'none' + return f'{self.protocol.name()} proxy at {self.address}, auth: {auth}' + + async def _handshake(self, client, sock, loop): + while True: + count = 0 + try: + message = client.next_message() + except NeedData as e: + count = e.args[0] + else: + if message is None: + return + await loop.sock_sendall(sock, message) + + if count: + data = await loop.sock_recv(sock, count) + if not data: + raise SOCKSProtocolError("EOF received") + client.receive_data(data) + + async def _connect_one(self, host, port): + '''Connect to the proxy and perform a handshake requesting a + connection to (host, port). + + Return the open socket on success, or the exception on failure. + ''' + client = self.protocol(host, port, self.auth) + sock = socket.socket() + loop = asyncio.get_event_loop() + try: + # A non-blocking socket is required by loop socket methods + sock.setblocking(False) + await loop.sock_connect(sock, self.address) + await self._handshake(client, sock, loop) + self.peername = sock.getpeername() + return sock + except Exception as e: + # Don't close - see https://github.com/kyuupichan/aiorpcX/issues/8 + if sys.platform.startswith('linux'): + sock.close() + return e + + async def _connect(self, addresses): + '''Connect to the proxy and perform a handshake requesting a + connection to each address in addresses. + + Return an (open_socket, address) pair on success. + ''' + assert len(addresses) > 0 + + exceptions = [] + for address in addresses: + host, port = address[:2] + sock = await self._connect_one(host, port) + if isinstance(sock, socket.socket): + return sock, address + exceptions.append(sock) + + strings = set(f'{exc!r}' for exc in exceptions) + raise (exceptions[0] if len(strings) == 1 else + OSError(f'multiple exceptions: {", ".join(strings)}')) + + async def _detect_proxy(self): + '''Return True if it appears we can connect to a SOCKS proxy, + otherwise False. + ''' + if self.protocol is SOCKS4a: + host, port = 'www.apple.com', 80 + else: + host, port = ipaddress.IPv4Address('8.8.8.8'), 53 + + sock = await self._connect_one(host, port) + if isinstance(sock, socket.socket): + sock.close() + return True + + # SOCKSFailure indicates something failed, but that we are + # likely talking to a proxy + return isinstance(sock, SOCKSFailure) + + @classmethod + async def auto_detect_address(cls, address, auth): + '''Try to detect a SOCKS proxy at address using the authentication + method (or None). SOCKS5, SOCKS4a and SOCKS are tried in + order. If a SOCKS proxy is detected a SOCKSProxy object is + returned. + + Returning a SOCKSProxy does not mean it is functioning - for + example, it may have no network connectivity. + + If no proxy is detected return None. + ''' + for protocol in (SOCKS5, SOCKS4a, SOCKS4): + proxy = cls(address, protocol, auth) + if await proxy._detect_proxy(): + return proxy + return None + + @classmethod + async def auto_detect_host(cls, host, ports, auth): + '''Try to detect a SOCKS proxy on a host on one of the ports. + + Calls auto_detect for the ports in order. Returns SOCKS are + tried in order; a SOCKSProxy object for the first detected + proxy is returned. + + Returning a SOCKSProxy does not mean it is functioning - for + example, it may have no network connectivity. + + If no proxy is detected return None. + ''' + for port in ports: + address = (host, port) + proxy = await cls.auto_detect_address(address, auth) + if proxy: + return proxy + + return None + + async def create_connection(self, protocol_factory, host, port, *, + resolve=False, ssl=None, + family=0, proto=0, flags=0): + '''Set up a connection to (host, port) through the proxy. + + If resolve is True then host is resolved locally with + getaddrinfo using family, proto and flags, otherwise the proxy + is asked to resolve host. + + The function signature is similar to loop.create_connection() + with the same result. The attribute _address is set on the + protocol to the address of the successful remote connection. + Additionally raises SOCKSError if something goes wrong with + the proxy handshake. + ''' + loop = asyncio.get_event_loop() + if resolve: + infos = await loop.getaddrinfo(host, port, family=family, + type=socket.SOCK_STREAM, + proto=proto, flags=flags) + addresses = [info[4] for info in infos] + else: + addresses = [(host, port)] + + sock, address = await self._connect(addresses) + + def set_address(): + protocol = protocol_factory() + protocol._address = address + return protocol + + return await loop.create_connection( + set_address, sock=sock, ssl=ssl, + server_hostname=host if ssl else None) diff --git a/torba/rpc/util.py b/torba/rpc/util.py new file mode 100644 index 000000000..07388e7a2 --- /dev/null +++ b/torba/rpc/util.py @@ -0,0 +1,120 @@ +# Copyright (c) 2018, Neil Booth +# +# All rights reserved. +# +# The MIT License (MIT) +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +__all__ = () + + +import asyncio +from collections import namedtuple +from functools import partial +import inspect + + +def normalize_corofunc(corofunc, args): + if asyncio.iscoroutine(corofunc): + if args != (): + raise ValueError('args cannot be passed with a coroutine') + return corofunc + return corofunc(*args) + + +def is_async_call(func): + '''inspect.iscoroutinefunction that looks through partials.''' + while isinstance(func, partial): + func = func.func + return inspect.iscoroutinefunction(func) + + +# other_params: None means cannot be called with keyword arguments only +# any means any name is good +SignatureInfo = namedtuple('SignatureInfo', 'min_args max_args ' + 'required_names other_names') + + +def signature_info(func): + params = inspect.signature(func).parameters + min_args = max_args = 0 + required_names = [] + other_names = [] + no_names = False + for p in params.values(): + if p.kind == p.POSITIONAL_OR_KEYWORD: + max_args += 1 + if p.default is p.empty: + min_args += 1 + required_names.append(p.name) + else: + other_names.append(p.name) + elif p.kind == p.KEYWORD_ONLY: + other_names.append(p.name) + elif p.kind == p.VAR_POSITIONAL: + max_args = None + elif p.kind == p.VAR_KEYWORD: + other_names = any + elif p.kind == p.POSITIONAL_ONLY: + max_args += 1 + if p.default is p.empty: + min_args += 1 + no_names = True + + if no_names: + other_names = None + + return SignatureInfo(min_args, max_args, required_names, other_names) + + +class Concurrency(object): + + def __init__(self, max_concurrent): + self._require_non_negative(max_concurrent) + self._max_concurrent = max_concurrent + self.semaphore = asyncio.Semaphore(max_concurrent) + + def _require_non_negative(self, value): + if not isinstance(value, int) or value < 0: + raise RuntimeError('concurrency must be a natural number') + + @property + def max_concurrent(self): + return self._max_concurrent + + async def set_max_concurrent(self, value): + self._require_non_negative(value) + diff = value - self._max_concurrent + self._max_concurrent = value + if diff >= 0: + for _ in range(diff): + self.semaphore.release() + else: + for _ in range(-diff): + await self.semaphore.acquire() + + +def check_task(logger, task): + if not task.cancelled(): + try: + task.result() + except Exception: + logger.error('task crashed: %r', task, exc_info=True) diff --git a/torba/server/block_processor.py b/torba/server/block_processor.py index 2cbafe041..fe2b44bea 100644 --- a/torba/server/block_processor.py +++ b/torba/server/block_processor.py @@ -15,7 +15,7 @@ from struct import pack, unpack import time from functools import partial -from aiorpcx import TaskGroup, run_in_thread +from torba.rpc import TaskGroup, run_in_thread import torba from torba.server.daemon import DaemonError diff --git a/torba/server/daemon.py b/torba/server/daemon.py index dd53ae63c..dba43abd8 100644 --- a/torba/server/daemon.py +++ b/torba/server/daemon.py @@ -22,7 +22,7 @@ from torba.server.util import hex_to_bytes, class_logger,\ unpack_le_uint16_from, pack_varint from torba.server.hash import hex_str_to_hash, hash_to_hex_str from torba.server.tx import DeserializerDecred -from aiorpcx import JSONRPC +from torba.rpc import JSONRPC class DaemonError(Exception): diff --git a/torba/server/db.py b/torba/server/db.py index d1af32592..2e843ee62 100644 --- a/torba/server/db.py +++ b/torba/server/db.py @@ -19,8 +19,8 @@ from glob import glob from struct import pack, unpack import attr -from aiorpcx import run_in_thread, sleep +from torba.rpc import run_in_thread, sleep from torba.server import util from torba.server.hash import hash_to_hex_str, HASHX_LEN from torba.server.merkle import Merkle, MerkleCache diff --git a/torba/server/mempool.py b/torba/server/mempool.py index 1f725aa5b..d5ecd6804 100644 --- a/torba/server/mempool.py +++ b/torba/server/mempool.py @@ -14,8 +14,8 @@ from asyncio import Lock from collections import defaultdict import attr -from aiorpcx import TaskGroup, run_in_thread, sleep +from torba.rpc import TaskGroup, run_in_thread, sleep from torba.server.hash import hash_to_hex_str, hex_str_to_hash from torba.server.util import class_logger, chunks from torba.server.db import UTXO diff --git a/torba/server/merkle.py b/torba/server/merkle.py index a96921936..f0c4d9a7a 100644 --- a/torba/server/merkle.py +++ b/torba/server/merkle.py @@ -28,8 +28,7 @@ from math import ceil, log -from aiorpcx import Event - +from torba.rpc import Event from torba.server.hash import double_sha256 diff --git a/torba/server/peers.py b/torba/server/peers.py index d24810fde..d77d0de39 100644 --- a/torba/server/peers.py +++ b/torba/server/peers.py @@ -14,11 +14,10 @@ import ssl import time from collections import defaultdict, Counter -from aiorpcx import (Connector, RPCSession, SOCKSProxy, +from torba.rpc import (Connector, RPCSession, SOCKSProxy, Notification, handler_invocation, SOCKSError, RPCError, TaskTimeout, TaskGroup, Event, sleep, run_in_thread, ignore_after, timeout_after) - from torba.server.peer import Peer from torba.server.util import class_logger, protocol_tuple diff --git a/torba/server/session.py b/torba/server/session.py index 14e4668ef..af38d7725 100644 --- a/torba/server/session.py +++ b/torba/server/session.py @@ -19,13 +19,12 @@ import time from collections import defaultdict from functools import partial -from aiorpcx import ( +import torba +from torba.rpc import ( RPCSession, JSONRPCAutoDetect, JSONRPCConnection, TaskGroup, handler_invocation, RPCError, Request, ignore_after, sleep, Event ) - -import torba from torba.server import text from torba.server import util from torba.server.hash import (sha256, hash_to_hex_str, hex_str_to_hash, @@ -664,9 +663,9 @@ class SessionBase(RPCSession): super().connection_lost(exc) self.session_mgr.remove_session(self) msg = '' - if not self.can_send.is_set(): + if not self._can_send.is_set(): msg += ' whilst paused' - if self.concurrency.max_concurrent != self.max_concurrent: + if self._concurrency.max_concurrent != self.max_concurrent: msg += ' whilst throttled' if self.send_size >= 1024*1024: msg += ('. Sent {:,d} bytes in {:,d} messages' From b5f245d9b6a983e27aca08e14f74f3d0880361d9 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 5 Dec 2018 01:01:11 -0500 Subject: [PATCH 252/383] made pylint and mypy happy --- setup.cfg | 2 +- torba/client/basenetwork.py | 2 +- torba/rpc/jsonrpc.py | 8 ++++---- torba/rpc/session.py | 8 ++++++-- 4 files changed, 12 insertions(+), 8 deletions(-) diff --git a/setup.cfg b/setup.cfg index 60a6219bf..b9c236991 100644 --- a/setup.cfg +++ b/setup.cfg @@ -10,7 +10,7 @@ source = ignore_missing_imports = True [pylint] -ignore=words,server,workbench +ignore=words,server,workbench,rpc max-args=10 max-line-length=110 good-names=T,t,n,i,j,k,x,y,s,f,d,h,c,e,op,db,tx,io,cachedproperty,log,id diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index d193d6d47..4147cc42b 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -3,7 +3,7 @@ import asyncio from asyncio import CancelledError from itertools import cycle -from aiorpcx import RPCSession as BaseClientSession, Connector, RPCError +from torba.rpc import RPCSession as BaseClientSession, Connector, RPCError from torba import __version__ from torba.stream import StreamController diff --git a/torba/rpc/jsonrpc.py b/torba/rpc/jsonrpc.py index 6cbd5f11a..3aaa95e83 100644 --- a/torba/rpc/jsonrpc.py +++ b/torba/rpc/jsonrpc.py @@ -70,7 +70,7 @@ class Notification(SingleRequest): pass -class Batch(object): +class Batch: __slots__ = ('items', ) def __init__(self, items): @@ -646,9 +646,9 @@ class JSONRPCConnection(object): parts.append(error.error_message) if not items and parts: - error = ProtocolError(0, "") - error.error_message = protocol.batch_message_from_parts(parts) - raise error + protocol_error = ProtocolError(0, "") + protocol_error.error_message = protocol.batch_message_from_parts(parts) + raise protocol_error return items def _receive_response_batch(self, payloads): diff --git a/torba/rpc/session.py b/torba/rpc/session.py index 144cc2f02..655f4145b 100644 --- a/torba/rpc/session.py +++ b/torba/rpc/session.py @@ -29,15 +29,19 @@ __all__ = ('Connector', 'RPCSession', 'MessageSession', 'Server', import asyncio +from asyncio import Event, CancelledError import logging import time from contextlib import suppress -from . import * +from .jsonrpc import Request, JSONRPCConnection, JSONRPCv2, JSONRPC, Batch, Notification +from .jsonrpc import RPCError, ProtocolError +from .curio import TaskGroup, TaskTimeout, spawn_sync, ignore_after, timeout_after +from .framing import BadMagicError, BadChecksumError, OversizedPayloadError from .util import Concurrency -class Connector(object): +class Connector: def __init__(self, session_factory, host=None, port=None, proxy=None, **kwargs): From c36b4626a9a82b8403ac809073bc83e0f8bad3cf Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 5 Dec 2018 01:06:00 -0500 Subject: [PATCH 253/383] added missing imports --- torba/rpc/session.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/rpc/session.py b/torba/rpc/session.py index 655f4145b..5be1a7dfc 100644 --- a/torba/rpc/session.py +++ b/torba/rpc/session.py @@ -37,7 +37,7 @@ from contextlib import suppress from .jsonrpc import Request, JSONRPCConnection, JSONRPCv2, JSONRPC, Batch, Notification from .jsonrpc import RPCError, ProtocolError from .curio import TaskGroup, TaskTimeout, spawn_sync, ignore_after, timeout_after -from .framing import BadMagicError, BadChecksumError, OversizedPayloadError +from .framing import BadMagicError, BadChecksumError, OversizedPayloadError, BitcoinFramer, NewlineFramer from .util import Concurrency From 2b8c06bda73f6341ea1acd55582a70649af06327 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 5 Dec 2018 01:13:31 -0500 Subject: [PATCH 254/383] wip sync fixing --- .../integration/test_transactions.py | 35 ++++++++++++++++++ torba/client/baseledger.py | 2 +- torba/client/basetransaction.py | 19 +++++++++- torba/orchstr8/node.py | 4 +- torba/testcase.py | 37 ++++++++++++++----- 5 files changed, 84 insertions(+), 13 deletions(-) diff --git a/tests/client_tests/integration/test_transactions.py b/tests/client_tests/integration/test_transactions.py index 93f49a0d7..5c946a8d5 100644 --- a/tests/client_tests/integration/test_transactions.py +++ b/tests/client_tests/integration/test_transactions.py @@ -4,10 +4,45 @@ from torba.testcase import IntegrationTestCase from torba.client.constants import COIN +log = logging.getLogger(__name__) +log.setLevel(logging.INFO) + + class BasicTransactionTests(IntegrationTestCase): VERBOSITY = logging.WARN + async def test_stressing(self): + await self.blockchain.generate(1000) + await self.assertBalance(self.account, '0.0') + address1 = await self.account.receiving.get_or_create_usable_address() + hash1 = self.ledger.address_to_hash160(address1) + + tasks = [] + for _ in range(10): + sendtxid = await self.blockchain.send_to_address(address1, 100) + tasks.append(self.on_transaction_id(sendtxid)) + await asyncio.wait(tasks) + await self.assertBalance(self.account, '1000.0') + + tasks = [] + for _ in range(10): + tx = await self.ledger.transaction_class.create( + [], + [self.ledger.transaction_class.output_class.pay_pubkey_hash(1*COIN, hash1)], + [self.account], self.account + ) + await self.broadcast(tx) + tasks.append(asyncio.create_task(self.ledger.wait(tx))) + + await asyncio.wait(tasks) + + #await asyncio.sleep(5) + + await self.assertBalance(self.account, '1000.0') + + await self.blockchain.generate(1) + async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) await self.ledger.subscribe_account(account2) diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index 0cf147f52..35a792b62 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -500,7 +500,7 @@ class BaseLedger(metaclass=LedgerRegistry): def broadcast(self, tx): return self.network.broadcast(hexlify(tx.raw).decode()) - async def wait(self, tx: basetransaction.BaseTransaction, height=0): + async def wait(self, tx: basetransaction.BaseTransaction, height=-1): addresses = set() for txi in tx.inputs: if txi.txo_ref.txo is not None: diff --git a/torba/client/basetransaction.py b/torba/client/basetransaction.py index e0b63fce9..a022bfa2b 100644 --- a/torba/client/basetransaction.py +++ b/torba/client/basetransaction.py @@ -247,7 +247,7 @@ class BaseTransaction: output_class = BaseOutput def __init__(self, raw=None, version: int = 1, locktime: int = 0, is_verified: bool = False, - height: int = -1, position: int = -1) -> None: + height: int = -2, position: int = -1) -> None: self._raw = raw self.ref = TXRefMutable(self) self.version = version @@ -255,11 +255,28 @@ class BaseTransaction: self._inputs: List[BaseInput] = [] self._outputs: List[BaseOutput] = [] self.is_verified = is_verified + # Height Progression + # -2: not broadcast + # -1: in mempool but has unconfirmed inputs + # 0: in mempool and all inputs confirmed + # +num: confirmed in a specific block (height) self.height = height self.position = position if raw is not None: self._deserialize() + @property + def is_broadcast(self): + return self.height > -2 + + @property + def is_mempool(self): + return self.height in (-1, 0) + + @property + def is_confirmed(self): + return self.height > 0 + @property def id(self): return self.ref.id diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index 7e8d05bf6..3615e59ca 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -49,6 +49,7 @@ def get_blockchain_node_from_ledger(ledger_module): def set_logging(ledger_module, level): logging.getLogger('torba').setLevel(level) + logging.getLogger('torba.client').setLevel(logging.INFO) logging.getLogger('torba.server').setLevel(level) #logging.getLogger('asyncio').setLevel(level) logging.getLogger('blockchain').setLevel(level) @@ -213,8 +214,6 @@ class BlockchainProcess(asyncio.SubprocessProtocol): raise SystemError(data.decode('ascii')) elif b'Done loading' in data: self.ready.set() - elif b'Shutdown: done' in data: - self.stopped.set() def process_exited(self): self.stopped.set() @@ -298,6 +297,7 @@ class BlockchainNode: try: self.transport.terminate() await self.protocol.stopped.wait() + self.transport.close() finally: if cleanup: self.cleanup() diff --git a/torba/testcase.py b/torba/testcase.py index a7eabab4d..2d3542d40 100644 --- a/torba/testcase.py +++ b/torba/testcase.py @@ -1,6 +1,8 @@ import sys import logging import unittest +import asyncio +from asyncio.runners import _cancel_all_tasks # type: ignore from unittest.case import _Outcome from typing import Optional from torba.orchstr8 import Conductor @@ -12,17 +14,34 @@ from torba.client.wallet import Wallet from torba.client.util import satoshis_to_coins -try: - import asyncio - from asyncio.runners import _cancel_all_tasks # type: ignore -except ImportError: - import asyncio +class ColorHandler(logging.StreamHandler): - # this is only available in py3.7 - def _cancel_all_tasks(loop): - pass + level_color = { + logging.DEBUG: "black", + logging.INFO: "black", + logging.WARNING: "yellow", + logging.ERROR: "red" + } -HANDLER = logging.StreamHandler(sys.stdout) + color_code = dict( + black=30, red=31, green=32, yellow=33, + blue=34, magenta=35, cyan=36, white=37 + ) + + def emit(self, record): + try: + msg = self.format(record) + color_name = self.level_color.get(record.levelno, "black") + color_code = self.color_code[color_name] + stream = self.stream + stream.write('\x1b[%sm%s\x1b[0m' % (color_code, msg)) + stream.write(self.terminator) + self.flush() + except Exception: + self.handleError(record) + + +HANDLER = ColorHandler(sys.stdout) HANDLER.setFormatter( logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') ) From 2bd60021aab4ca53ea5a06c51090573fbb254c7d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 5 Dec 2018 07:35:06 -0500 Subject: [PATCH 255/383] pylint --- torba/testcase.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/testcase.py b/torba/testcase.py index 2d3542d40..7b808a920 100644 --- a/torba/testcase.py +++ b/torba/testcase.py @@ -1,8 +1,8 @@ import sys import logging -import unittest import asyncio from asyncio.runners import _cancel_all_tasks # type: ignore +import unittest from unittest.case import _Outcome from typing import Optional from torba.orchstr8 import Conductor From 1b7c5a1373a01d4d6936d92b736b1c83b7c1487f Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 5 Dec 2018 11:02:52 -0500 Subject: [PATCH 256/383] update_history serially handles unique addresses --- .../integration/test_transactions.py | 21 ++-- torba/client/baseledger.py | 107 +++++++++--------- torba/testcase.py | 14 ++- 3 files changed, 76 insertions(+), 66 deletions(-) diff --git a/tests/client_tests/integration/test_transactions.py b/tests/client_tests/integration/test_transactions.py index 5c946a8d5..611816be3 100644 --- a/tests/client_tests/integration/test_transactions.py +++ b/tests/client_tests/integration/test_transactions.py @@ -18,11 +18,16 @@ class BasicTransactionTests(IntegrationTestCase): address1 = await self.account.receiving.get_or_create_usable_address() hash1 = self.ledger.address_to_hash160(address1) - tasks = [] - for _ in range(10): - sendtxid = await self.blockchain.send_to_address(address1, 100) - tasks.append(self.on_transaction_id(sendtxid)) - await asyncio.wait(tasks) + txids = await asyncio.gather(*( + self.blockchain.send_to_address(address1, 100) + for _ in range(10) + )) + + await asyncio.wait([ + self.on_transaction_id(txid) + for txid in txids + ]) + await self.assertBalance(self.account, '1000.0') tasks = [] @@ -37,11 +42,7 @@ class BasicTransactionTests(IntegrationTestCase): await asyncio.wait(tasks) - #await asyncio.sleep(5) - - await self.assertBalance(self.account, '1000.0') - - await self.blockchain.generate(1) + await self.assertBalance(self.account, '999.99876') async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index 35a792b62..f3bd6cf73 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -75,20 +75,21 @@ class TransactionCacheItem: class SynchronizationMonitor: - def __init__(self): + def __init__(self, loop=None): self.done = asyncio.Event() self.tasks = [] + self.loop = loop or asyncio.get_event_loop() def add(self, coro): len(self.tasks) < 1 and self.done.clear() - asyncio.ensure_future(self._monitor(coro)) + self.loop.create_task(self._monitor(coro)) def cancel(self): for task in self.tasks: task.cancel() async def _monitor(self, coro): - task = asyncio.ensure_future(coro) + task = self.loop.create_task(coro) self.tasks.append(task) try: await task @@ -161,6 +162,7 @@ class BaseLedger(metaclass=LedgerRegistry): self.sync = SynchronizationMonitor() self._utxo_reservation_lock = asyncio.Lock() self._header_processing_lock = asyncio.Lock() + self._address_update_locks: Dict[str, asyncio.Lock] = {} @classmethod def get_id(cls): @@ -382,63 +384,66 @@ class BaseLedger(metaclass=LedgerRegistry): async def update_history(self, address, remote_status, address_manager: baseaccount.AddressManager = None): - local_status, local_history = await self.get_local_status_and_history(address) - if local_status == remote_status: - return + async with self._address_update_locks.setdefault(address, asyncio.Lock()): - remote_history = await self.network.get_history(address) + local_status, local_history = await self.get_local_status_and_history(address) - cache_tasks = [] - synced_history = StringIO() - for i, (txid, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): - if i < len(local_history) and local_history[i] == (txid, remote_height): - synced_history.write(f'{txid}:{remote_height}:') - else: - cache_tasks.append(asyncio.ensure_future( - self.cache_transaction(txid, remote_height) - )) + if local_status == remote_status: + return - for task in cache_tasks: - tx = await task + remote_history = await self.network.get_history(address) - check_db_for_txos = [] - for txi in tx.inputs: - if txi.txo_ref.txo is not None: - continue - cache_item = self._tx_cache.get(txi.txo_ref.tx_ref.id) - if cache_item is not None: - if cache_item.tx is None: - await cache_item.has_tx.wait() - assert cache_item.tx is not None - txi.txo_ref = cache_item.tx.outputs[txi.txo_ref.position].ref + cache_tasks = [] + synced_history = StringIO() + for i, (txid, remote_height) in enumerate(map(itemgetter('tx_hash', 'height'), remote_history)): + if i < len(local_history) and local_history[i] == (txid, remote_height): + synced_history.write(f'{txid}:{remote_height}:') else: - check_db_for_txos.append(txi.txo_ref.tx_ref.id) + cache_tasks.append(asyncio.ensure_future( + self.cache_transaction(txid, remote_height) + )) - referenced_txos = { - txo.id: txo for txo in await self.db.get_txos(txoid__in=check_db_for_txos) - } + for task in cache_tasks: + tx = await task - for txi in tx.inputs: - if txi.txo_ref.txo is not None: - continue - referenced_txo = referenced_txos.get(txi.txo_ref.tx_ref.id) - if referenced_txo is not None: - txi.txo_ref = referenced_txo.ref + check_db_for_txos = [] + for txi in tx.inputs: + if txi.txo_ref.txo is not None: + continue + cache_item = self._tx_cache.get(txi.txo_ref.tx_ref.id) + if cache_item is not None: + if cache_item.tx is None: + await cache_item.has_tx.wait() + assert cache_item.tx is not None + txi.txo_ref = cache_item.tx.outputs[txi.txo_ref.position].ref + else: + check_db_for_txos.append(txi.txo_ref.tx_ref.id) - synced_history.write(f'{tx.id}:{tx.height}:') + referenced_txos = { + txo.id: txo for txo in await self.db.get_txos(txoid__in=check_db_for_txos) + } - await self.db.save_transaction_io( - tx, address, self.address_to_hash160(address), synced_history.getvalue() - ) + for txi in tx.inputs: + if txi.txo_ref.txo is not None: + continue + referenced_txo = referenced_txos.get(txi.txo_ref.tx_ref.id) + if referenced_txo is not None: + txi.txo_ref = referenced_txo.ref - self._on_transaction_controller.add(TransactionEvent(address, tx)) + synced_history.write(f'{tx.id}:{tx.height}:') - if address_manager is None: - address_manager = await self.get_address_manager_for_address(address) + await self.db.save_transaction_io( + tx, address, self.address_to_hash160(address), synced_history.getvalue() + ) - if address_manager is not None: - await address_manager.ensure_address_gap() + await self._on_transaction_controller.add(TransactionEvent(address, tx)) + + if address_manager is None: + address_manager = await self.get_address_manager_for_address(address) + + if address_manager is not None: + await address_manager.ensure_address_gap() async def cache_transaction(self, txid, remote_height): cache_item = self._tx_cache.get(txid) @@ -449,9 +454,8 @@ class BaseLedger(metaclass=LedgerRegistry): (cache_item.tx.is_verified or remote_height < 1): return cache_item.tx # cached tx is already up-to-date - await cache_item.lock.acquire() + async with cache_item.lock: - try: tx = cache_item.tx if tx is None: @@ -478,9 +482,6 @@ class BaseLedger(metaclass=LedgerRegistry): return tx - finally: - cache_item.lock.release() - async def maybe_verify_transaction(self, tx, remote_height): tx.height = remote_height if 0 < remote_height <= len(self.headers): @@ -514,6 +515,6 @@ class BaseLedger(metaclass=LedgerRegistry): records = await self.db.get_addresses(cols=('address',), address__in=addresses) await asyncio.wait([ self.on_transaction.where(partial( - lambda a, e: a == e.address and e.tx.height >= height, address_record['address'] + lambda a, e: a == e.address and e.tx.height >= height and e.tx.id == tx.id, address_record['address'] )) for address_record in records ]) diff --git a/torba/testcase.py b/torba/testcase.py index 7b808a920..8e61b7828 100644 --- a/torba/testcase.py +++ b/torba/testcase.py @@ -18,14 +18,22 @@ class ColorHandler(logging.StreamHandler): level_color = { logging.DEBUG: "black", - logging.INFO: "black", + logging.INFO: "light_gray", logging.WARNING: "yellow", logging.ERROR: "red" } color_code = dict( - black=30, red=31, green=32, yellow=33, - blue=34, magenta=35, cyan=36, white=37 + black=30, + red=31, + green=32, + yellow=33, + blue=34, + magenta=35, + cyan=36, + white=37, + light_gray='0;37', + dark_gray='1;30' ) def emit(self, record): From cff22a895100109aadb6c13b7e8624acdf3ebb88 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 5 Dec 2018 11:06:19 -0500 Subject: [PATCH 257/383] pylint line too long --- torba/client/baseledger.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index f3bd6cf73..511d98c37 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -515,6 +515,7 @@ class BaseLedger(metaclass=LedgerRegistry): records = await self.db.get_addresses(cols=('address',), address__in=addresses) await asyncio.wait([ self.on_transaction.where(partial( - lambda a, e: a == e.address and e.tx.height >= height and e.tx.id == tx.id, address_record['address'] + lambda a, e: a == e.address and e.tx.height >= height and e.tx.id == tx.id, + address_record['address'] )) for address_record in records ]) From e96b2f702d26e770131e544f881025b94f75bef5 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 5 Dec 2018 11:49:22 -0500 Subject: [PATCH 258/383] 0.2.3 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 6e6b4e6d9..d018fac92 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.2.2' +__version__ = '0.2.3' From 4c854dd5a7fae1333b6f909245934511ff3cd98c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 5 Dec 2018 11:50:11 -0500 Subject: [PATCH 259/383] 0.2.4 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index d018fac92..7f85c65d8 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.2.3' +__version__ = '0.2.4' From 367ffdea1f05a0974b928477fc358a59ec2f397d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 5 Dec 2018 23:42:16 -0500 Subject: [PATCH 260/383] may be the sync fix --- torba/client/baseledger.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index 511d98c37..26cce3da9 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -91,6 +91,7 @@ class SynchronizationMonitor: async def _monitor(self, coro): task = self.loop.create_task(coro) self.tasks.append(task) + log.info('sync tasks: %s', len(self.tasks)) try: await task finally: @@ -418,7 +419,7 @@ class BaseLedger(metaclass=LedgerRegistry): assert cache_item.tx is not None txi.txo_ref = cache_item.tx.outputs[txi.txo_ref.position].ref else: - check_db_for_txos.append(txi.txo_ref.tx_ref.id) + check_db_for_txos.append(txi.txo_ref.id) referenced_txos = { txo.id: txo for txo in await self.db.get_txos(txoid__in=check_db_for_txos) @@ -427,7 +428,7 @@ class BaseLedger(metaclass=LedgerRegistry): for txi in tx.inputs: if txi.txo_ref.txo is not None: continue - referenced_txo = referenced_txos.get(txi.txo_ref.tx_ref.id) + referenced_txo = referenced_txos.get(txi.txo_ref.id) if referenced_txo is not None: txi.txo_ref = referenced_txo.ref From b2544139e658ca6edae87d2eeeb64ba848fafc27 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 5 Dec 2018 23:45:35 -0500 Subject: [PATCH 261/383] stress test --- tests/client_tests/integration/test_sync.py | 2 +- .../integration/test_transactions.py | 50 +++++++++---------- torba/orchstr8/node.py | 2 +- 3 files changed, 27 insertions(+), 27 deletions(-) diff --git a/tests/client_tests/integration/test_sync.py b/tests/client_tests/integration/test_sync.py index 9ce75d917..1a43d0954 100644 --- a/tests/client_tests/integration/test_sync.py +++ b/tests/client_tests/integration/test_sync.py @@ -6,7 +6,7 @@ from torba.client.constants import CENT class SyncTests(IntegrationTestCase): - VERBOSITY = logging.INFO + VERBOSITY = logging.WARN def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) diff --git a/tests/client_tests/integration/test_transactions.py b/tests/client_tests/integration/test_transactions.py index 611816be3..68a2fb182 100644 --- a/tests/client_tests/integration/test_transactions.py +++ b/tests/client_tests/integration/test_transactions.py @@ -1,13 +1,10 @@ import logging import asyncio +from itertools import chain from torba.testcase import IntegrationTestCase from torba.client.constants import COIN -log = logging.getLogger(__name__) -log.setLevel(logging.INFO) - - class BasicTransactionTests(IntegrationTestCase): VERBOSITY = logging.WARN @@ -15,34 +12,37 @@ class BasicTransactionTests(IntegrationTestCase): async def test_stressing(self): await self.blockchain.generate(1000) await self.assertBalance(self.account, '0.0') - address1 = await self.account.receiving.get_or_create_usable_address() - hash1 = self.ledger.address_to_hash160(address1) + addresses = await self.account.receiving.get_addresses() - txids = await asyncio.gather(*( - self.blockchain.send_to_address(address1, 100) - for _ in range(10) + sends = list(chain( + (self.blockchain.send_to_address(address, 10) for address in addresses), + (self.blockchain.send_to_address(addresses[-1], 10) for _ in range(10)) )) - await asyncio.wait([ - self.on_transaction_id(txid) - for txid in txids - ]) + for batch in range(0, len(sends), 10): + txids = await asyncio.gather(*sends[batch:batch+10]) + await asyncio.wait([ + self.on_transaction_id(txid) for txid in txids + ]) - await self.assertBalance(self.account, '1000.0') + await self.assertBalance(self.account, '300.0') + addresses = await self.account.receiving.get_addresses() + self.assertEqual(40, len(addresses)) - tasks = [] - for _ in range(10): - tx = await self.ledger.transaction_class.create( - [], - [self.ledger.transaction_class.output_class.pay_pubkey_hash(1*COIN, hash1)], - [self.account], self.account - ) - await self.broadcast(tx) - tasks.append(asyncio.create_task(self.ledger.wait(tx))) + await self.blockchain.generate(1) - await asyncio.wait(tasks) + self.assertEqual(30, await self.account.get_utxo_count()) - await self.assertBalance(self.account, '999.99876') + hash1 = self.ledger.address_to_hash160(addresses[-1]) + tx = await self.ledger.transaction_class.create( + [], + [self.ledger.transaction_class.output_class.pay_pubkey_hash(299*COIN, hash1)], + [self.account], self.account + ) + await self.broadcast(tx) + await self.ledger.wait(tx) + + self.assertEqual(2, await self.account.get_utxo_count()) # 299 + change async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index 3615e59ca..c6309e905 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -49,7 +49,7 @@ def get_blockchain_node_from_ledger(ledger_module): def set_logging(ledger_module, level): logging.getLogger('torba').setLevel(level) - logging.getLogger('torba.client').setLevel(logging.INFO) + logging.getLogger('torba.client').setLevel(level) logging.getLogger('torba.server').setLevel(level) #logging.getLogger('asyncio').setLevel(level) logging.getLogger('blockchain').setLevel(level) From b273d58a80765001acbfd76e243e4e3f8feadffb Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 6 Dec 2018 00:19:35 -0500 Subject: [PATCH 262/383] 0.2.5 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 7f85c65d8..2d20cabca 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.2.4' +__version__ = '0.2.5' From 612066165a30ad181004500ac4619b8c733dec9a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 6 Dec 2018 13:38:56 -0500 Subject: [PATCH 263/383] improved integration test for tx synchronization --- .../integration/test_transactions.py | 92 ++++++++++++------- torba/client/baseledger.py | 2 +- 2 files changed, 62 insertions(+), 32 deletions(-) diff --git a/tests/client_tests/integration/test_transactions.py b/tests/client_tests/integration/test_transactions.py index 68a2fb182..bdbd51dfa 100644 --- a/tests/client_tests/integration/test_transactions.py +++ b/tests/client_tests/integration/test_transactions.py @@ -2,47 +2,81 @@ import logging import asyncio from itertools import chain from torba.testcase import IntegrationTestCase -from torba.client.constants import COIN +from torba.client.util import satoshis_to_coins, coins_to_satoshis class BasicTransactionTests(IntegrationTestCase): VERBOSITY = logging.WARN - async def test_stressing(self): - await self.blockchain.generate(1000) + async def test_variety_of_transactions_and_longish_history(self): + await self.blockchain.generate(300) await self.assertBalance(self.account, '0.0') addresses = await self.account.receiving.get_addresses() + # send 10 coins to first 10 receiving addresses and then 10 transactions worth 10 coins each + # to the 10th receiving address for a total of 30 UTXOs on the entire account sends = list(chain( - (self.blockchain.send_to_address(address, 10) for address in addresses), - (self.blockchain.send_to_address(addresses[-1], 10) for _ in range(10)) + (self.blockchain.send_to_address(address, 10) for address in addresses[:10]), + (self.blockchain.send_to_address(addresses[9], 10) for _ in range(10)) )) - + # use batching to reduce issues with send_to_address on cli for batch in range(0, len(sends), 10): txids = await asyncio.gather(*sends[batch:batch+10]) - await asyncio.wait([ - self.on_transaction_id(txid) for txid in txids - ]) + await asyncio.wait([self.on_transaction_id(txid) for txid in txids]) + await self.assertBalance(self.account, '200.0') + self.assertEqual(20, await self.account.get_utxo_count()) - await self.assertBalance(self.account, '300.0') + # address gap should have increase by 10 to cover the first 10 addresses we've used up addresses = await self.account.receiving.get_addresses() - self.assertEqual(40, len(addresses)) + self.assertEqual(30, len(addresses)) + + # there used to be a sync bug which failed to save TXIs between + # daemon restarts, clearing cache replicates that behavior + self.ledger._tx_cache.clear() + + # spend from each of the first 10 addresses to the subsequent 10 addresses + txs = [] + for address in addresses[10:20]: + txs.append(await self.ledger.transaction_class.create( + [], + [self.ledger.transaction_class.output_class.pay_pubkey_hash( + coins_to_satoshis('1.0'), self.ledger.address_to_hash160(address) + )], + [self.account], self.account + )) + await asyncio.wait([self.broadcast(tx) for tx in txs]) + await asyncio.wait([self.ledger.wait(tx) for tx in txs]) + + # verify that a previous bug which failed to save TXIs doesn't come back + # this check must happen before generating a new block + self.assertTrue(all([ + tx.inputs[0].txo_ref.txo is not None + for tx in await self.ledger.db.get_transactions(txid__in=[tx.id for tx in txs]) + ])) await self.blockchain.generate(1) + await asyncio.wait([self.ledger.wait(tx) for tx in txs]) + await self.assertBalance(self.account, '199.99876') + # 10 of the UTXOs have been split into a 1 coin UTXO and a 9 UTXO change self.assertEqual(30, await self.account.get_utxo_count()) - hash1 = self.ledger.address_to_hash160(addresses[-1]) + # spend all 30 UTXOs into a a 199 coin UTXO and change tx = await self.ledger.transaction_class.create( [], - [self.ledger.transaction_class.output_class.pay_pubkey_hash(299*COIN, hash1)], + [self.ledger.transaction_class.output_class.pay_pubkey_hash( + coins_to_satoshis('199.0'), self.ledger.address_to_hash160(addresses[-1]) + )], [self.account], self.account ) await self.broadcast(tx) await self.ledger.wait(tx) + await self.blockchain.generate(1) + await self.ledger.wait(tx) - self.assertEqual(2, await self.account.get_utxo_count()) # 299 + change + self.assertEqual(2, await self.account.get_utxo_count()) # 199 + change + await self.assertBalance(self.account, '199.99649') async def test_sending_and_receiving(self): account1, account2 = self.account, self.wallet.generate_account(self.ledger) @@ -51,25 +85,22 @@ class BasicTransactionTests(IntegrationTestCase): await self.assertBalance(account1, '0.0') await self.assertBalance(account2, '0.0') - sendtxids = [] - for i in range(5): - address1 = await account1.receiving.get_or_create_usable_address() - sendtxid = await self.blockchain.send_to_address(address1, 1.1) - sendtxids.append(sendtxid) - await self.on_transaction_id(sendtxid) # mempool + addresses = await self.account.receiving.get_addresses() + txids = await asyncio.gather(*( + self.blockchain.send_to_address(address, 1.1) for address in addresses[:5] + )) + await asyncio.wait([self.on_transaction_id(txid) for txid in txids]) # mempool await self.blockchain.generate(1) - await asyncio.wait([ # confirmed - self.on_transaction_id(txid) for txid in sendtxids - ]) - + await asyncio.wait([self.on_transaction_id(txid) for txid in txids]) # confirmed await self.assertBalance(account1, '5.5') await self.assertBalance(account2, '0.0') address2 = await account2.receiving.get_or_create_usable_address() - hash2 = self.ledger.address_to_hash160(address2) tx = await self.ledger.transaction_class.create( [], - [self.ledger.transaction_class.output_class.pay_pubkey_hash(2*COIN, hash2)], + [self.ledger.transaction_class.output_class.pay_pubkey_hash( + coins_to_satoshis('2.0'), self.ledger.address_to_hash160(address2) + )], [account1], account1 ) await self.broadcast(tx) @@ -91,11 +122,10 @@ class BasicTransactionTests(IntegrationTestCase): await self.blockchain.generate(1) await self.ledger.wait(tx) # confirmed - txs = await account1.get_transactions() - tx = txs[1] - self.assertEqual(round(tx.inputs[0].txo_ref.txo.amount/COIN, 1), 1.1) - self.assertEqual(round(tx.inputs[1].txo_ref.txo.amount/COIN, 1), 1.1) - self.assertEqual(round(tx.outputs[0].amount/COIN, 1), 2.0) + tx = (await account1.get_transactions())[1] + self.assertEqual(satoshis_to_coins(tx.inputs[0].amount), '1.1') + self.assertEqual(satoshis_to_coins(tx.inputs[1].amount), '1.1') + self.assertEqual(satoshis_to_coins(tx.outputs[0].amount), '2.0') self.assertEqual(tx.outputs[0].get_address(self.ledger), address2) self.assertEqual(tx.outputs[0].is_change, False) self.assertEqual(tx.outputs[1].is_change, True) diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index 26cce3da9..c99c34612 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -91,7 +91,7 @@ class SynchronizationMonitor: async def _monitor(self, coro): task = self.loop.create_task(coro) self.tasks.append(task) - log.info('sync tasks: %s', len(self.tasks)) + log.debug('sync tasks: %s', len(self.tasks)) try: await task finally: From 8bc07fad32f5f35b1b0305db01d168d13e141410 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Fri, 7 Dec 2018 01:13:08 -0300 Subject: [PATCH 264/383] fast and furious --- torba/orchstr8/node.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index c6309e905..1918a1b01 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -177,7 +177,7 @@ class SPVNode: } os.environ.update(conf) self.server = Server(Env(self.coin_class)) - self.server.bp.prefetcher.polling_delay = 0.5 + self.server.mempool.refresh_secs = self.server.bp.prefetcher.polling_delay = 0.5 await self.server.start() async def stop(self, cleanup=True): From f4ec20a2e2559f4775cf411278c823a08497c1b1 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Fri, 7 Dec 2018 13:29:56 -0300 Subject: [PATCH 265/383] tentatively enable test_reorg for travis --- tests/client_tests/integration/test_blockchain_reorganization.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/client_tests/integration/test_blockchain_reorganization.py b/tests/client_tests/integration/test_blockchain_reorganization.py index f2bbb7930..6f6ecbd02 100644 --- a/tests/client_tests/integration/test_blockchain_reorganization.py +++ b/tests/client_tests/integration/test_blockchain_reorganization.py @@ -7,7 +7,6 @@ class BlockchainReorganizationTests(IntegrationTestCase): VERBOSITY = logging.WARN - @skip("too slow on Travis CI") async def test_reorg(self): self.assertEqual(self.ledger.headers.height, 200) From b93f9d4c9458a7a528cca48e9ce91e3fba840790 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 6 Dec 2018 14:27:38 -0500 Subject: [PATCH 266/383] removing dependence on curio abstraction --- torba/rpc/curio.py | 69 ++++++--------------------------- torba/server/block_processor.py | 6 +-- torba/server/db.py | 16 ++++---- torba/server/mempool.py | 13 ++++--- torba/server/merkle.py | 4 +- torba/server/peers.py | 14 +++---- torba/server/session.py | 9 ++--- 7 files changed, 41 insertions(+), 90 deletions(-) diff --git a/torba/rpc/curio.py b/torba/rpc/curio.py index 2e9d53bff..cccac1d3b 100644 --- a/torba/rpc/curio.py +++ b/torba/rpc/curio.py @@ -38,10 +38,6 @@ import logging import asyncio -from asyncio import ( - CancelledError, get_event_loop, Queue, Event, Lock, Semaphore, - sleep, Task -) from collections import deque from contextlib import suppress from functools import partial @@ -50,32 +46,22 @@ from .util import normalize_corofunc, check_task __all__ = ( - 'Queue', 'Event', 'Lock', 'Semaphore', 'sleep', 'CancelledError', - 'run_in_thread', 'spawn', 'spawn_sync', 'TaskGroup', + 'spawn_sync', 'TaskGroup', 'TaskTimeout', 'TimeoutCancellationError', 'UncaughtTimeoutError', - 'timeout_after', 'timeout_at', 'ignore_after', 'ignore_at', + 'timeout_after', 'ignore_after' ) -async def run_in_thread(func, *args): - '''Run a function in a separate thread, and await its completion.''' - return await get_event_loop().run_in_executor(None, func, *args) - - -async def spawn(coro, *args, loop=None, report_crash=True): - return spawn_sync(coro, *args, loop=loop, report_crash=report_crash) - - def spawn_sync(coro, *args, loop=None, report_crash=True): coro = normalize_corofunc(coro, args) - loop = loop or get_event_loop() + loop = loop or asyncio.get_event_loop() task = loop.create_task(coro) if report_crash: task.add_done_callback(partial(check_task, logging)) return task -class TaskGroup(object): +class TaskGroup: '''A class representing a group of executing tasks. tasks is an optional set of existing tasks to put into the group. New tasks can later be added using the spawn() method below. wait specifies @@ -98,7 +84,7 @@ class TaskGroup(object): self._done = deque() self._pending = set() self._wait = wait - self._done_event = Event() + self._done_event = asyncio.Event() self._logger = logging.getLogger(self.__class__.__name__) self._closed = False self.completed = None @@ -134,7 +120,7 @@ class TaskGroup(object): '''Create a new task that’s part of the group. Returns a Task instance. ''' - task = await spawn(coro, *args, report_crash=False) + task = spawn_sync(coro, *args, report_crash=False) self._add_task(task) return task @@ -205,7 +191,7 @@ class TaskGroup(object): self._closed = True for task in list(self._pending): task.cancel() - with suppress(CancelledError): + with suppress(asyncio.CancelledError): await task def closed(self): @@ -230,7 +216,7 @@ class TaskGroup(object): await self.join() -class TaskTimeout(CancelledError): +class TaskTimeout(asyncio.CancelledError): def __init__(self, secs): self.secs = secs @@ -239,7 +225,7 @@ class TaskTimeout(CancelledError): return f'task timed out after {self.args[0]}s' -class TimeoutCancellationError(CancelledError): +class TimeoutCancellationError(asyncio.CancelledError): pass @@ -302,7 +288,7 @@ class TimeoutAfter(object): async def __aexit__(self, exc_type, exc_value, traceback): timed_out_deadline, uncaught = _unset_task_deadline(self._task) - if exc_type not in (CancelledError, TaskTimeout, + if exc_type not in (asyncio.CancelledError, TaskTimeout, TimeoutCancellationError): return False if timed_out_deadline == self._deadline: @@ -311,7 +297,7 @@ class TimeoutAfter(object): return True raise TaskTimeout(self._secs) from None if timed_out_deadline is None: - assert exc_type is CancelledError + assert exc_type is asyncio.CancelledError return False if uncaught: raise UncaughtTimeoutError('uncaught timeout received') @@ -348,28 +334,6 @@ def timeout_after(seconds, coro=None, *args): return TimeoutAfter(seconds) -def timeout_at(clock, coro=None, *args): - '''Execute the specified coroutine and return its result. However, - issue a cancellation request to the calling task after seconds - have elapsed. When this happens, a TaskTimeout exception is - raised. If coro is None, the result of this function serves - as an asynchronous context manager that applies a timeout to a - block of statements. - - timeout_after() may be composed with other timeout_after() - operations (i.e., nested timeouts). If an outer timeout expires - first, then TimeoutCancellationError is raised instead of - TaskTimeout. If an inner timeout expires and fails to properly - TaskTimeout, a UncaughtTimeoutError is raised in the outer - timeout. - - ''' - if coro: - return _timeout_after_func(clock, True, coro, args) - - return TimeoutAfter(clock, absolute=True) - - async def _ignore_after_func(seconds, absolute, coro, args, timeout_result): coro = normalize_corofunc(coro, args) async with TimeoutAfter(seconds, absolute=absolute, ignore=True): @@ -398,14 +362,3 @@ def ignore_after(seconds, coro=None, *args, timeout_result=None): return _ignore_after_func(seconds, False, coro, args, timeout_result) return TimeoutAfter(seconds, ignore=True) - - -def ignore_at(clock, coro=None, *args, timeout_result=None): - ''' - Stop the enclosed task or block of code at an absolute - clock value. Same usage as ignore_after(). - ''' - if coro: - return _ignore_after_func(clock, True, coro, args, timeout_result) - - return TimeoutAfter(clock, absolute=True, ignore=True) diff --git a/torba/server/block_processor.py b/torba/server/block_processor.py index fe2b44bea..5a638c426 100644 --- a/torba/server/block_processor.py +++ b/torba/server/block_processor.py @@ -9,13 +9,11 @@ '''Block prefetcher and chain processor.''' -import array import asyncio from struct import pack, unpack import time -from functools import partial -from torba.rpc import TaskGroup, run_in_thread +from torba.rpc import TaskGroup import torba from torba.server.daemon import DaemonError @@ -187,7 +185,7 @@ class BlockProcessor: # consistent and not being updated elsewhere. async def run_in_thread_locked(): async with self.state_lock: - return await run_in_thread(func, *args) + return await asyncio.get_event_loop().run_in_executor(None, func, *args) return await asyncio.shield(run_in_thread_locked()) async def check_and_advance_blocks(self, raw_blocks): diff --git a/torba/server/db.py b/torba/server/db.py index 2e843ee62..593bf3d83 100644 --- a/torba/server/db.py +++ b/torba/server/db.py @@ -9,6 +9,7 @@ '''Interface to the blockchain database.''' +import asyncio import array import ast import os @@ -20,7 +21,6 @@ from struct import pack, unpack import attr -from torba.rpc import run_in_thread, sleep from torba.server import util from torba.server.hash import hash_to_hex_str, HASHX_LEN from torba.server.merkle import Merkle, MerkleCache @@ -403,7 +403,7 @@ class DB: return self.headers_file.read(offset, size), disk_count return b'', 0 - return await run_in_thread(read_headers) + return await asyncio.get_event_loop().run_in_executor(None, read_headers) def fs_tx_hash(self, tx_num): '''Return a par (tx_hash, tx_height) for the given tx number. @@ -443,12 +443,12 @@ class DB: return [fs_tx_hash(tx_num) for tx_num in tx_nums] while True: - history = await run_in_thread(read_history) + history = await asyncio.get_event_loop().run_in_executor(None, read_history) if all(hash is not None for hash, height in history): return history self.logger.warning(f'limited_history: tx hash ' f'not found (reorg?), retrying...') - await sleep(0.25) + await asyncio.sleep(0.25) # -- Undo information @@ -612,12 +612,12 @@ class DB: return utxos while True: - utxos = await run_in_thread(read_utxos) + utxos = await asyncio.get_event_loop().run_in_executor(None, read_utxos) if all(utxo.tx_hash is not None for utxo in utxos): return utxos self.logger.warning(f'all_utxos: tx hash not ' f'found (reorg?), retrying...') - await sleep(0.25) + await asyncio.sleep(0.25) async def lookup_utxos(self, prevouts): '''For each prevout, lookup it up in the DB and return a (hashX, @@ -665,5 +665,5 @@ class DB: return hashX, value return [lookup_utxo(*hashX_pair) for hashX_pair in hashX_pairs] - hashX_pairs = await run_in_thread(lookup_hashXs) - return await run_in_thread(lookup_utxos, hashX_pairs) + hashX_pairs = await asyncio.get_event_loop().run_in_executor(None, lookup_hashXs) + return await asyncio.get_event_loop().run_in_executor(None, lookup_utxos, hashX_pairs) diff --git a/torba/server/mempool.py b/torba/server/mempool.py index d5ecd6804..50f2e4681 100644 --- a/torba/server/mempool.py +++ b/torba/server/mempool.py @@ -7,6 +7,7 @@ '''Mempool handling.''' +import asyncio import itertools import time from abc import ABC, abstractmethod @@ -15,7 +16,7 @@ from collections import defaultdict import attr -from torba.rpc import TaskGroup, run_in_thread, sleep +from torba.rpc import TaskGroup from torba.server.hash import hash_to_hex_str, hex_str_to_hash from torba.server.util import class_logger, chunks from torba.server.db import UTXO @@ -117,7 +118,7 @@ class MemPool: while True: self.logger.info(f'{len(self.txs):,d} txs ' f'touching {len(self.hashXs):,d} addresses') - await sleep(self.log_status_secs) + await asyncio.sleep(self.log_status_secs) await synchronized_event.wait() async def _refresh_histogram(self, synchronized_event): @@ -125,8 +126,8 @@ class MemPool: await synchronized_event.wait() async with self.lock: # Threaded as can be expensive - await run_in_thread(self._update_histogram, 100_000) - await sleep(self.coin.MEMPOOL_HISTOGRAM_REFRESH_SECS) + await asyncio.get_event_loop().run_in_executor(None, self._update_histogram, 100_000) + await asyncio.sleep(self.coin.MEMPOOL_HISTOGRAM_REFRESH_SECS) def _update_histogram(self, bin_size): # Build a histogram by fee rate @@ -212,7 +213,7 @@ class MemPool: synchronized_event.set() synchronized_event.clear() await self.api.on_mempool(touched, height) - await sleep(self.refresh_secs) + await asyncio.sleep(self.refresh_secs) async def _process_mempool(self, all_hashes): # Re-sync with the new set of hashes @@ -284,7 +285,7 @@ class MemPool: return txs # Thread this potentially slow operation so as not to block - tx_map = await run_in_thread(deserialize_txs) + tx_map = await asyncio.get_event_loop().run_in_executor(None, deserialize_txs) # Determine all prevouts not in the mempool, and fetch the # UTXO information from the database. Failed prevout lookups diff --git a/torba/server/merkle.py b/torba/server/merkle.py index f0c4d9a7a..65ebd3b8b 100644 --- a/torba/server/merkle.py +++ b/torba/server/merkle.py @@ -26,9 +26,9 @@ '''Merkle trees, branches, proofs and roots.''' +import asyncio from math import ceil, log -from torba.rpc import Event from torba.server.hash import double_sha256 @@ -169,7 +169,7 @@ class MerkleCache: self.source_func = source_func self.length = 0 self.depth_higher = 0 - self.initialized = Event() + self.initialized = asyncio.Event() def _segment_length(self): return 1 << self.depth_higher diff --git a/torba/server/peers.py b/torba/server/peers.py index d77d0de39..af319c29a 100644 --- a/torba/server/peers.py +++ b/torba/server/peers.py @@ -14,10 +14,10 @@ import ssl import time from collections import defaultdict, Counter -from torba.rpc import (Connector, RPCSession, SOCKSProxy, - Notification, handler_invocation, - SOCKSError, RPCError, TaskTimeout, TaskGroup, Event, - sleep, run_in_thread, ignore_after, timeout_after) +from torba.rpc import ( + Connector, RPCSession, SOCKSProxy, Notification, handler_invocation, + SOCKSError, RPCError, TaskTimeout, TaskGroup, ignore_after, timeout_after +) from torba.server.peer import Peer from torba.server.util import class_logger, protocol_tuple @@ -149,7 +149,7 @@ class PeerManager: self.logger.info(f'detected {proxy}') return self.logger.info('no proxy detected, will try later') - await sleep(900) + await asyncio.sleep(900) async def _note_peers(self, peers, limit=2, check_ports=False, source=None): @@ -177,7 +177,7 @@ class PeerManager: use_peers = new_peers for peer in use_peers: self.logger.info(f'accepted new peer {peer} from {source}') - peer.retry_event = Event() + peer.retry_event = asyncio.Event() self.peers.add(peer) await self.group.spawn(self._monitor_peer(peer)) @@ -385,7 +385,7 @@ class PeerManager: self.logger.info(f'beginning peer discovery. Force use of ' f'proxy: {self.env.force_proxy}') - forever = Event() + forever = asyncio.Event() async with self.group as group: await group.spawn(forever.wait()) await group.spawn(self._detect_proxy()) diff --git a/torba/server/session.py b/torba/server/session.py index af38d7725..a7925acdb 100644 --- a/torba/server/session.py +++ b/torba/server/session.py @@ -22,8 +22,7 @@ from functools import partial import torba from torba.rpc import ( RPCSession, JSONRPCAutoDetect, JSONRPCConnection, - TaskGroup, handler_invocation, RPCError, Request, ignore_after, sleep, - Event + TaskGroup, handler_invocation, RPCError, Request ) from torba.server import text from torba.server import util @@ -131,7 +130,7 @@ class SessionManager: self.mn_cache_height = 0 self.mn_cache = [] - self.session_event = Event() + self.session_event = asyncio.Event() # Set up the RPC request handlers cmds = ('add_peer daemon_url disconnect getinfo groups log peers ' @@ -207,7 +206,7 @@ class SessionManager: log_interval = self.env.log_sessions if log_interval: while True: - await sleep(log_interval) + await asyncio.sleep(log_interval) data = self._session_data(for_log=True) for line in text.sessions_lines(data): self.logger.info(line) @@ -249,7 +248,7 @@ class SessionManager: async def _clear_stale_sessions(self): '''Cut off sessions that haven't done anything for 10 minutes.''' while True: - await sleep(60) + await asyncio.sleep(60) stale_cutoff = time.time() - self.env.session_timeout stale_sessions = [session for session in self.sessions if session.last_recv < stale_cutoff] From 5ed478ed115ca042f0d57bee8518c57711730445 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 6 Dec 2018 16:48:17 -0500 Subject: [PATCH 267/383] dropped everything in curio.py except TaskGroup so far, TaskGroup is next --- torba/rpc/curio.py | 168 +----------------------------------------- torba/rpc/session.py | 19 ++--- torba/server/peers.py | 18 +++-- 3 files changed, 20 insertions(+), 185 deletions(-) diff --git a/torba/rpc/curio.py b/torba/rpc/curio.py index cccac1d3b..b07f44b29 100644 --- a/torba/rpc/curio.py +++ b/torba/rpc/curio.py @@ -40,25 +40,9 @@ import logging import asyncio from collections import deque from contextlib import suppress -from functools import partial - -from .util import normalize_corofunc, check_task -__all__ = ( - 'spawn_sync', 'TaskGroup', - 'TaskTimeout', 'TimeoutCancellationError', 'UncaughtTimeoutError', - 'timeout_after', 'ignore_after' -) - - -def spawn_sync(coro, *args, loop=None, report_crash=True): - coro = normalize_corofunc(coro, args) - loop = loop or asyncio.get_event_loop() - task = loop.create_task(coro) - if report_crash: - task.add_done_callback(partial(check_task, logging)) - return task +__all__ = 'TaskGroup', class TaskGroup: @@ -120,7 +104,7 @@ class TaskGroup: '''Create a new task that’s part of the group. Returns a Task instance. ''' - task = spawn_sync(coro, *args, report_crash=False) + task = asyncio.create_task(coro) self._add_task(task) return task @@ -214,151 +198,3 @@ class TaskGroup: await self.cancel_remaining() else: await self.join() - - -class TaskTimeout(asyncio.CancelledError): - - def __init__(self, secs): - self.secs = secs - - def __str__(self): - return f'task timed out after {self.args[0]}s' - - -class TimeoutCancellationError(asyncio.CancelledError): - pass - - -class UncaughtTimeoutError(Exception): - pass - - -def _set_new_deadline(task, deadline): - def timeout_task(): - # Unfortunately task.cancel is all we can do with asyncio - task.cancel() - task._timed_out = deadline - task._deadline_handle = task._loop.call_at(deadline, timeout_task) - - -def _set_task_deadline(task, deadline): - deadlines = getattr(task, '_deadlines', []) - if deadlines: - if deadline < min(deadlines): - task._deadline_handle.cancel() - _set_new_deadline(task, deadline) - else: - _set_new_deadline(task, deadline) - deadlines.append(deadline) - task._deadlines = deadlines - task._timed_out = None - - -def _unset_task_deadline(task): - deadlines = task._deadlines - timed_out_deadline = task._timed_out - uncaught = timed_out_deadline not in deadlines - task._deadline_handle.cancel() - deadlines.pop() - if deadlines: - _set_new_deadline(task, min(deadlines)) - return timed_out_deadline, uncaught - - -class TimeoutAfter(object): - - def __init__(self, deadline, *, ignore=False, absolute=False): - self._deadline = deadline - self._ignore = ignore - self._absolute = absolute - self.expired = False - - async def __aenter__(self): - task = asyncio.current_task() - loop_time = task._loop.time() - if self._absolute: - self._secs = self._deadline - loop_time - else: - self._secs = self._deadline - self._deadline += loop_time - _set_task_deadline(task, self._deadline) - self.expired = False - self._task = task - return self - - async def __aexit__(self, exc_type, exc_value, traceback): - timed_out_deadline, uncaught = _unset_task_deadline(self._task) - if exc_type not in (asyncio.CancelledError, TaskTimeout, - TimeoutCancellationError): - return False - if timed_out_deadline == self._deadline: - self.expired = True - if self._ignore: - return True - raise TaskTimeout(self._secs) from None - if timed_out_deadline is None: - assert exc_type is asyncio.CancelledError - return False - if uncaught: - raise UncaughtTimeoutError('uncaught timeout received') - if exc_type is TimeoutCancellationError: - return False - raise TimeoutCancellationError(timed_out_deadline) from None - - -async def _timeout_after_func(seconds, absolute, coro, args): - coro = normalize_corofunc(coro, args) - async with TimeoutAfter(seconds, absolute=absolute): - return await coro - - -def timeout_after(seconds, coro=None, *args): - '''Execute the specified coroutine and return its result. However, - issue a cancellation request to the calling task after seconds - have elapsed. When this happens, a TaskTimeout exception is - raised. If coro is None, the result of this function serves - as an asynchronous context manager that applies a timeout to a - block of statements. - - timeout_after() may be composed with other timeout_after() - operations (i.e., nested timeouts). If an outer timeout expires - first, then TimeoutCancellationError is raised instead of - TaskTimeout. If an inner timeout expires and fails to properly - TaskTimeout, a UncaughtTimeoutError is raised in the outer - timeout. - - ''' - if coro: - return _timeout_after_func(seconds, False, coro, args) - - return TimeoutAfter(seconds) - - -async def _ignore_after_func(seconds, absolute, coro, args, timeout_result): - coro = normalize_corofunc(coro, args) - async with TimeoutAfter(seconds, absolute=absolute, ignore=True): - return await coro - - return timeout_result - - -def ignore_after(seconds, coro=None, *args, timeout_result=None): - '''Execute the specified coroutine and return its result. Issue a - cancellation request after seconds have elapsed. When a timeout - occurs, no exception is raised. Instead, timeout_result is - returned. - - If coro is None, the result is an asynchronous context manager - that applies a timeout to a block of statements. For the context - manager case, the resulting context manager object has an expired - attribute set to True if time expired. - - Note: ignore_after() may also be composed with other timeout - operations. TimeoutCancellationError and UncaughtTimeoutError - exceptions might be raised according to the same rules as for - timeout_after(). - ''' - if coro: - return _ignore_after_func(seconds, False, coro, args, timeout_result) - - return TimeoutAfter(seconds, ignore=True) diff --git a/torba/rpc/session.py b/torba/rpc/session.py index 5be1a7dfc..3c465abd6 100644 --- a/torba/rpc/session.py +++ b/torba/rpc/session.py @@ -36,7 +36,7 @@ from contextlib import suppress from .jsonrpc import Request, JSONRPCConnection, JSONRPCv2, JSONRPC, Batch, Notification from .jsonrpc import RPCError, ProtocolError -from .curio import TaskGroup, TaskTimeout, spawn_sync, ignore_after, timeout_after +from .curio import TaskGroup from .framing import BadMagicError, BadChecksumError, OversizedPayloadError, BitcoinFramer, NewlineFramer from .util import Concurrency @@ -151,17 +151,15 @@ class SessionBase(asyncio.Protocol): task_group = self._task_group async with task_group: - await self.spawn(self._receive_messages) - await self.spawn(collect_tasks) + await self.spawn(self._receive_messages()) + await self.spawn(collect_tasks()) async def _limited_wait(self, secs): - # Wait at most secs seconds to send, otherwise abort the connection try: - async with timeout_after(secs): - await self._can_send.wait() - except TaskTimeout: + await asyncio.wait_for(self._can_send.wait(), secs) + except asyncio.TimeoutError: self.abort() - raise + raise asyncio.CancelledError(f'task timed out after {secs}s') async def _send_message(self, message): if not self._can_send.is_set(): @@ -221,7 +219,7 @@ class SessionBase(asyncio.Protocol): self._proxy_address = peer_address else: self._address = peer_address - self._pm_task = spawn_sync(self._process_messages(), loop=self.loop) + self._pm_task = self.loop.create_task(self._process_messages()) def connection_lost(self, exc): '''Called by asyncio when the connection closes. @@ -281,8 +279,7 @@ class SessionBase(asyncio.Protocol): self._close() if self._pm_task: with suppress(CancelledError): - async with ignore_after(force_after): - await self._pm_task + await asyncio.wait([self._pm_task], timeout=force_after) self.abort() await self._pm_task diff --git a/torba/server/peers.py b/torba/server/peers.py index af319c29a..f764ba548 100644 --- a/torba/server/peers.py +++ b/torba/server/peers.py @@ -16,7 +16,7 @@ from collections import defaultdict, Counter from torba.rpc import ( Connector, RPCSession, SOCKSProxy, Notification, handler_invocation, - SOCKSError, RPCError, TaskTimeout, TaskGroup, ignore_after, timeout_after + SOCKSError, RPCError, TaskGroup ) from torba.server.peer import Peer from torba.server.util import class_logger, protocol_tuple @@ -194,8 +194,8 @@ class PeerManager: pause = STALE_SECS - WAKEUP_SECS * 2 else: pause = WAKEUP_SECS * 2 ** peer.try_count - async with ignore_after(pause): - await peer.retry_event.wait() + pending, done = await asyncio.wait([peer.retry_event.wait()], timeout=pause) + if done: peer.retry_event.clear() async def _should_drop_peer(self, peer): @@ -224,10 +224,12 @@ class PeerManager: peer_text = f'[{peer}:{port} {kind}]' try: - async with timeout_after(120 if peer.is_tor else 30): - async with Connector(PeerSession, peer.host, port, - **kwargs) as session: - await self._verify_peer(session, peer) + async with Connector(PeerSession, peer.host, port, + **kwargs) as session: + await asyncio.wait_for( + self._verify_peer(session, peer), + 120 if peer.is_tor else 30 + ) is_good = True break except BadPeerError as e: @@ -237,7 +239,7 @@ class PeerManager: except RPCError as e: self.logger.error(f'{peer_text} RPC error: {e.message} ' f'({e.code})') - except (OSError, SOCKSError, ConnectionError, TaskTimeout) as e: + except (OSError, SOCKSError, ConnectionError, asyncio.TimeoutError) as e: self.logger.info(f'{peer_text} {e}') if is_good: From a6de3a96425197f748d29a69d293f913dc013899 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 6 Dec 2018 20:03:22 -0500 Subject: [PATCH 268/383] completely dropped curio.py --- torba/client/baseledger.py | 39 ++----- torba/rpc/__init__.py | 4 +- torba/rpc/curio.py | 200 -------------------------------- torba/rpc/session.py | 35 ++---- torba/rpc/util.py | 25 ---- torba/server/block_processor.py | 9 +- torba/server/mempool.py | 19 ++- torba/server/peers.py | 29 ++--- torba/server/session.py | 35 +++--- torba/tasks.py | 24 ++++ 10 files changed, 82 insertions(+), 337 deletions(-) delete mode 100644 torba/rpc/curio.py create mode 100644 torba/tasks.py diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index c99c34612..721236e07 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -9,6 +9,7 @@ from typing import Dict, Type, Iterable, List, Optional from operator import itemgetter from collections import namedtuple +from torba.tasks import TaskGroup from torba.client import baseaccount, basenetwork, basetransaction from torba.client.basedatabase import BaseDatabase from torba.client.baseheader import BaseHeaders @@ -73,32 +74,6 @@ class TransactionCacheItem: self.has_tx.set() -class SynchronizationMonitor: - - def __init__(self, loop=None): - self.done = asyncio.Event() - self.tasks = [] - self.loop = loop or asyncio.get_event_loop() - - def add(self, coro): - len(self.tasks) < 1 and self.done.clear() - self.loop.create_task(self._monitor(coro)) - - def cancel(self): - for task in self.tasks: - task.cancel() - - async def _monitor(self, coro): - task = self.loop.create_task(coro) - self.tasks.append(task) - log.debug('sync tasks: %s', len(self.tasks)) - try: - await task - finally: - self.tasks.remove(task) - len(self.tasks) < 1 and self.done.set() - - class BaseLedger(metaclass=LedgerRegistry): name: str @@ -160,7 +135,7 @@ class BaseLedger(metaclass=LedgerRegistry): ) self._tx_cache = {} - self.sync = SynchronizationMonitor() + self._update_tasks = TaskGroup() self._utxo_reservation_lock = asyncio.Lock() self._header_processing_lock = asyncio.Lock() self._address_update_locks: Dict[str, asyncio.Lock] = {} @@ -265,11 +240,11 @@ class BaseLedger(metaclass=LedgerRegistry): await self.update_headers() await self.network.subscribe_headers() await self.subscribe_accounts() - await self.sync.done.wait() + await self._update_tasks.done.wait() async def stop(self): - self.sync.cancel() - await self.sync.done.wait() + self._update_tasks.cancel() + await self._update_tasks.done.wait() await self.network.stop() await self.db.close() await self.headers.close() @@ -377,11 +352,11 @@ class BaseLedger(metaclass=LedgerRegistry): async def subscribe_address(self, address_manager: baseaccount.AddressManager, address: str): remote_status = await self.network.subscribe_address(address) - self.sync.add(self.update_history(address, remote_status, address_manager)) + self._update_tasks.add(self.update_history(address, remote_status, address_manager)) def process_status_update(self, update): address, remote_status = update - self.sync.add(self.update_history(address, remote_status)) + self._update_tasks.add(self.update_history(address, remote_status)) async def update_history(self, address, remote_status, address_manager: baseaccount.AddressManager = None): diff --git a/torba/rpc/__init__.py b/torba/rpc/__init__.py index ce96bd517..c2b585547 100644 --- a/torba/rpc/__init__.py +++ b/torba/rpc/__init__.py @@ -1,12 +1,10 @@ -from .curio import * from .framing import * from .jsonrpc import * from .socks import * from .session import * from .util import * -__all__ = (curio.__all__ + - framing.__all__ + +__all__ = (framing.__all__ + jsonrpc.__all__ + socks.__all__ + session.__all__ + diff --git a/torba/rpc/curio.py b/torba/rpc/curio.py deleted file mode 100644 index b07f44b29..000000000 --- a/torba/rpc/curio.py +++ /dev/null @@ -1,200 +0,0 @@ -# The code below is mostly my own but based on the interfaces of the -# curio library by David Beazley. I'm considering switching to using -# curio. In the mean-time this is an attempt to provide a similar -# clean, pure-async interface and move away from direct -# framework-specific dependencies. As asyncio differs in its design -# it is not possible to provide identical semantics. -# -# The curio library is distributed under the following licence: -# -# Copyright (C) 2015-2017 -# David Beazley (Dabeaz LLC) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are -# met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# * Redistributions in binary form must reproduce the above copyright notice, -# this list of conditions and the following disclaimer in the documentation -# and/or other materials provided with the distribution. -# * Neither the name of the David Beazley or Dabeaz LLC may be used to -# endorse or promote products derived from this software without -# specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -import logging -import asyncio -from collections import deque -from contextlib import suppress - - -__all__ = 'TaskGroup', - - -class TaskGroup: - '''A class representing a group of executing tasks. tasks is an - optional set of existing tasks to put into the group. New tasks - can later be added using the spawn() method below. wait specifies - the policy used for waiting for tasks. See the join() method - below. Each TaskGroup is an independent entity. Task groups do not - form a hierarchy or any kind of relationship to other previously - created task groups or tasks. Moreover, Tasks created by the top - level spawn() function are not placed into any task group. To - create a task in a group, it should be created using - TaskGroup.spawn() or explicitly added using TaskGroup.add_task(). - - completed attribute: the first task that completed with a result - in the group. Takes into account the wait option used in the - TaskGroup constructor (but not in the join method)`. - ''' - - def __init__(self, tasks=(), *, wait=all): - if wait not in (any, all, object): - raise ValueError('invalid wait argument') - self._done = deque() - self._pending = set() - self._wait = wait - self._done_event = asyncio.Event() - self._logger = logging.getLogger(self.__class__.__name__) - self._closed = False - self.completed = None - for task in tasks: - self._add_task(task) - - def _add_task(self, task): - '''Add an already existing task to the task group.''' - if hasattr(task, '_task_group'): - raise RuntimeError('task is already part of a group') - if self._closed: - raise RuntimeError('task group is closed') - task._task_group = self - if task.done(): - self._done.append(task) - else: - self._pending.add(task) - task.add_done_callback(self._on_done) - - def _on_done(self, task): - task._task_group = None - self._pending.remove(task) - self._done.append(task) - self._done_event.set() - if self.completed is None: - if not task.cancelled() and not task.exception(): - if self._wait is object and task.result() is None: - pass - else: - self.completed = task - - async def spawn(self, coro, *args): - '''Create a new task that’s part of the group. Returns a Task - instance. - ''' - task = asyncio.create_task(coro) - self._add_task(task) - return task - - async def add_task(self, task): - '''Add an already existing task to the task group.''' - self._add_task(task) - - async def next_done(self): - '''Returns the next completed task. Returns None if no more tasks - remain. A TaskGroup may also be used as an asynchronous iterator. - ''' - if not self._done and self._pending: - self._done_event.clear() - await self._done_event.wait() - if self._done: - return self._done.popleft() - return None - - async def next_result(self): - '''Returns the result of the next completed task. If the task failed - with an exception, that exception is raised. A RuntimeError - exception is raised if this is called when no remaining tasks - are available.''' - task = await self.next_done() - if not task: - raise RuntimeError('no tasks remain') - return task.result() - - async def join(self): - '''Wait for tasks in the group to terminate according to the wait - policy for the group. - - If the join() operation itself is cancelled, all remaining - tasks in the group are also cancelled. - - If a TaskGroup is used as a context manager, the join() method - is called on context-exit. - - Once join() returns, no more tasks may be added to the task - group. Tasks can be added while join() is running. - ''' - def errored(task): - return not task.cancelled() and task.exception() - - try: - if self._wait in (all, object): - while True: - task = await self.next_done() - if task is None: - return - if errored(task): - break - if self._wait is object: - if task.cancelled() or task.result() is not None: - return - else: # any - task = await self.next_done() - if task is None or not errored(task): - return - finally: - await self.cancel_remaining() - - if errored(task): - raise task.exception() - - async def cancel_remaining(self): - '''Cancel all remaining tasks.''' - self._closed = True - for task in list(self._pending): - task.cancel() - with suppress(asyncio.CancelledError): - await task - - def closed(self): - return self._closed - - def __aiter__(self): - return self - - async def __anext__(self): - task = await self.next_done() - if task: - return task - raise StopAsyncIteration - - async def __aenter__(self): - return self - - async def __aexit__(self, exc_type, exc_value, traceback): - if exc_type: - await self.cancel_remaining() - else: - await self.join() diff --git a/torba/rpc/session.py b/torba/rpc/session.py index 3c465abd6..e23f78b47 100644 --- a/torba/rpc/session.py +++ b/torba/rpc/session.py @@ -34,9 +34,10 @@ import logging import time from contextlib import suppress +from torba.tasks import TaskGroup + from .jsonrpc import Request, JSONRPCConnection, JSONRPCv2, JSONRPC, Batch, Notification from .jsonrpc import RPCError, ProtocolError -from .curio import TaskGroup from .framing import BadMagicError, BadChecksumError, OversizedPayloadError, BitcoinFramer, NewlineFramer from .util import Concurrency @@ -98,7 +99,7 @@ class SessionBase(asyncio.Protocol): self._can_send = Event() self._can_send.set() self._pm_task = None - self._task_group = TaskGroup() + self._task_group = TaskGroup(self.loop) # Force-close a connection if a send doesn't succeed in this time self.max_send_delay = 60 # Statistics. The RPC object also keeps its own statistics. @@ -140,20 +141,6 @@ class SessionBase(asyncio.Protocol): '''Called when sending or receiving size bytes.''' self.bw_charge += size - async def _process_messages(self): - '''Process incoming messages asynchronously and consume the - results. - ''' - async def collect_tasks(): - next_done = task_group.next_done - while True: - await next_done() - - task_group = self._task_group - async with task_group: - await self.spawn(self._receive_messages()) - await self.spawn(collect_tasks()) - async def _limited_wait(self, secs): try: await asyncio.wait_for(self._can_send.wait(), secs) @@ -219,7 +206,7 @@ class SessionBase(asyncio.Protocol): self._proxy_address = peer_address else: self._address = peer_address - self._pm_task = self.loop.create_task(self._process_messages()) + self._pm_task = self.loop.create_task(self._receive_messages()) def connection_lost(self, exc): '''Called by asyncio when the connection closes. @@ -227,6 +214,7 @@ class SessionBase(asyncio.Protocol): Tear down things done in connection_made.''' self._address = None self.transport = None + self._task_group.cancel() self._pm_task.cancel() # Release waiting tasks self._can_send.set() @@ -256,15 +244,6 @@ class SessionBase(asyncio.Protocol): else: return f'{ip_addr_str}:{port}' - async def spawn(self, coro, *args): - '''If the session is connected, spawn a task that is cancelled - on disconnect, and return it. Otherwise return None.''' - group = self._task_group - if not group.closed(): - return await group.spawn(coro, *args) - else: - return None - def is_closing(self): '''Return True if the connection is closing.''' return not self.transport or self.transport.is_closing() @@ -321,7 +300,7 @@ class MessageSession(SessionBase): self.recv_count += 1 if self.recv_count % 10 == 0: await self._update_concurrency() - await self.spawn(self._throttled_message(message)) + await self._task_group.add(self._throttled_message(message)) async def _throttled_message(self, message): '''Process a single request, respecting the concurrency limit.''' @@ -453,7 +432,7 @@ class RPCSession(SessionBase): self._bump_errors() else: for request in requests: - await self.spawn(self._throttled_request(request)) + await self._task_group.add(self._throttled_request(request)) async def _throttled_request(self, request): '''Process a single request, respecting the concurrency limit.''' diff --git a/torba/rpc/util.py b/torba/rpc/util.py index 07388e7a2..f62587b71 100644 --- a/torba/rpc/util.py +++ b/torba/rpc/util.py @@ -28,25 +28,8 @@ __all__ = () import asyncio from collections import namedtuple -from functools import partial import inspect - -def normalize_corofunc(corofunc, args): - if asyncio.iscoroutine(corofunc): - if args != (): - raise ValueError('args cannot be passed with a coroutine') - return corofunc - return corofunc(*args) - - -def is_async_call(func): - '''inspect.iscoroutinefunction that looks through partials.''' - while isinstance(func, partial): - func = func.func - return inspect.iscoroutinefunction(func) - - # other_params: None means cannot be called with keyword arguments only # any means any name is good SignatureInfo = namedtuple('SignatureInfo', 'min_args max_args ' @@ -110,11 +93,3 @@ class Concurrency(object): else: for _ in range(-diff): await self.semaphore.acquire() - - -def check_task(logger, task): - if not task.cancelled(): - try: - task.result() - except Exception: - logger.error('task crashed: %r', task, exc_info=True) diff --git a/torba/server/block_processor.py b/torba/server/block_processor.py index 5a638c426..e544eb7b8 100644 --- a/torba/server/block_processor.py +++ b/torba/server/block_processor.py @@ -13,8 +13,6 @@ import asyncio from struct import pack, unpack import time -from torba.rpc import TaskGroup - import torba from torba.server.daemon import DaemonError from torba.server.hash import hash_to_hex_str, HASHX_LEN @@ -651,9 +649,10 @@ class BlockProcessor: self._caught_up_event = caught_up_event await self._first_open_dbs() try: - async with TaskGroup() as group: - await group.spawn(self.prefetcher.main_loop(self.height)) - await group.spawn(self._process_prefetched_blocks()) + await asyncio.wait([ + self.prefetcher.main_loop(self.height), + self._process_prefetched_blocks() + ]) finally: # Shut down block processing self.logger.info('flushing to DB for a clean shutdown...') diff --git a/torba/server/mempool.py b/torba/server/mempool.py index 50f2e4681..e3af9d154 100644 --- a/torba/server/mempool.py +++ b/torba/server/mempool.py @@ -16,7 +16,6 @@ from collections import defaultdict import attr -from torba.rpc import TaskGroup from torba.server.hash import hash_to_hex_str, hex_str_to_hash from torba.server.util import class_logger, chunks from torba.server.db import UTXO @@ -235,14 +234,13 @@ class MemPool: # Process new transactions new_hashes = list(all_hashes.difference(txs)) if new_hashes: - group = TaskGroup() + fetches = [] for hashes in chunks(new_hashes, 200): - coro = self._fetch_and_accept(hashes, all_hashes, touched) - await group.spawn(coro) + fetches.append(self._fetch_and_accept(hashes, all_hashes, touched)) tx_map = {} utxo_map = {} - async for task in group: - deferred, unspent = task.result() + for fetch in asyncio.as_completed(fetches): + deferred, unspent = await fetch tx_map.update(deferred) utxo_map.update(unspent) @@ -306,10 +304,11 @@ class MemPool: async def keep_synchronized(self, synchronized_event): '''Keep the mempool synchronized with the daemon.''' - async with TaskGroup() as group: - await group.spawn(self._refresh_hashes(synchronized_event)) - await group.spawn(self._refresh_histogram(synchronized_event)) - await group.spawn(self._logging(synchronized_event)) + await asyncio.wait([ + self._refresh_hashes(synchronized_event), + self._refresh_histogram(synchronized_event), + self._logging(synchronized_event) + ]) async def balance_delta(self, hashX): '''Return the unconfirmed amount in the mempool for hashX. diff --git a/torba/server/peers.py b/torba/server/peers.py index f764ba548..e54939af7 100644 --- a/torba/server/peers.py +++ b/torba/server/peers.py @@ -14,9 +14,10 @@ import ssl import time from collections import defaultdict, Counter +from torba.tasks import TaskGroup from torba.rpc import ( Connector, RPCSession, SOCKSProxy, Notification, handler_invocation, - SOCKSError, RPCError, TaskGroup + SOCKSError, RPCError ) from torba.server.peer import Peer from torba.server.util import class_logger, protocol_tuple @@ -179,7 +180,7 @@ class PeerManager: self.logger.info(f'accepted new peer {peer} from {source}') peer.retry_event = asyncio.Event() self.peers.add(peer) - await self.group.spawn(self._monitor_peer(peer)) + await self.group.add(self._monitor_peer(peer)) async def _monitor_peer(self, peer): # Stop monitoring if we were dropped (a duplicate peer) @@ -292,10 +293,11 @@ class PeerManager: peer.features['server_version'] = server_version ptuple = protocol_tuple(protocol_version) - async with TaskGroup() as g: - await g.spawn(self._send_headers_subscribe(session, peer, ptuple)) - await g.spawn(self._send_server_features(session, peer)) - await g.spawn(self._send_peers_subscribe(session, peer)) + await asyncio.wait([ + self._send_headers_subscribe(session, peer, ptuple), + self._send_server_features(session, peer), + self._send_peers_subscribe(session, peer) + ]) async def _send_headers_subscribe(self, session, peer, ptuple): message = 'blockchain.headers.subscribe' @@ -387,18 +389,9 @@ class PeerManager: self.logger.info(f'beginning peer discovery. Force use of ' f'proxy: {self.env.force_proxy}') - forever = asyncio.Event() - async with self.group as group: - await group.spawn(forever.wait()) - await group.spawn(self._detect_proxy()) - await group.spawn(self._import_peers()) - # Consume tasks as they complete, logging unexpected failures - async for task in group: - if not task.cancelled(): - try: - task.result() - except Exception: - self.logger.exception('task failed unexpectedly') + + self.group.add(self._detect_proxy()) + self.group.add(self._import_peers()) def info(self): '''The number of peers.''' diff --git a/torba/server/session.py b/torba/server/session.py index a7925acdb..d80728dbf 100644 --- a/torba/server/session.py +++ b/torba/server/session.py @@ -22,7 +22,7 @@ from functools import partial import torba from torba.rpc import ( RPCSession, JSONRPCAutoDetect, JSONRPCConnection, - TaskGroup, handler_invocation, RPCError, Request + handler_invocation, RPCError, Request ) from torba.server import text from torba.server import util @@ -257,9 +257,10 @@ class SessionManager: for session in stale_sessions) self.logger.info(f'closing stale connections {text}') # Give the sockets some time to close gracefully - async with TaskGroup() as group: - for session in stale_sessions: - await group.spawn(session.close()) + if stale_sessions: + await asyncio.wait([ + session.close() for session in stale_sessions + ]) # Consolidate small groups bw_limit = self.env.bandwidth_limit @@ -499,17 +500,18 @@ class SessionManager: server_listening_event.set() # Peer discovery should start after the external servers # because we connect to ourself - async with TaskGroup() as group: - await group.spawn(self.peer_mgr.discover_peers()) - await group.spawn(self._clear_stale_sessions()) - await group.spawn(self._log_sessions()) - await group.spawn(self._manage_servers()) + await asyncio.wait([ + self.peer_mgr.discover_peers(), + self._clear_stale_sessions(), + self._log_sessions(), + self._manage_servers() + ]) finally: - # Close servers and sessions await self._close_servers(list(self.servers.keys())) - async with TaskGroup() as group: - for session in list(self.sessions): - await group.spawn(session.close(force_after=1)) + if self.sessions: + await asyncio.wait([ + session.close(force_after=1) for session in self.sessions + ]) def session_count(self): '''The number of connections that we've sent something to.''' @@ -562,9 +564,10 @@ class SessionManager: for hashX in set(hc).intersection(touched): del hc[hashX] - async with TaskGroup() as group: - for session in self.sessions: - await group.spawn(session.notify(touched, height_changed)) + if self.sessions: + await asyncio.wait([ + session.notify(touched, height_changed) for session in self.sessions + ]) def add_session(self, session): self.sessions.add(session) diff --git a/torba/tasks.py b/torba/tasks.py new file mode 100644 index 000000000..4978c2185 --- /dev/null +++ b/torba/tasks.py @@ -0,0 +1,24 @@ +from asyncio import Event, get_event_loop + + +class TaskGroup: + + def __init__(self, loop=None): + self._loop = loop or get_event_loop() + self._tasks = set() + self.done = Event() + + def add(self, coro): + task = self._loop.create_task(coro) + self._tasks.add(task) + self.done.clear() + task.add_done_callback(self._remove) + return task + + def _remove(self, task): + self._tasks.remove(task) + len(self._tasks) < 1 and self.done.set() + + def cancel(self): + for task in self._tasks: + task.cancel() From 78fd43468689ef307c17a0471ca8333a4fd02dde Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 6 Dec 2018 20:19:16 -0500 Subject: [PATCH 269/383] asyncio.sleep() -> sleep() and asyncio.Event() to Event() in order to reduce overall diff after dropping curio.py --- torba/server/db.py | 5 +++-- torba/server/mempool.py | 8 ++++---- torba/server/merkle.py | 4 ++-- torba/server/peers.py | 5 +++-- torba/server/session.py | 7 ++++--- 5 files changed, 16 insertions(+), 13 deletions(-) diff --git a/torba/server/db.py b/torba/server/db.py index 593bf3d83..0721dcef5 100644 --- a/torba/server/db.py +++ b/torba/server/db.py @@ -14,6 +14,7 @@ import array import ast import os import time +from asyncio import sleep from bisect import bisect_right from collections import namedtuple from glob import glob @@ -448,7 +449,7 @@ class DB: return history self.logger.warning(f'limited_history: tx hash ' f'not found (reorg?), retrying...') - await asyncio.sleep(0.25) + await sleep(0.25) # -- Undo information @@ -617,7 +618,7 @@ class DB: return utxos self.logger.warning(f'all_utxos: tx hash not ' f'found (reorg?), retrying...') - await asyncio.sleep(0.25) + await sleep(0.25) async def lookup_utxos(self, prevouts): '''For each prevout, lookup it up in the DB and return a (hashX, diff --git a/torba/server/mempool.py b/torba/server/mempool.py index e3af9d154..4ae0526b1 100644 --- a/torba/server/mempool.py +++ b/torba/server/mempool.py @@ -11,7 +11,7 @@ import asyncio import itertools import time from abc import ABC, abstractmethod -from asyncio import Lock +from asyncio import Lock, sleep from collections import defaultdict import attr @@ -117,7 +117,7 @@ class MemPool: while True: self.logger.info(f'{len(self.txs):,d} txs ' f'touching {len(self.hashXs):,d} addresses') - await asyncio.sleep(self.log_status_secs) + await sleep(self.log_status_secs) await synchronized_event.wait() async def _refresh_histogram(self, synchronized_event): @@ -126,7 +126,7 @@ class MemPool: async with self.lock: # Threaded as can be expensive await asyncio.get_event_loop().run_in_executor(None, self._update_histogram, 100_000) - await asyncio.sleep(self.coin.MEMPOOL_HISTOGRAM_REFRESH_SECS) + await sleep(self.coin.MEMPOOL_HISTOGRAM_REFRESH_SECS) def _update_histogram(self, bin_size): # Build a histogram by fee rate @@ -212,7 +212,7 @@ class MemPool: synchronized_event.set() synchronized_event.clear() await self.api.on_mempool(touched, height) - await asyncio.sleep(self.refresh_secs) + await sleep(self.refresh_secs) async def _process_mempool(self, all_hashes): # Re-sync with the new set of hashes diff --git a/torba/server/merkle.py b/torba/server/merkle.py index 65ebd3b8b..e8e54a06c 100644 --- a/torba/server/merkle.py +++ b/torba/server/merkle.py @@ -26,7 +26,7 @@ '''Merkle trees, branches, proofs and roots.''' -import asyncio +from asyncio import Event from math import ceil, log from torba.server.hash import double_sha256 @@ -169,7 +169,7 @@ class MerkleCache: self.source_func = source_func self.length = 0 self.depth_higher = 0 - self.initialized = asyncio.Event() + self.initialized = Event() def _segment_length(self): return 1 << self.depth_higher diff --git a/torba/server/peers.py b/torba/server/peers.py index e54939af7..842111466 100644 --- a/torba/server/peers.py +++ b/torba/server/peers.py @@ -12,6 +12,7 @@ import random import socket import ssl import time +from asyncio import Event, sleep from collections import defaultdict, Counter from torba.tasks import TaskGroup @@ -150,7 +151,7 @@ class PeerManager: self.logger.info(f'detected {proxy}') return self.logger.info('no proxy detected, will try later') - await asyncio.sleep(900) + await sleep(900) async def _note_peers(self, peers, limit=2, check_ports=False, source=None): @@ -178,7 +179,7 @@ class PeerManager: use_peers = new_peers for peer in use_peers: self.logger.info(f'accepted new peer {peer} from {source}') - peer.retry_event = asyncio.Event() + peer.retry_event = Event() self.peers.add(peer) await self.group.add(self._monitor_peer(peer)) diff --git a/torba/server/session.py b/torba/server/session.py index d80728dbf..b3b1e963e 100644 --- a/torba/server/session.py +++ b/torba/server/session.py @@ -16,6 +16,7 @@ import os import pylru import ssl import time +from asyncio import Event, sleep from collections import defaultdict from functools import partial @@ -130,7 +131,7 @@ class SessionManager: self.mn_cache_height = 0 self.mn_cache = [] - self.session_event = asyncio.Event() + self.session_event = Event() # Set up the RPC request handlers cmds = ('add_peer daemon_url disconnect getinfo groups log peers ' @@ -206,7 +207,7 @@ class SessionManager: log_interval = self.env.log_sessions if log_interval: while True: - await asyncio.sleep(log_interval) + await sleep(log_interval) data = self._session_data(for_log=True) for line in text.sessions_lines(data): self.logger.info(line) @@ -248,7 +249,7 @@ class SessionManager: async def _clear_stale_sessions(self): '''Cut off sessions that haven't done anything for 10 minutes.''' while True: - await asyncio.sleep(60) + await sleep(60) stale_cutoff = time.time() - self.env.session_timeout stale_sessions = [session for session in self.sessions if session.last_recv < stale_cutoff] From e3106012662d8c82dac39f4c53f1671d0d0d894e Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Tue, 11 Dec 2018 01:38:15 -0300 Subject: [PATCH 270/383] keep connection alive for idling peers --- torba/client/basenetwork.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index 4147cc42b..f6c85c9b8 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -2,6 +2,7 @@ import logging import asyncio from asyncio import CancelledError from itertools import cycle +from time import time from torba.rpc import RPCSession as BaseClientSession, Connector, RPCError @@ -20,6 +21,8 @@ class ClientSession(BaseClientSession): self._on_disconnect_controller = StreamController() self.on_disconnected = self._on_disconnect_controller.stream self.bw_limit = self.framer.max_size = self.max_errors = 1 << 32 + self.max_seconds_idle = 60 + self.ping_task = None async def send_request(self, method, args=()): try: @@ -28,9 +31,17 @@ class ClientSession(BaseClientSession): log.warning("Wallet server returned an error. Code: %s Message: %s", *e.args) raise e + async def ping_forever(self): + # TODO: change to 'ping' on newer protocol (above 1.2) + while not self.is_closing(): + if (time() - self.last_send) > self.max_seconds_idle: + await self.send_request('server.banner') + await asyncio.sleep(self.max_seconds_idle//3) + async def create_connection(self): connector = Connector(lambda: self, *self.server) await connector.create_connection() + self.ping_task = asyncio.create_task(self.ping_forever()) async def handle_request(self, request): controller = self.network.subscription_controllers[request.method] @@ -39,6 +50,8 @@ class ClientSession(BaseClientSession): def connection_lost(self, exc): super().connection_lost(exc) self._on_disconnect_controller.add(True) + if self.ping_task: + self.ping_task.cancel() class BaseNetwork: From 50fc02728901bf66842cc605e45bb5071985e923 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 12 Dec 2018 12:54:38 -0500 Subject: [PATCH 271/383] initial version of torba/server/cli.py --- torba/server/cli.py | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 torba/server/cli.py diff --git a/torba/server/cli.py b/torba/server/cli.py new file mode 100644 index 000000000..4a9788923 --- /dev/null +++ b/torba/server/cli.py @@ -0,0 +1,39 @@ +import logging +import traceback +import argparse +import importlib +from .env import Env +from .server import Server + + +def get_argument_parser(): + parser = argparse.ArgumentParser( + prog="torba-server" + ) + parser.add_argument("spvserver", type=str, help="Python class path to SPV server implementation.") + return parser + + +def get_coin_class(spvserver): + spvserver_path, coin_class_name = spvserver.rsplit('.', 1) + spvserver_module = importlib.import_module(spvserver_path) + return getattr(spvserver_module, coin_class_name) + + +def main(): + parser = get_argument_parser() + args = parser.parse_args() + coin_class = get_coin_class(args.spvserver) + logging.info('torba.server starting') + try: + server = Server(Env(coin_class)) + server.run() + except Exception: + traceback.print_exc() + logging.critical('torba.server terminated abnormally') + else: + logging.info('torba.server terminated normally') + + +if __name__ == "__main__": + main() From 1c860e85781b13dbe74ac848821977798da4b398 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 12 Dec 2018 20:12:35 -0300 Subject: [PATCH 272/383] set logging to info --- torba/server/cli.py | 1 + 1 file changed, 1 insertion(+) diff --git a/torba/server/cli.py b/torba/server/cli.py index 4a9788923..2409ec52e 100644 --- a/torba/server/cli.py +++ b/torba/server/cli.py @@ -24,6 +24,7 @@ def main(): parser = get_argument_parser() args = parser.parse_args() coin_class = get_coin_class(args.spvserver) + logging.basicConfig(level=logging.INFO) logging.info('torba.server starting') try: server = Server(Env(coin_class)) From 9d772a45d5333fd97daa32fe005308a5534291af Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 12 Dec 2018 20:13:08 -0300 Subject: [PATCH 273/383] wait the shutdown event instead of running forever --- torba/server/server.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/torba/server/server.py b/torba/server/server.py index dee96f634..b6822e28b 100644 --- a/torba/server/server.py +++ b/torba/server/server.py @@ -111,6 +111,7 @@ class Server: def stop(self): for task in reversed(self.cancellable_tasks): task.cancel() + self.shutdown_event.set() def run(self): loop = asyncio.get_event_loop() @@ -118,6 +119,6 @@ class Server: loop.add_signal_handler(signal.SIGINT, self.stop) loop.add_signal_handler(signal.SIGTERM, self.stop) loop.run_until_complete(self.start()) - loop.run_forever() + loop.run_until_complete(self.shutdown_event.wait()) finally: loop.run_until_complete(loop.shutdown_asyncgens()) From 458189366f8cbd518b47253329b6160f2ccc20da Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 12 Dec 2018 20:13:34 -0300 Subject: [PATCH 274/383] typo on session.py --- torba/server/session.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torba/server/session.py b/torba/server/session.py index b3b1e963e..c5b063ec5 100644 --- a/torba/server/session.py +++ b/torba/server/session.py @@ -648,7 +648,7 @@ class SessionBase(RPCSession): status += 'C' if self.log_me: status += 'L' - status += str(self.concurrency.max_concurrent) + status += str(self._concurrency.max_concurrent) return status def connection_made(self, transport): @@ -681,7 +681,7 @@ class SessionBase(RPCSession): return len(self.connection.pending_requests()) def semaphore(self): - return Semaphores([self.concurrency.semaphore, self.group.semaphore]) + return Semaphores([self._concurrency.semaphore, self.group.semaphore]) def sub_count(self): return 0 From 7092f4070169e47e719d716e9fe0131cd1ad0cc2 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 14 Dec 2018 16:15:59 -0500 Subject: [PATCH 275/383] improved shutdown for torba.server and related test setup code --- torba/orchstr8/node.py | 74 ++++++++++++++++++++------------- torba/server/block_processor.py | 1 + torba/server/db.py | 2 +- torba/server/server.py | 3 +- torba/testcase.py | 66 ++++++++++++++++------------- 5 files changed, 88 insertions(+), 58 deletions(-) diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index 1918a1b01..9d30bdd4b 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -19,6 +19,9 @@ from torba.client.basemanager import BaseWalletManager from torba.client.baseaccount import BaseAccount +log = logging.getLogger(__name__) + + def get_manager_from_environment(default_manager=BaseWalletManager): if 'TORBA_MANAGER' not in os.environ: return default_manager @@ -73,40 +76,55 @@ class Conductor: self.spv_started = False self.wallet_started = False + self.log = log.getChild('conductor') + async def start_blockchain(self): - await self.blockchain_node.start() - await self.blockchain_node.generate(200) - self.blockchain_started = True + if not self.blockchain_started: + await self.blockchain_node.start() + await self.blockchain_node.generate(200) + self.blockchain_started = True + + async def stop_blockchain(self): + if self.blockchain_started: + await self.blockchain_node.stop(cleanup=True) + self.blockchain_started = False async def start_spv(self): - await self.spv_node.start() - self.spv_started = True + if not self.spv_started: + await self.spv_node.start() + self.spv_started = True + + async def stop_spv(self): + if self.spv_started: + await self.spv_node.stop(cleanup=True) + self.spv_started = False async def start_wallet(self): - await self.wallet_node.start() - self.wallet_started = True + if not self.wallet_started: + await self.wallet_node.start() + self.wallet_started = True + + async def stop_wallet(self): + if self.wallet_started: + await self.wallet_node.stop(cleanup=True) + self.wallet_started = False async def start(self): - self.blockchain_started or await self.start_blockchain() - self.spv_started or await self.start_spv() - self.wallet_started or await self.start_wallet() + await self.start_blockchain() + await self.start_spv() + await self.start_wallet() async def stop(self): - if self.wallet_started: + all_the_stops = [ + self.wallet_node.stop, + self.spv_node.stop, + self.blockchain_node.stop + ] + for stop in all_the_stops: try: - await self.wallet_node.stop(cleanup=True) + await stop() except Exception as e: - print(e) - if self.spv_started: - try: - await self.spv_node.stop(cleanup=True) - except Exception as e: - print(e) - if self.blockchain_started: - try: - await self.blockchain_node.stop(cleanup=True) - except Exception as e: - print(e) + log.exception('Exception raised while stopping services:', exc_info=e) class WalletNode: @@ -182,7 +200,7 @@ class SPVNode: async def stop(self, cleanup=True): try: - self.server.db.shutdown() + self.server.stop() finally: cleanup and self.cleanup() @@ -198,10 +216,10 @@ class BlockchainProcess(asyncio.SubprocessProtocol): b'keypool return', ] - def __init__(self, log): + def __init__(self): self.ready = asyncio.Event() self.stopped = asyncio.Event() - self.log = log + self.log = log.getChild('blockchain') def pipe_data_received(self, fd, data): if self.log and not any(ignore in data for ignore in self.IGNORE_OUTPUT): @@ -227,7 +245,7 @@ class BlockchainNode: self.bin_dir = os.path.join(self.project_dir, 'bin') self.daemon_bin = os.path.join(self.bin_dir, daemon) self.cli_bin = os.path.join(self.bin_dir, cli) - self.log = logging.getLogger('blockchain') + self.log = log.getChild('blockchain') self.data_path = None self.protocol = None self.transport = None @@ -289,7 +307,7 @@ class BlockchainNode: ) self.log.info(' '.join(command)) self.transport, self.protocol = await loop.subprocess_exec( - lambda: BlockchainProcess(self.log), *command + lambda: BlockchainProcess(), *command ) await self.protocol.ready.wait() diff --git a/torba/server/block_processor.py b/torba/server/block_processor.py index e544eb7b8..93925b1ed 100644 --- a/torba/server/block_processor.py +++ b/torba/server/block_processor.py @@ -657,6 +657,7 @@ class BlockProcessor: # Shut down block processing self.logger.info('flushing to DB for a clean shutdown...') await self.flush(True) + self.db.close() def force_chain_reorg(self, count): '''Force a reorg of the given number of blocks. diff --git a/torba/server/db.py b/torba/server/db.py index 0721dcef5..16e165bc9 100644 --- a/torba/server/db.py +++ b/torba/server/db.py @@ -134,7 +134,7 @@ class DB: # Read TX counts (requires meta directory) await self._read_tx_counts() - def shutdown(self): + def close(self): self.utxo_db.close() self.history.close_db() diff --git a/torba/server/server.py b/torba/server/server.py index b6822e28b..433df49fa 100644 --- a/torba/server/server.py +++ b/torba/server/server.py @@ -108,9 +108,10 @@ class Server: await _start_cancellable(self.mempool.keep_synchronized) await _start_cancellable(self.session_mgr.serve, self.notifications) - def stop(self): + async def stop(self): for task in reversed(self.cancellable_tasks): task.cancel() + await asyncio.wait(self.cancellable_tasks) self.shutdown_event.set() def run(self): diff --git a/torba/testcase.py b/torba/testcase.py index 8e61b7828..e6074c7e9 100644 --- a/torba/testcase.py +++ b/torba/testcase.py @@ -96,36 +96,35 @@ class AsyncioTestCase(unittest.TestCase): "__unittest_expecting_failure__", False) expecting_failure = expecting_failure_class or expecting_failure_method outcome = _Outcome(result) + loop = asyncio.new_event_loop() try: self._outcome = outcome - loop = asyncio.new_event_loop() - try: - asyncio.set_event_loop(loop) - loop.set_debug(True) + asyncio.set_event_loop(loop) + loop.set_debug(True) + with outcome.testPartExecutor(self): + self.setUp() + loop.run_until_complete(self.asyncSetUp()) + if outcome.success: + outcome.expecting_failure = expecting_failure + with outcome.testPartExecutor(self, isTest=True): + maybe_coroutine = testMethod() + if asyncio.iscoroutine(maybe_coroutine): + loop.run_until_complete(maybe_coroutine) + outcome.expecting_failure = False with outcome.testPartExecutor(self): - self.setUp() - loop.run_until_complete(self.asyncSetUp()) - if outcome.success: - outcome.expecting_failure = expecting_failure - with outcome.testPartExecutor(self, isTest=True): - possible_coroutine = testMethod() - if asyncio.iscoroutine(possible_coroutine): - loop.run_until_complete(possible_coroutine) - outcome.expecting_failure = False - with outcome.testPartExecutor(self): - loop.run_until_complete(self.asyncTearDown()) - self.tearDown() - finally: - try: - _cancel_all_tasks(loop) - loop.run_until_complete(loop.shutdown_asyncgens()) - finally: - asyncio.set_event_loop(None) - loop.close() + loop.run_until_complete(self.asyncTearDown()) + self.tearDown() - self.doCleanups() + self.doAsyncCleanups(loop) + + try: + _cancel_all_tasks(loop) + loop.run_until_complete(loop.shutdown_asyncgens()) + finally: + asyncio.set_event_loop(None) + loop.close() for test, reason in outcome.skipped: self._addSkip(result, test, reason) @@ -155,6 +154,15 @@ class AsyncioTestCase(unittest.TestCase): # clear the outcome, no more needed self._outcome = None + def doAsyncCleanups(self, loop): + outcome = self._outcome or _Outcome() + while self._cleanups: + function, args, kwargs = self._cleanups.pop() + with outcome.testPartExecutor(self): + maybe_coroutine = function(*args, **kwargs) + if asyncio.iscoroutine(maybe_coroutine): + loop.run_until_complete(maybe_coroutine) + class IntegrationTestCase(AsyncioTestCase): @@ -176,7 +184,12 @@ class IntegrationTestCase(AsyncioTestCase): self.conductor = Conductor( ledger_module=self.LEDGER, manager_module=self.MANAGER, verbosity=self.VERBOSITY ) - await self.conductor.start() + await self.conductor.start_blockchain() + self.addCleanup(self.conductor.stop_blockchain) + await self.conductor.start_spv() + self.addCleanup(self.conductor.stop_spv) + await self.conductor.start_wallet() + self.addCleanup(self.conductor.stop_wallet) self.blockchain = self.conductor.blockchain_node self.wallet_node = self.conductor.wallet_node self.manager = self.wallet_node.manager @@ -184,9 +197,6 @@ class IntegrationTestCase(AsyncioTestCase): self.wallet = self.wallet_node.wallet self.account = self.wallet_node.wallet.default_account - async def asyncTearDown(self): - await self.conductor.stop() - async def assertBalance(self, account, expected_balance: str): # pylint: disable=C0103 balance = await account.get_balance() self.assertEqual(satoshis_to_coins(balance), expected_balance) From a16495d06fe2fba7f9f527c118e998b44789e383 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 14 Dec 2018 22:31:01 -0500 Subject: [PATCH 276/383] await self.server.stop() --- torba/orchstr8/node.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index 9d30bdd4b..5c34d6b38 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -200,7 +200,7 @@ class SPVNode: async def stop(self, cleanup=True): try: - self.server.stop() + await self.server.stop() finally: cleanup and self.cleanup() From 390226d2efc25cdd53f0a724498aeeb33e6b700b Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 14 Dec 2018 22:36:45 -0500 Subject: [PATCH 277/383] pylint --- torba/orchstr8/node.py | 2 +- torba/testcase.py | 5 +---- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index 5c34d6b38..991ea1241 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -307,7 +307,7 @@ class BlockchainNode: ) self.log.info(' '.join(command)) self.transport, self.protocol = await loop.subprocess_exec( - lambda: BlockchainProcess(), *command + BlockchainProcess, *command ) await self.protocol.ready.wait() diff --git a/torba/testcase.py b/torba/testcase.py index e6074c7e9..84a2f4a41 100644 --- a/torba/testcase.py +++ b/torba/testcase.py @@ -66,9 +66,6 @@ class AsyncioTestCase(unittest.TestCase): async def asyncTearDown(self): # pylint: disable=C0103 pass - async def doAsyncCleanups(self): # pylint: disable=C0103 - pass - def run(self, result=None): # pylint: disable=R0915 orig_result = result if result is None: @@ -154,7 +151,7 @@ class AsyncioTestCase(unittest.TestCase): # clear the outcome, no more needed self._outcome = None - def doAsyncCleanups(self, loop): + def doAsyncCleanups(self, loop): # pylint: disable=C0103 outcome = self._outcome or _Outcome() while self._cleanups: function, args, kwargs = self._cleanups.pop() From d72a1521953b8bf36d95da39fc0688ca644da458 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 15 Dec 2018 15:38:58 -0500 Subject: [PATCH 278/383] run transaction interactions now return a result --- torba/client/basedatabase.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index b6ead4aea..722bb9de1 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -54,12 +54,13 @@ class AIOSQLite: def __run_transaction(self, fun: Callable[[sqlite3.Connection, Any, Any], Any], *args, **kwargs): self.connection.execute('begin') try: - fun(self.connection, *args, **kwargs) # type: ignore - except (Exception, OSError): + result = fun(self.connection, *args, **kwargs) # type: ignore + self.connection.commit() + return result + except (Exception, OSError) as e: + log.exception('Error running transaction:', exc_info=e) self.connection.rollback() raise - else: - self.connection.commit() def constraints_to_sql(constraints, joiner=' AND ', prepend_key=''): From b9b411ec30fa226a506f7e90f4a5bcea6dc79e76 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 6 Jan 2019 16:05:52 -0500 Subject: [PATCH 279/383] instal older aiohttp to make pylint happy --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index bbd6772b5..63ae9794d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -9,8 +9,8 @@ jobs: - stage: code quality name: "pylint & mypy" install: - - pip install astroid==2.0.4 - # newer astroid fails in pylint so we pre-install older version + - pip install astroid==2.0.4 aiohttp==3.4.4 + # newer astroid and aiohttp fails in pylint so we pre-install older version - pip install pylint mypy - pip install -e . script: From 442138ef363118e88fb716ef913f6b170d7d0897 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 7 Jan 2019 03:02:15 -0500 Subject: [PATCH 280/383] added AdvanceTimeTestCase --- torba/testcase.py | 44 +++++++++++++++++++++++++++++++------------- 1 file changed, 31 insertions(+), 13 deletions(-) diff --git a/torba/testcase.py b/torba/testcase.py index 84a2f4a41..7e3913bb8 100644 --- a/torba/testcase.py +++ b/torba/testcase.py @@ -1,5 +1,6 @@ import sys import logging +import functools import asyncio from asyncio.runners import _cancel_all_tasks # type: ignore import unittest @@ -93,35 +94,36 @@ class AsyncioTestCase(unittest.TestCase): "__unittest_expecting_failure__", False) expecting_failure = expecting_failure_class or expecting_failure_method outcome = _Outcome(result) - loop = asyncio.new_event_loop() + + self.loop = asyncio.new_event_loop() # pylint: disable=W0201 + asyncio.set_event_loop(self.loop) + self.loop.set_debug(True) + try: self._outcome = outcome - asyncio.set_event_loop(loop) - loop.set_debug(True) - with outcome.testPartExecutor(self): self.setUp() - loop.run_until_complete(self.asyncSetUp()) + self.loop.run_until_complete(self.asyncSetUp()) if outcome.success: outcome.expecting_failure = expecting_failure with outcome.testPartExecutor(self, isTest=True): maybe_coroutine = testMethod() if asyncio.iscoroutine(maybe_coroutine): - loop.run_until_complete(maybe_coroutine) + self.loop.run_until_complete(maybe_coroutine) outcome.expecting_failure = False with outcome.testPartExecutor(self): - loop.run_until_complete(self.asyncTearDown()) + self.loop.run_until_complete(self.asyncTearDown()) self.tearDown() - self.doAsyncCleanups(loop) + self.doAsyncCleanups() try: - _cancel_all_tasks(loop) - loop.run_until_complete(loop.shutdown_asyncgens()) + _cancel_all_tasks(self.loop) + self.loop.run_until_complete(self.loop.shutdown_asyncgens()) finally: asyncio.set_event_loop(None) - loop.close() + self.loop.close() for test, reason in outcome.skipped: self._addSkip(result, test, reason) @@ -151,14 +153,30 @@ class AsyncioTestCase(unittest.TestCase): # clear the outcome, no more needed self._outcome = None - def doAsyncCleanups(self, loop): # pylint: disable=C0103 + def doAsyncCleanups(self): # pylint: disable=C0103 outcome = self._outcome or _Outcome() while self._cleanups: function, args, kwargs = self._cleanups.pop() with outcome.testPartExecutor(self): maybe_coroutine = function(*args, **kwargs) if asyncio.iscoroutine(maybe_coroutine): - loop.run_until_complete(maybe_coroutine) + self.loop.run_until_complete(maybe_coroutine) + + +class AdvanceTimeTestCase(AsyncioTestCase): + + async def asyncSetUp(self): + self._time = 0 # pylint: disable=W0201 + self.loop.time = functools.wraps(self.loop.time)(lambda: self._time) + await super().asyncSetUp() + + async def advance(self, seconds): + while self.loop._ready: + await asyncio.sleep(0) + self._time += seconds + await asyncio.sleep(0) + while self.loop._ready: + await asyncio.sleep(0) class IntegrationTestCase(AsyncioTestCase): From f4bf260cdba59c9402e560bb5adc0a599e936c74 Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Wed, 9 Jan 2019 11:29:28 -0500 Subject: [PATCH 281/383] fix improperly handled CancelledError on shutdown --- torba/client/basenetwork.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index f6c85c9b8..c1d5f31ef 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -88,7 +88,9 @@ class BaseNetwork: self._on_connected_controller.add(True) delay = 0.0 await self.client.on_disconnected.first - except (Exception, CancelledError): # pylint: disable=broad-except + except CancelledError: + self.running = False + except Exception: # pylint: disable=broad-except log.exception("Connecting to %s raised an exception:", connection_string) if not self.running: return From feee5348295692c4474922f4b47e340ef3b8dc81 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 10 Jan 2019 17:02:57 -0500 Subject: [PATCH 282/383] silence sql transaction errors --- torba/client/basedatabase.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 722bb9de1..145897ad7 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -58,7 +58,7 @@ class AIOSQLite: self.connection.commit() return result except (Exception, OSError) as e: - log.exception('Error running transaction:', exc_info=e) + #log.exception('Error running transaction:', exc_info=e) self.connection.rollback() raise From 186de045b374664922661a95ecad970e37c70e7c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 10 Jan 2019 17:17:12 -0500 Subject: [PATCH 283/383] pylint --- torba/client/basedatabase.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 145897ad7..28d0901c0 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -57,7 +57,7 @@ class AIOSQLite: result = fun(self.connection, *args, **kwargs) # type: ignore self.connection.commit() return result - except (Exception, OSError) as e: + except (Exception, OSError): # as e: #log.exception('Error running transaction:', exc_info=e) self.connection.rollback() raise From 3a8e1cd4a500c2c929f05980ea77dde8cfd2945b Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 13 Jan 2019 02:59:54 -0500 Subject: [PATCH 284/383] initial push of workbench --- torba/orchstr8/cli.py | 5 +- torba/orchstr8/node.py | 26 +- torba/orchstr8/service.py | 35 +-- torba/workbench/Makefile | 5 + torba/workbench/__init__.py | 1 + torba/workbench/_blockchain_dock.py | 70 +++++ torba/workbench/_output_dock.py | 34 +++ torba/workbench/application.py | 401 ++++++++++++++++++++++++++++ torba/workbench/blockchain_dock.ui | 104 ++++++++ torba/workbench/output_dock.ui | 36 +++ 10 files changed, 682 insertions(+), 35 deletions(-) create mode 100644 torba/workbench/Makefile create mode 100644 torba/workbench/__init__.py create mode 100644 torba/workbench/_blockchain_dock.py create mode 100644 torba/workbench/_output_dock.py create mode 100644 torba/workbench/application.py create mode 100644 torba/workbench/blockchain_dock.ui create mode 100644 torba/workbench/output_dock.ui diff --git a/torba/orchstr8/cli.py b/torba/orchstr8/cli.py index 0dc7343e6..523e0c1dd 100644 --- a/torba/orchstr8/cli.py +++ b/torba/orchstr8/cli.py @@ -3,8 +3,8 @@ import argparse import asyncio import aiohttp -from .node import Conductor, get_ledger_from_environment, get_blockchain_node_from_ledger -from .service import ConductorService +from torba.orchstr8.node import Conductor, get_ledger_from_environment, get_blockchain_node_from_ledger +from torba.orchstr8.service import ConductorService def get_argument_parser(): @@ -46,6 +46,7 @@ def main(): return start_app() loop = asyncio.get_event_loop() + asyncio.set_event_loop(loop) ledger = get_ledger_from_environment() if command == 'download': diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index 991ea1241..7e5b834a1 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -50,13 +50,19 @@ def get_blockchain_node_from_ledger(ledger_module): ) -def set_logging(ledger_module, level): - logging.getLogger('torba').setLevel(level) - logging.getLogger('torba.client').setLevel(level) - logging.getLogger('torba.server').setLevel(level) - #logging.getLogger('asyncio').setLevel(level) - logging.getLogger('blockchain').setLevel(level) - logging.getLogger(ledger_module.__name__).setLevel(level) +def set_logging(ledger_module, level, handler=None): + modules = [ + 'torba', + 'torba.client', + 'torba.server', + 'blockchain', + ledger_module.__name__ + ] + for module_name in modules: + module = logging.getLogger(module_name) + module.setLevel(level) + if handler is not None: + module.addHandler(handler) class Conductor: @@ -184,6 +190,7 @@ class SPVNode: self.controller = None self.data_path = None self.server = None + self.port = 1984 async def start(self): self.data_path = tempfile.mkdtemp() @@ -191,7 +198,7 @@ class SPVNode: 'DB_DIRECTORY': self.data_path, 'DAEMON_URL': 'http://rpcuser:rpcpassword@localhost:50001/', 'REORG_LIMIT': '100', - 'TCP_PORT': '1984' + 'TCP_PORT': str(self.port) } os.environ.update(conf) self.server = Server(Env(self.coin_class)) @@ -250,6 +257,7 @@ class BlockchainNode: self.protocol = None self.transport = None self._block_expected = 0 + self.port = 50001 def is_expected_block(self, e: BlockHeightEvent): return self._block_expected == e.height @@ -303,7 +311,7 @@ class BlockchainNode: self.daemon_bin, '-datadir={}'.format(self.data_path), '-printtoconsole', '-regtest', '-server', '-txindex', - '-rpcuser=rpcuser', '-rpcpassword=rpcpassword', '-rpcport=50001' + '-rpcuser=rpcuser', '-rpcpassword=rpcpassword', f'-rpcport={self.port}' ) self.log.info(' '.join(command)) self.transport, self.protocol = await loop.subprocess_exec( diff --git a/torba/orchstr8/service.py b/torba/orchstr8/service.py index 23a7ad3f8..d57bf5a26 100644 --- a/torba/orchstr8/service.py +++ b/torba/orchstr8/service.py @@ -2,7 +2,9 @@ import asyncio import logging from aiohttp.web import Application, WebSocketResponse, json_response from aiohttp.http_websocket import WSMsgType, WSCloseCode -from .node import Conductor + +from torba.client.util import satoshis_to_coins +from .node import Conductor, set_logging PORT = 7954 @@ -56,30 +58,15 @@ class ConductorService: await self.app.cleanup() async def start_stack(self, _): - handler = WebSocketLogHandler(self.send_message) - logging.getLogger('blockchain').setLevel(logging.DEBUG) - logging.getLogger('blockchain').addHandler(handler) - logging.getLogger('electrumx').setLevel(logging.DEBUG) - logging.getLogger('electrumx').addHandler(handler) - logging.getLogger('Controller').setLevel(logging.DEBUG) - logging.getLogger('Controller').addHandler(handler) - logging.getLogger('LBRYBlockProcessor').setLevel(logging.DEBUG) - logging.getLogger('LBRYBlockProcessor').addHandler(handler) - logging.getLogger('LBCDaemon').setLevel(logging.DEBUG) - logging.getLogger('LBCDaemon').addHandler(handler) - logging.getLogger('torba').setLevel(logging.DEBUG) - logging.getLogger('torba').addHandler(handler) - logging.getLogger(self.stack.ledger_module.__name__).setLevel(logging.DEBUG) - logging.getLogger(self.stack.ledger_module.__name__).addHandler(handler) - logging.getLogger(self.stack.ledger_module.__electrumx__.split('.')[0]).setLevel(logging.DEBUG) - logging.getLogger(self.stack.ledger_module.__electrumx__.split('.')[0]).addHandler(handler) - #await self.stack.start() + set_logging( + self.stack.ledger_module, logging.DEBUG, WebSocketLogHandler(self.send_message) + ) self.stack.blockchain_started or await self.stack.start_blockchain() - self.send_message({'type': 'service', 'name': 'blockchain'}) + self.send_message({'type': 'service', 'name': 'blockchain', 'port': self.stack.blockchain_node.port}) self.stack.spv_started or await self.stack.start_spv() - self.send_message({'type': 'service', 'name': 'spv'}) + self.send_message({'type': 'service', 'name': 'spv', 'port': self.stack.spv_node.port}) self.stack.wallet_started or await self.stack.start_wallet() - self.send_message({'type': 'service', 'name': 'wallet'}) + self.send_message({'type': 'service', 'name': 'wallet', 'port': ''}) self.stack.wallet_node.ledger.on_header.listen(self.on_status) self.stack.wallet_node.ledger.on_transaction.listen(self.on_status) return json_response({'started': True}) @@ -138,10 +125,10 @@ class ConductorService: self.send_message({ 'type': 'status', 'height': self.stack.wallet_node.ledger.headers.height, - 'balance': await self.stack.wallet_node.account.get_balance(), + 'balance': satoshis_to_coins(await self.stack.wallet_node.account.get_balance()), 'miner': await self.stack.blockchain_node.get_balance() }) def send_message(self, msg): for web_socket in self.app['websockets']: - asyncio.ensure_future(web_socket.send_json(msg)) + self.loop.create_task(web_socket.send_json(msg)) diff --git a/torba/workbench/Makefile b/torba/workbench/Makefile new file mode 100644 index 000000000..524c22557 --- /dev/null +++ b/torba/workbench/Makefile @@ -0,0 +1,5 @@ +all: _blockchain_dock.py _output_dock.py +_blockchain_dock.py: blockchain_dock.ui + pyside2-uic -d blockchain_dock.ui -o _blockchain_dock.py +_output_dock.py: output_dock.ui + pyside2-uic -d output_dock.ui -o _output_dock.py diff --git a/torba/workbench/__init__.py b/torba/workbench/__init__.py new file mode 100644 index 000000000..3449276fd --- /dev/null +++ b/torba/workbench/__init__.py @@ -0,0 +1 @@ +from .application import main diff --git a/torba/workbench/_blockchain_dock.py b/torba/workbench/_blockchain_dock.py new file mode 100644 index 000000000..2a7cc11d8 --- /dev/null +++ b/torba/workbench/_blockchain_dock.py @@ -0,0 +1,70 @@ +# -*- coding: utf-8 -*- + +# Form implementation generated from reading ui file 'blockchain_dock.ui', +# licensing of 'blockchain_dock.ui' applies. +# +# Created: Sun Jan 13 02:56:21 2019 +# by: pyside2-uic running on PySide2 5.12.0 +# +# WARNING! All changes made in this file will be lost! + +from PySide2 import QtCore, QtGui, QtWidgets + +class Ui_BlockchainDock(object): + def setupUi(self, BlockchainDock): + BlockchainDock.setObjectName("BlockchainDock") + BlockchainDock.resize(416, 167) + BlockchainDock.setFloating(False) + BlockchainDock.setFeatures(QtWidgets.QDockWidget.AllDockWidgetFeatures) + self.dockWidgetContents = QtWidgets.QWidget() + self.dockWidgetContents.setObjectName("dockWidgetContents") + self.formLayout = QtWidgets.QFormLayout(self.dockWidgetContents) + self.formLayout.setObjectName("formLayout") + self.generate = QtWidgets.QPushButton(self.dockWidgetContents) + self.generate.setObjectName("generate") + self.formLayout.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.generate) + self.blocks = QtWidgets.QSpinBox(self.dockWidgetContents) + self.blocks.setMinimum(1) + self.blocks.setMaximum(9999) + self.blocks.setProperty("value", 1) + self.blocks.setObjectName("blocks") + self.formLayout.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.blocks) + self.transfer = QtWidgets.QPushButton(self.dockWidgetContents) + self.transfer.setObjectName("transfer") + self.formLayout.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.transfer) + self.horizontalLayout = QtWidgets.QHBoxLayout() + self.horizontalLayout.setObjectName("horizontalLayout") + self.amount = QtWidgets.QDoubleSpinBox(self.dockWidgetContents) + self.amount.setSuffix("") + self.amount.setMaximum(9999.99) + self.amount.setProperty("value", 10.0) + self.amount.setObjectName("amount") + self.horizontalLayout.addWidget(self.amount) + self.to_label = QtWidgets.QLabel(self.dockWidgetContents) + self.to_label.setObjectName("to_label") + self.horizontalLayout.addWidget(self.to_label) + self.address = QtWidgets.QLineEdit(self.dockWidgetContents) + self.address.setObjectName("address") + self.horizontalLayout.addWidget(self.address) + self.formLayout.setLayout(1, QtWidgets.QFormLayout.FieldRole, self.horizontalLayout) + self.invalidate = QtWidgets.QPushButton(self.dockWidgetContents) + self.invalidate.setObjectName("invalidate") + self.formLayout.setWidget(2, QtWidgets.QFormLayout.LabelRole, self.invalidate) + self.block_hash = QtWidgets.QLineEdit(self.dockWidgetContents) + self.block_hash.setObjectName("block_hash") + self.formLayout.setWidget(2, QtWidgets.QFormLayout.FieldRole, self.block_hash) + BlockchainDock.setWidget(self.dockWidgetContents) + + self.retranslateUi(BlockchainDock) + QtCore.QMetaObject.connectSlotsByName(BlockchainDock) + + def retranslateUi(self, BlockchainDock): + BlockchainDock.setWindowTitle(QtWidgets.QApplication.translate("BlockchainDock", "Blockchain", None, -1)) + self.generate.setText(QtWidgets.QApplication.translate("BlockchainDock", "generate", None, -1)) + self.blocks.setSuffix(QtWidgets.QApplication.translate("BlockchainDock", " block(s)", None, -1)) + self.transfer.setText(QtWidgets.QApplication.translate("BlockchainDock", "transfer", None, -1)) + self.to_label.setText(QtWidgets.QApplication.translate("BlockchainDock", "to", None, -1)) + self.address.setPlaceholderText(QtWidgets.QApplication.translate("BlockchainDock", "recipient address", None, -1)) + self.invalidate.setText(QtWidgets.QApplication.translate("BlockchainDock", "invalidate", None, -1)) + self.block_hash.setPlaceholderText(QtWidgets.QApplication.translate("BlockchainDock", "block hash", None, -1)) + diff --git a/torba/workbench/_output_dock.py b/torba/workbench/_output_dock.py new file mode 100644 index 000000000..980343735 --- /dev/null +++ b/torba/workbench/_output_dock.py @@ -0,0 +1,34 @@ +# -*- coding: utf-8 -*- + +# Form implementation generated from reading ui file 'output_dock.ui', +# licensing of 'output_dock.ui' applies. +# +# Created: Sat Oct 27 16:41:03 2018 +# by: pyside2-uic running on PySide2 5.11.2 +# +# WARNING! All changes made in this file will be lost! + +from PySide2 import QtCore, QtGui, QtWidgets + +class Ui_OutputDock(object): + def setupUi(self, OutputDock): + OutputDock.setObjectName("OutputDock") + OutputDock.resize(700, 397) + OutputDock.setFloating(False) + OutputDock.setFeatures(QtWidgets.QDockWidget.AllDockWidgetFeatures) + self.dockWidgetContents = QtWidgets.QWidget() + self.dockWidgetContents.setObjectName("dockWidgetContents") + self.horizontalLayout = QtWidgets.QHBoxLayout(self.dockWidgetContents) + self.horizontalLayout.setObjectName("horizontalLayout") + self.textEdit = QtWidgets.QTextEdit(self.dockWidgetContents) + self.textEdit.setReadOnly(True) + self.textEdit.setObjectName("textEdit") + self.horizontalLayout.addWidget(self.textEdit) + OutputDock.setWidget(self.dockWidgetContents) + + self.retranslateUi(OutputDock) + QtCore.QMetaObject.connectSlotsByName(OutputDock) + + def retranslateUi(self, OutputDock): + OutputDock.setWindowTitle(QtWidgets.QApplication.translate("OutputDock", "Output", None, -1)) + diff --git a/torba/workbench/application.py b/torba/workbench/application.py new file mode 100644 index 000000000..56b282844 --- /dev/null +++ b/torba/workbench/application.py @@ -0,0 +1,401 @@ +import sys +import json +import math + +from PySide2 import QtCore, QtGui, QtWidgets, QtNetwork, QtWebSockets, QtSvg + +from torba.workbench._output_dock import Ui_OutputDock as OutputDock +from torba.workbench._blockchain_dock import Ui_BlockchainDock as BlockchainDock + + +def dict_to_post_data(d): + query = QtCore.QUrlQuery() + for key, value in d.items(): + query.addQueryItem(str(key), str(value)) + return QtCore.QByteArray(query.toString().encode()) + + +class LoggingOutput(QtWidgets.QDockWidget, OutputDock): + + def __init__(self, title, parent): + super().__init__(parent) + self.setupUi(self) + self.setWindowTitle(title) + + +class BlockchainControls(QtWidgets.QDockWidget, BlockchainDock): + + def __init__(self, parent): + super().__init__(parent) + self.setupUi(self) + self.generate.clicked.connect(self.on_generate) + self.transfer.clicked.connect(self.on_transfer) + + def on_generate(self): + print('generating') + self.parent().run_command('generate', blocks=self.blocks.value()) + + def on_transfer(self): + print('transfering') + self.parent().run_command('transfer', amount=self.amount.value()) + + +class Arrow(QtWidgets.QGraphicsLineItem): + + def __init__(self, start_node, end_node, parent=None, scene=None): + super().__init__(parent, scene) + self.start_node = start_node + self.start_node.connect_arrow(self) + self.end_node = end_node + self.end_node.connect_arrow(self) + self.arrow_head = QtGui.QPolygonF() + self.setFlag(QtWidgets.QGraphicsItem.ItemIsSelectable, True) + self.setZValue(-1000.0) + self.arrow_color = QtCore.Qt.black + self.setPen(QtGui.QPen( + self.arrow_color, 2, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin + )) + + def boundingRect(self): + extra = (self.pen().width() + 20) / 2.0 + p1 = self.line().p1() + p2 = self.line().p2() + size = QtCore.QSizeF(p2.x() - p1.x(), p2.y() - p1.y()) + return QtCore.QRectF(p1, size).normalized().adjusted(-extra, -extra, extra, extra) + + def shape(self): + path = super().shape() + path.addPolygon(self.arrow_head) + return path + + def update_position(self): + line = QtCore.QLineF( + self.mapFromItem(self.start_node, 0, 0), + self.mapFromItem(self.end_node, 0, 0) + ) + self.setLine(line) + + def paint(self, painter, option, widget=None): + if self.start_node.collidesWithItem(self.end_node): + return + + start_node = self.start_node + end_node = self.end_node + color = self.arrow_color + pen = self.pen() + pen.setColor(self.arrow_color) + arrow_size = 20.0 + painter.setPen(pen) + painter.setBrush(self.arrow_color) + + end_rectangle = end_node.sceneBoundingRect() + start_center = start_node.sceneBoundingRect().center() + end_center = end_rectangle.center() + center_line = QtCore.QLineF(start_center, end_center) + end_polygon = QtGui.QPolygonF(end_rectangle) + p1 = end_polygon.at(0) + + intersect_point = QtCore.QPointF() + for p2 in end_polygon: + poly_line = QtCore.QLineF(p1, p2) + intersect_type, intersect_point = poly_line.intersect(center_line) + if intersect_type == QtCore.QLineF.BoundedIntersection: + break + p1 = p2 + + self.setLine(QtCore.QLineF(intersect_point, start_center)) + line = self.line() + + angle = math.acos(line.dx() / line.length()) + if line.dy() >= 0: + angle = (math.pi * 2.0) - angle + + arrow_p1 = line.p1() + QtCore.QPointF( + math.sin(angle + math.pi / 3.0) * arrow_size, + math.cos(angle + math.pi / 3.0) * arrow_size + ) + arrow_p2 = line.p1() + QtCore.QPointF( + math.sin(angle + math.pi - math.pi / 3.0) * arrow_size, + math.cos(angle + math.pi - math.pi / 3.0) * arrow_size + ) + + self.arrow_head.clear() + for point in [line.p1(), arrow_p1, arrow_p2]: + self.arrow_head.append(point) + + painter.drawLine(line) + painter.drawPolygon(self.arrow_head) + if self.isSelected(): + painter.setPen(QtGui.QPen(color, 1, QtCore.Qt.DashLine)) + line = QtCore.QLineF(line) + line.translate(0, 4.0) + painter.drawLine(line) + line.translate(0, -8.0) + painter.drawLine(line) + + +ONLINE_COLOR = "limegreen" +OFFLINE_COLOR = "lightsteelblue" + + +class NodeItem(QtSvg.QGraphicsSvgItem): + + def __init__(self, context_menu): + super().__init__() + self._port = '' + self._color = OFFLINE_COLOR + self.context_menu = context_menu + self.arrows = set() + self.renderer = QtSvg.QSvgRenderer() + self.update_svg() + self.setSharedRenderer(self.renderer) + #self.setScale(2.0) + #self.setTransformOriginPoint(24, 24) + self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable, True) + self.setFlag(QtWidgets.QGraphicsItem.ItemIsSelectable, True) + + def get_svg(self): + return self.SVG.format( + port=self.port, + color=self._color + ) + + def update_svg(self): + self.renderer.load(QtCore.QByteArray(self.get_svg().encode())) + self.update() + + @property + def port(self): + return self._port + + @port.setter + def port(self, port): + self._port = port + self.update_svg() + + @property + def online(self): + return self._color == ONLINE_COLOR + + @online.setter + def online(self, online): + if online: + self._color = ONLINE_COLOR + else: + self._color = OFFLINE_COLOR + self.update_svg() + + def connect_arrow(self, arrow): + self.arrows.add(arrow) + + def disconnect_arrow(self, arrow): + self.arrows.discard(arrow) + + def contextMenuEvent(self, event): + self.scene().clearSelection() + self.setSelected(True) + self.myContextMenu.exec_(event.screenPos()) + + def itemChange(self, change, value): + if change == QtWidgets.QGraphicsItem.ItemPositionChange: + for arrow in self.arrows: + arrow.update_position() + return value + + +class BlockchainNode(NodeItem): + SVG = """ + + + + + {port} + {block} + + """ + + def __init__(self, *args): + self._block_height = '' + super().__init__(*args) + + @property + def block_height(self): + return self._block_height + + @block_height.setter + def block_height(self, block_height): + self._block_height = block_height + self.update_svg() + + def get_svg(self): + return self.SVG.format( + port=self.port, + block=self.block_height, + color=self._color + ) + + +class SPVNode(NodeItem): + SVG = """ + + + + + + + {port} + + """ + + def __init__(self, *args): + super().__init__(*args) + + +class WalletNode(NodeItem): + SVG = """ + + + + + + + + {coins} + + """ + + def __init__(self, *args): + self._coins = '--' + super().__init__(*args) + + @property + def coins(self): + return self._coins + + @coins.setter + def coins(self, coins): + self._coins = coins + self.update_svg() + + def get_svg(self): + return self.SVG.format( + coins=self.coins, + color=self._color + ) + + +class Stage(QtWidgets.QGraphicsScene): + + def __init__(self, parent): + super().__init__(parent) + self.blockchain = b = BlockchainNode(None) + b.port = '' + b.block_height = '' + b.setZValue(0) + b.setPos(-25, -100) + self.addItem(b) + self.spv = s = SPVNode(None) + s.port = '' + s.setZValue(0) + self.addItem(s) + s.setPos(-10, -10) + self.wallet = w = WalletNode(None) + w.coins = '' + w.setZValue(0) + w.update_svg() + self.addItem(w) + w.setPos(0, 100) + + self.addItem(Arrow(b, s)) + self.addItem(Arrow(s, w)) + + +class Orchstr8Workbench(QtWidgets.QMainWindow): + + def __init__(self): + super().__init__() + self.stage = Stage(self) + self.view = QtWidgets.QGraphicsView(self.stage) + self.status_bar = QtWidgets.QStatusBar(self) + + self.setWindowTitle('Orchstr8 Workbench') + self.setCentralWidget(self.view) + self.setStatusBar(self.status_bar) + + self.block_height = self.make_status_label('Height: -- ') + self.user_balance = self.make_status_label('User Balance: -- ') + self.mining_balance = self.make_status_label('Mining Balance: -- ') + + self.wallet_log = LoggingOutput('Wallet', self) + self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.wallet_log) + self.spv_log = LoggingOutput('SPV Server', self) + self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.spv_log) + self.blockchain_log = LoggingOutput('Blockchain', self) + self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.blockchain_log) + + self.blockchain_controls = BlockchainControls(self) + self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.blockchain_controls) + + self.network = QtNetwork.QNetworkAccessManager(self) + self.socket = QtWebSockets.QWebSocket() + self.socket.connected.connect(lambda: self.run_command('start')) + self.socket.error.connect(lambda e: print(f'errored: {e}')) + self.socket.textMessageReceived.connect(self.on_message) + self.socket.open('ws://localhost:7954/log') + + def make_status_label(self, text): + label = QtWidgets.QLabel(text) + label.setFrameStyle(QtWidgets.QLabel.Panel | QtWidgets.QLabel.Sunken) + self.status_bar.addPermanentWidget(label) + return label + + def on_message(self, text): + msg = json.loads(text) + if msg['type'] == 'status': + self.stage.wallet.coins = msg['balance'] + self.stage.blockchain.block_height = msg['height'] + self.block_height.setText(f"Height: {msg['height']} ") + self.user_balance.setText(f"User Balance: {msg['balance']} ") + self.mining_balance.setText(f"Mining Balance: {msg['miner']} ") + elif msg['type'] == 'service': + node = { + 'blockchain': self.stage.blockchain, + 'spv': self.stage.spv, + 'wallet': self.stage.wallet + }[msg['name']] + node.online = True + node.port = f":{msg['port']}" + elif msg['type'] == 'log': + log = { + 'blockchain': self.blockchain_log, + 'electrumx': self.spv_log, + 'lbryumx': self.spv_log, + 'Controller': self.spv_log, + 'LBRYBlockProcessor': self.spv_log, + 'LBCDaemon': self.spv_log, + }.get(msg['name'].split('.')[-1], self.wallet_log) + log.textEdit.append(msg['message']) + + def run_command(self, command, **kwargs): + request = QtNetwork.QNetworkRequest(QtCore.QUrl('http://localhost:7954/'+command)) + request.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded") + reply = self.network.post(request, dict_to_post_data(kwargs)) + # reply.finished.connect(cb) + reply.error.connect(self.on_command_error) + + @staticmethod + def on_command_error(error): + print('failed executing command:') + print(error) + + +def main(): + app = QtWidgets.QApplication(sys.argv) + workbench = Orchstr8Workbench() + workbench.setGeometry(100, 100, 1200, 600) + workbench.show() + return app.exec_() + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/torba/workbench/blockchain_dock.ui b/torba/workbench/blockchain_dock.ui new file mode 100644 index 000000000..2946b839d --- /dev/null +++ b/torba/workbench/blockchain_dock.ui @@ -0,0 +1,104 @@ + + + BlockchainDock + + + + 0 + 0 + 416 + 167 + + + + false + + + QDockWidget::AllDockWidgetFeatures + + + Blockchain + + + + + + + generate + + + + + + + block(s) + + + 1 + + + 9999 + + + 1 + + + + + + + transfer + + + + + + + + + + + + 9999.989999999999782 + + + 10.000000000000000 + + + + + + + to + + + + + + + recipient address + + + + + + + + + invalidate + + + + + + + block hash + + + + + + + + + diff --git a/torba/workbench/output_dock.ui b/torba/workbench/output_dock.ui new file mode 100644 index 000000000..3e1136659 --- /dev/null +++ b/torba/workbench/output_dock.ui @@ -0,0 +1,36 @@ + + + OutputDock + + + + 0 + 0 + 700 + 397 + + + + false + + + QDockWidget::AllDockWidgetFeatures + + + Output + + + + + + + true + + + + + + + + + From ed32d17936acfcf848f287cce3adf17683cefbcb Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 13 Jan 2019 11:44:32 -0500 Subject: [PATCH 285/383] use guarded stop methods in orchstr8/node.py --- torba/orchstr8/node.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index 7e5b834a1..f263881a9 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -122,9 +122,9 @@ class Conductor: async def stop(self): all_the_stops = [ - self.wallet_node.stop, - self.spv_node.stop, - self.blockchain_node.stop + self.stop_wallet, + self.stop_spv, + self.stop_blockchain ] for stop in all_the_stops: try: From 527e288568133237e9e682b0402e6b3643e94f57 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 13 Jan 2019 14:50:24 -0500 Subject: [PATCH 286/383] explicitely specify ipv4 --- torba/server/session.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/torba/server/session.py b/torba/server/session.py index c5b063ec5..b85182cec 100644 --- a/torba/server/session.py +++ b/torba/server/session.py @@ -16,6 +16,7 @@ import os import pylru import ssl import time +import socket from asyncio import Event, sleep from collections import defaultdict from functools import partial @@ -147,7 +148,7 @@ class SessionManager: protocol_class = self.env.coin.SESSIONCLS protocol_factory = partial(protocol_class, self, self.db, self.mempool, self.peer_mgr, kind) - server = loop.create_server(protocol_factory, *args, **kw_args) + server = loop.create_server(protocol_factory, *args, family=socket.AF_INET, **kw_args) host, port = args[:2] try: From e79202de3cf78b8ee91bcbd807db9cf40c62df98 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 13 Jan 2019 22:38:36 -0500 Subject: [PATCH 287/383] support for linking between nodes --- torba/orchstr8/node.py | 36 +++++++++++++++++++++++------------- torba/orchstr8/service.py | 2 +- 2 files changed, 24 insertions(+), 14 deletions(-) diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index f263881a9..abe2009d9 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -97,7 +97,7 @@ class Conductor: async def start_spv(self): if not self.spv_started: - await self.spv_node.start() + await self.spv_node.start(self.blockchain_node) self.spv_started = True async def stop_spv(self): @@ -107,7 +107,7 @@ class Conductor: async def start_wallet(self): if not self.wallet_started: - await self.wallet_node.start() + await self.wallet_node.start(self.spv_node) self.wallet_started = True async def stop_wallet(self): @@ -136,7 +136,7 @@ class Conductor: class WalletNode: def __init__(self, manager_class: Type[BaseWalletManager], ledger_class: Type[BaseLedger], - verbose: bool = False, api_port: int = 5279) -> None: + verbose: bool = False, port: int = 5280) -> None: self.manager_class = manager_class self.ledger_class = ledger_class self.verbose = verbose @@ -145,9 +145,9 @@ class WalletNode: self.wallet: Optional[Wallet] = None self.account: Optional[BaseAccount] = None self.data_path: Optional[str] = None - self.api_port = api_port + self.port = port - async def start(self, seed=None): + async def start(self, spv_node: 'SPVNode', seed=None): self.data_path = tempfile.mkdtemp() wallet_file_name = os.path.join(self.data_path, 'my_wallet.json') with open(wallet_file_name, 'w') as wallet_file: @@ -155,8 +155,8 @@ class WalletNode: self.manager = self.manager_class.from_config({ 'ledgers': { self.ledger_class.get_id(): { - 'api_port': self.api_port, - 'default_servers': [('localhost', 1984)], + 'api_port': self.port, + 'default_servers': [(spv_node.hostname, spv_node.port)], 'data_path': self.data_path } }, @@ -190,16 +190,19 @@ class SPVNode: self.controller = None self.data_path = None self.server = None - self.port = 1984 + self.hostname = 'localhost' + self.port = 50001 + 1 # avoid conflict with default daemon - async def start(self): + async def start(self, blockchain_node: 'BlockchainNode'): self.data_path = tempfile.mkdtemp() conf = { 'DB_DIRECTORY': self.data_path, - 'DAEMON_URL': 'http://rpcuser:rpcpassword@localhost:50001/', + 'DAEMON_URL': blockchain_node.rpc_url, 'REORG_LIMIT': '100', + 'TCP_HOST': self.hostname, 'TCP_PORT': str(self.port) } + # TODO: don't use os.environ os.environ.update(conf) self.server = Server(Env(self.coin_class)) self.server.mempool.refresh_secs = self.server.bp.prefetcher.polling_delay = 0.5 @@ -257,7 +260,14 @@ class BlockchainNode: self.protocol = None self.transport = None self._block_expected = 0 - self.port = 50001 + self.rpcuser = 'rpcuser' + self.rpcpassword = 'rpcpassword' + self.hostname = 'localhost' + self.port = 9245 + 1 # avoid conflict with default daemon + + @property + def rpc_url(self): + return f'http://{self.rpcuser}:{self.rpcpassword}@{self.hostname}:{self.port}/' def is_expected_block(self, e: BlockHeightEvent): return self._block_expected == e.height @@ -311,7 +321,7 @@ class BlockchainNode: self.daemon_bin, '-datadir={}'.format(self.data_path), '-printtoconsole', '-regtest', '-server', '-txindex', - '-rpcuser=rpcuser', '-rpcpassword=rpcpassword', f'-rpcport={self.port}' + f'-rpcuser={self.rpcuser}', f'-rpcpassword={self.rpcpassword}', f'-rpcport={self.port}' ) self.log.info(' '.join(command)) self.transport, self.protocol = await loop.subprocess_exec( @@ -334,7 +344,7 @@ class BlockchainNode: async def _cli_cmnd(self, *args): cmnd_args = [ self.cli_bin, '-datadir={}'.format(self.data_path), '-regtest', - '-rpcuser=rpcuser', '-rpcpassword=rpcpassword', '-rpcport=50001' + f'-rpcuser={self.rpcuser}', f'-rpcpassword={self.rpcpassword}', f'-rpcport={self.port}' ] + list(args) self.log.info(' '.join(cmnd_args)) loop = asyncio.get_event_loop() diff --git a/torba/orchstr8/service.py b/torba/orchstr8/service.py index d57bf5a26..da72a5c62 100644 --- a/torba/orchstr8/service.py +++ b/torba/orchstr8/service.py @@ -66,7 +66,7 @@ class ConductorService: self.stack.spv_started or await self.stack.start_spv() self.send_message({'type': 'service', 'name': 'spv', 'port': self.stack.spv_node.port}) self.stack.wallet_started or await self.stack.start_wallet() - self.send_message({'type': 'service', 'name': 'wallet', 'port': ''}) + self.send_message({'type': 'service', 'name': 'wallet', 'port': self.stack.wallet_node.port}) self.stack.wallet_node.ledger.on_header.listen(self.on_status) self.stack.wallet_node.ledger.on_transaction.listen(self.on_status) return json_response({'started': True}) From 6a00cf9942ab77943b05e880e1fea43ccf5488c4 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 13 Jan 2019 22:44:46 -0500 Subject: [PATCH 288/383] mypy fixes --- torba/orchstr8/node.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index abe2009d9..b53aa7486 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -164,12 +164,14 @@ class WalletNode: }) self.ledger = self.manager.ledgers[self.ledger_class] self.wallet = self.manager.default_wallet - if seed is None: + if seed is None and self.wallet is not None: self.wallet.generate_account(self.ledger) - else: + elif self.wallet is not None: self.ledger.account_class.from_dict( self.ledger, self.wallet, {'seed': seed} ) + else: + raise ValueError('Wallet is required.') self.account = self.wallet.default_account await self.manager.start() From 08814ad81104e109ceb3200f5e41e1add34c1319 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 13 Jan 2019 22:52:49 -0500 Subject: [PATCH 289/383] test_sync.py fixes --- tests/client_tests/integration/test_sync.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/client_tests/integration/test_sync.py b/tests/client_tests/integration/test_sync.py index 1a43d0954..612b041b7 100644 --- a/tests/client_tests/integration/test_sync.py +++ b/tests/client_tests/integration/test_sync.py @@ -26,7 +26,7 @@ class SyncTests(IntegrationTestCase): wallet_node = WalletNode( self.wallet_node.manager_class, self.wallet_node.ledger_class, - api_port=self.api_port + port=self.api_port ) await wallet_node.start(seed) self.started_nodes.append(wallet_node) From 355989d6d1b75513b3daf368627ce05d1150a8a0 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 13 Jan 2019 22:59:57 -0500 Subject: [PATCH 290/383] test_sync.py fixes --- tests/client_tests/integration/test_sync.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/client_tests/integration/test_sync.py b/tests/client_tests/integration/test_sync.py index 612b041b7..cfb22755c 100644 --- a/tests/client_tests/integration/test_sync.py +++ b/tests/client_tests/integration/test_sync.py @@ -28,7 +28,7 @@ class SyncTests(IntegrationTestCase): self.wallet_node.ledger_class, port=self.api_port ) - await wallet_node.start(seed) + await wallet_node.start(self.conductor.spv_node, seed) self.started_nodes.append(wallet_node) return wallet_node From 7a8c2fc98ba31751ec9262ab4adcefe4f6335a9e Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 15 Jan 2019 00:22:55 -0500 Subject: [PATCH 291/383] removed hard coded ipv4 and replaced it with being able to provide hostname to --spv --- torba/orchstr8/cli.py | 9 ++++++--- torba/server/session.py | 3 +-- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/torba/orchstr8/cli.py b/torba/orchstr8/cli.py index 523e0c1dd..e3639ecdb 100644 --- a/torba/orchstr8/cli.py +++ b/torba/orchstr8/cli.py @@ -18,9 +18,9 @@ def get_argument_parser(): subparsers.add_parser("download", help="Download blockchain node binary.") start = subparsers.add_parser("start", help="Start orchstr8 service.") - start.add_argument("--blockchain", help="Start blockchain node.", action="store_true") - start.add_argument("--spv", help="Start SPV server.", action="store_true") - start.add_argument("--wallet", help="Start wallet daemon.", action="store_true") + start.add_argument("--blockchain", help="Hostname to start blockchain node.") + start.add_argument("--spv", help="Hostname to start SPV server.") + start.add_argument("--wallet", help="Hostname to start wallet daemon.") generate = subparsers.add_parser("generate", help="Call generate method on running orchstr8 instance.") generate.add_argument("blocks", type=int, help="Number of blocks to generate") @@ -62,10 +62,13 @@ def main(): conductor = Conductor() if getattr(args, 'blockchain', False): + conductor.blockchain_node.hostname = args.blockchain loop.run_until_complete(conductor.start_blockchain()) if getattr(args, 'spv', False): + conductor.spv_node.hostname = args.spv loop.run_until_complete(conductor.start_spv()) if getattr(args, 'wallet', False): + conductor.wallet_node.hostname = args.wallet loop.run_until_complete(conductor.start_wallet()) service = ConductorService(conductor, loop) diff --git a/torba/server/session.py b/torba/server/session.py index b85182cec..c5b063ec5 100644 --- a/torba/server/session.py +++ b/torba/server/session.py @@ -16,7 +16,6 @@ import os import pylru import ssl import time -import socket from asyncio import Event, sleep from collections import defaultdict from functools import partial @@ -148,7 +147,7 @@ class SessionManager: protocol_class = self.env.coin.SESSIONCLS protocol_factory = partial(protocol_class, self, self.db, self.mempool, self.peer_mgr, kind) - server = loop.create_server(protocol_factory, *args, family=socket.AF_INET, **kw_args) + server = loop.create_server(protocol_factory, *args, **kw_args) host, port = args[:2] try: From 09b77972d9a406b3c2228ad09536ddf48022116a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 15 Jan 2019 15:24:08 -0500 Subject: [PATCH 292/383] convert localhost to 127.0.0.1 bypassing /etc/hosts which resolves to ::1 and fails on default docker setup --- torba/server/env.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/torba/server/env.py b/torba/server/env.py index 28dd266e2..d748d536b 100644 --- a/torba/server/env.py +++ b/torba/server/env.py @@ -154,6 +154,10 @@ class Env: # permitted for an RPC server. if for_rpc and not result: result = 'localhost' + if result == 'localhost': + # 'localhost' resolves to ::1 (ipv6) on many systems, which fails on default setup of + # docker, using 127.0.0.1 instead forces ipv4 + result = '127.0.0.1' return result def sane_max_sessions(self): From a53b60fca4963a9c1e06ef18fb2ab57378dc9a52 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 16 Jan 2019 13:05:23 -0500 Subject: [PATCH 293/383] use correct env variable for setting SPV hostname --- torba/orchstr8/node.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index b53aa7486..bb6d16d1a 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -201,7 +201,7 @@ class SPVNode: 'DB_DIRECTORY': self.data_path, 'DAEMON_URL': blockchain_node.rpc_url, 'REORG_LIMIT': '100', - 'TCP_HOST': self.hostname, + 'HOST': self.hostname, 'TCP_PORT': str(self.port) } # TODO: don't use os.environ From 2cb9d5c63612399b0990ac7c30969cc1a6065843 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 16 Jan 2019 13:28:12 -0500 Subject: [PATCH 294/383] orchstr service transfer command works without wallet availability --- torba/orchstr8/service.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/torba/orchstr8/service.py b/torba/orchstr8/service.py index da72a5c62..3c368c457 100644 --- a/torba/orchstr8/service.py +++ b/torba/orchstr8/service.py @@ -80,13 +80,16 @@ class ConductorService: async def transfer(self, request): data = await request.post() address = data.get('address') - if not address: + if not address and self.stack.wallet_started: address = await self.stack.wallet_node.account.receiving.get_or_create_usable_address() + if not address: + raise ValueError("No address was provided.") amount = data.get('amount', 1) txid = await self.stack.blockchain_node.send_to_address(address, amount) - await self.stack.wallet_node.ledger.on_transaction.where( - lambda e: e.tx.id == txid and e.address == address - ) + if self.stack.wallet_started: + await self.stack.wallet_node.ledger.on_transaction.where( + lambda e: e.tx.id == txid and e.address == address + ) return json_response({ 'address': address, 'amount': amount, From 3e4c9f25a863799ea5648942734ca9b628119082 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 23 Jan 2019 17:03:45 -0300 Subject: [PATCH 295/383] signal handlers cant call async functions --- torba/server/server.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torba/server/server.py b/torba/server/server.py index 433df49fa..a9e980951 100644 --- a/torba/server/server.py +++ b/torba/server/server.py @@ -117,8 +117,8 @@ class Server: def run(self): loop = asyncio.get_event_loop() try: - loop.add_signal_handler(signal.SIGINT, self.stop) - loop.add_signal_handler(signal.SIGTERM, self.stop) + loop.add_signal_handler(signal.SIGINT, lambda: asyncio.ensure_future(self.stop())) + loop.add_signal_handler(signal.SIGTERM, lambda: asyncio.ensure_future(self.stop())) loop.run_until_complete(self.start()) loop.run_until_complete(self.shutdown_event.wait()) finally: From 9a9d37cc50447555327e96f99f20c0933395be66 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Thu, 24 Jan 2019 21:40:24 -0300 Subject: [PATCH 296/383] [wallet server] improved/stabler signal handlers --- torba/server/server.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/torba/server/server.py b/torba/server/server.py index a9e980951..ffcdfc4b9 100644 --- a/torba/server/server.py +++ b/torba/server/server.py @@ -116,10 +116,16 @@ class Server: def run(self): loop = asyncio.get_event_loop() + + def __exit(): + raise SystemExit() try: - loop.add_signal_handler(signal.SIGINT, lambda: asyncio.ensure_future(self.stop())) - loop.add_signal_handler(signal.SIGTERM, lambda: asyncio.ensure_future(self.stop())) + loop.add_signal_handler(signal.SIGINT, __exit) + loop.add_signal_handler(signal.SIGTERM, __exit) loop.run_until_complete(self.start()) loop.run_until_complete(self.shutdown_event.wait()) + except (SystemExit, KeyboardInterrupt): + pass finally: + loop.run_until_complete(self.stop()) loop.run_until_complete(loop.shutdown_asyncgens()) From 662f2bff4c53cd2086f2d31d4bc5cadf5d655c90 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Fri, 25 Jan 2019 11:57:45 -0300 Subject: [PATCH 297/383] [wallet server] take control of executor --- torba/server/server.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/torba/server/server.py b/torba/server/server.py index ffcdfc4b9..b6435e5ab 100644 --- a/torba/server/server.py +++ b/torba/server/server.py @@ -1,6 +1,7 @@ import signal import logging import asyncio +from concurrent.futures.thread import ThreadPoolExecutor import torba from torba.server.mempool import MemPool, MemPoolAPI @@ -116,6 +117,8 @@ class Server: def run(self): loop = asyncio.get_event_loop() + executor = ThreadPoolExecutor(1) + loop.set_default_executor(executor) def __exit(): raise SystemExit() @@ -123,9 +126,8 @@ class Server: loop.add_signal_handler(signal.SIGINT, __exit) loop.add_signal_handler(signal.SIGTERM, __exit) loop.run_until_complete(self.start()) - loop.run_until_complete(self.shutdown_event.wait()) except (SystemExit, KeyboardInterrupt): pass finally: + executor.shutdown(True) loop.run_until_complete(self.stop()) - loop.run_until_complete(loop.shutdown_asyncgens()) From 9d3e1af69b7880b30ef0fdc772ce940acc082b88 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Fri, 25 Jan 2019 18:30:19 -0300 Subject: [PATCH 298/383] [wallet server] stop executor after stopping server and wait for shutdown event --- torba/server/server.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/torba/server/server.py b/torba/server/server.py index b6435e5ab..384287d20 100644 --- a/torba/server/server.py +++ b/torba/server/server.py @@ -126,8 +126,9 @@ class Server: loop.add_signal_handler(signal.SIGINT, __exit) loop.add_signal_handler(signal.SIGTERM, __exit) loop.run_until_complete(self.start()) + loop.run_until_complete(self.shutdown_event.wait()) except (SystemExit, KeyboardInterrupt): pass finally: - executor.shutdown(True) loop.run_until_complete(self.stop()) + executor.shutdown(True) From e1c0caa357e0bef134f14b6fa2689328d22a9619 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Mon, 28 Jan 2019 23:36:16 -0300 Subject: [PATCH 299/383] add executemany and translate batches to it --- torba/client/basedatabase.py | 31 +++++++++++++------------------ 1 file changed, 13 insertions(+), 18 deletions(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 28d0901c0..106e3e1d5 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -35,6 +35,11 @@ class AIOSQLite: self.connection = None return asyncio.get_event_loop_policy().get_event_loop().call_later(0.01, __close, conn) + def executemany(self, sql: str, params: Iterable): + def __executemany_in_a_transaction(conn: sqlite3.Connection, *args, **kwargs): + return conn.executemany(*args, **kwargs) + return self.run(__executemany_in_a_transaction, sql, params) + def executescript(self, script: str) -> Awaitable: return wrap_future(self.executor.submit(self.connection.executescript, script)) @@ -321,12 +326,8 @@ class BaseDatabase(SQLiteMixin): return self.db.run(_transaction, tx, address, txhash, history) async def reserve_outputs(self, txos, is_reserved=True): - txoids = [txo.id for txo in txos] - await self.db.execute( - "UPDATE txo SET is_reserved = ? WHERE txoid IN ({})".format( - ', '.join(['?']*len(txoids)) - ), [is_reserved]+txoids - ) + txoids = ((is_reserved, txo.id) for txo in txos) + await self.db.executemany("UPDATE txo SET is_reserved = ? WHERE txoid = ?", txoids) async def release_outputs(self, txos): await self.reserve_outputs(txos, is_reserved=False) @@ -488,18 +489,12 @@ class BaseDatabase(SQLiteMixin): return addresses[0] async def add_keys(self, account, chain, keys): - sql = ( - "insert into pubkey_address " - "(address, account, chain, position, pubkey) " - "values " - ) + ', '.join(['(?, ?, ?, ?, ?)'] * len(keys)) - values = [] - for position, pubkey in keys: - values.extend(( - pubkey.address, account.public_key.address, chain, position, - sqlite3.Binary(pubkey.pubkey_bytes) - )) - await self.db.execute(sql, values) + sql = "insert into pubkey_address (address, account, chain, position, pubkey) values (?, ?, ?, ?, ?)" + values = ( + (pubkey.address, account.public_key.address, chain, position, sqlite3.Binary(pubkey.pubkey_bytes)) + for position, pubkey in keys + ) + await self.db.executemany(sql, values) async def _set_address_history(self, address, history): await self.db.execute( From 19e326c1403e57b9936b95b8ce33eafd042248de Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Tue, 29 Jan 2019 14:27:46 -0300 Subject: [PATCH 300/383] simplify generate_keys --- torba/client/baseaccount.py | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index bfa8e2637..86d1d0d7d 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -134,16 +134,9 @@ class HierarchicalDeterministic(AddressManager): async def _generate_keys(self, start: int, end: int) -> List[str]: if not self.address_generator_lock.locked(): raise RuntimeError('Should not be called outside of address_generator_lock.') - keys_batch, final_keys = [], [] - for index in range(start, end+1): - keys_batch.append((index, self.public_key.child(index))) - if index % 180 == 0 or index == end: - await self.account.ledger.db.add_keys( - self.account, self.chain_number, keys_batch - ) - final_keys.extend(keys_batch) - keys_batch.clear() - return [key[1].address for key in final_keys] + keys = [(index, self.public_key.child(index)) for index in range(start, end+1)] + await self.account.ledger.db.add_keys(self.account, self.chain_number, keys) + return [key[1].address for key in keys] def get_address_records(self, only_usable: bool = False, **constraints): if only_usable: From 45669dad336f7b74dd7c04d3f826620ed2f777c7 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Tue, 29 Jan 2019 14:51:59 -0300 Subject: [PATCH 301/383] simplify add_keys --- torba/client/basedatabase.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 106e3e1d5..4e2d1ee51 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -489,12 +489,12 @@ class BaseDatabase(SQLiteMixin): return addresses[0] async def add_keys(self, account, chain, keys): - sql = "insert into pubkey_address (address, account, chain, position, pubkey) values (?, ?, ?, ?, ?)" - values = ( - (pubkey.address, account.public_key.address, chain, position, sqlite3.Binary(pubkey.pubkey_bytes)) - for position, pubkey in keys + await self.db.executemany( + "insert into pubkey_address (address, account, chain, position, pubkey) values (?, ?, ?, ?, ?)", + ((pubkey.address, account.public_key.address, chain, + position, sqlite3.Binary(pubkey.pubkey_bytes)) + for position, pubkey in keys) ) - await self.db.executemany(sql, values) async def _set_address_history(self, address, history): await self.db.execute( From 364f95612a48a33066b99d5a26c26f4e99d150d8 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 10 Feb 2019 23:11:47 -0500 Subject: [PATCH 302/383] 0.3.0 --- torba/__init__.py | 2 +- torba/orchstr8/node.py | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/torba/__init__.py b/torba/__init__.py index 2d20cabca..b3f7f9e86 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.2.5' +__version__ = '0.3.0' diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index bb6d16d1a..a75175222 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -147,7 +147,7 @@ class WalletNode: self.data_path: Optional[str] = None self.port = port - async def start(self, spv_node: 'SPVNode', seed=None): + async def start(self, spv_node: 'SPVNode', seed=None, connect=True): self.data_path = tempfile.mkdtemp() wallet_file_name = os.path.join(self.data_path, 'my_wallet.json') with open(wallet_file_name, 'w') as wallet_file: @@ -173,7 +173,8 @@ class WalletNode: else: raise ValueError('Wallet is required.') self.account = self.wallet.default_account - await self.manager.start() + if connect: + await self.manager.start() async def stop(self, cleanup=True): try: From cabc58feb4b74191356f05b3852a2a6041f2d742 Mon Sep 17 00:00:00 2001 From: Brannon King Date: Mon, 11 Feb 2019 11:01:07 -0700 Subject: [PATCH 303/383] fix decoding error in torba log --- torba/orchstr8/node.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index a75175222..e9113de8c 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -237,12 +237,12 @@ class BlockchainProcess(asyncio.SubprocessProtocol): def pipe_data_received(self, fd, data): if self.log and not any(ignore in data for ignore in self.IGNORE_OUTPUT): if b'Error:' in data: - self.log.error(data.decode('ascii')) + self.log.error(data.decode()) else: - self.log.info(data.decode('ascii')) + self.log.info(data.decode()) if b'Error:' in data: self.ready.set() - raise SystemError(data.decode('ascii')) + raise SystemError(data.decode()) elif b'Done loading' in data: self.ready.set() From 6c68ba1d22ce501fba00a2fb5204e902dde5a1f1 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Tue, 12 Feb 2019 18:50:43 -0300 Subject: [PATCH 304/383] add timeout->retry tests] --- tests/client_tests/integration/test_reconnect.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/tests/client_tests/integration/test_reconnect.py b/tests/client_tests/integration/test_reconnect.py index 857954889..a2b7b71d1 100644 --- a/tests/client_tests/integration/test_reconnect.py +++ b/tests/client_tests/integration/test_reconnect.py @@ -1,5 +1,5 @@ import logging -from asyncio import CancelledError +import asyncio from torba.testcase import IntegrationTestCase @@ -21,7 +21,7 @@ class ReconnectTests(IntegrationTestCase): d = self.ledger.network.get_transaction(sendtxid) # what's that smoke on my ethernet cable? oh no! self.ledger.network.client.connection_lost(Exception()) - with self.assertRaises(CancelledError): + with self.assertRaises(asyncio.CancelledError): await d # rich but offline? no way, no water, let's retry with self.assertRaisesRegex(ConnectionError, 'connection is not available'): @@ -31,3 +31,11 @@ class ReconnectTests(IntegrationTestCase): await self.blockchain.generate(1) # omg, the burned cable still works! torba is fire proof! await self.ledger.network.get_transaction(sendtxid) + + async def test_timeout_then_reconnect(self): + await self.ledger.stop() + conf = self.ledger.config + self.ledger.config['connect_timeout'] = 1 + self.ledger.config['default_servers'] = [('10.0.0.1', 12)] + list(conf['default_servers']) + await self.ledger.start() + self.assertTrue(self.ledger.network.is_connected) \ No newline at end of file From 57eb56b92d719df1f263454671d45d4d3e24d4f2 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Tue, 12 Feb 2019 18:51:12 -0300 Subject: [PATCH 305/383] timeout earlier on connect --- torba/client/basenetwork.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index c1d5f31ef..0915fb056 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -38,9 +38,9 @@ class ClientSession(BaseClientSession): await self.send_request('server.banner') await asyncio.sleep(self.max_seconds_idle//3) - async def create_connection(self): + async def create_connection(self, timeout=6): connector = Connector(lambda: self, *self.server) - await connector.create_connection() + await asyncio.wait_for(connector.create_connection(), timeout=timeout) self.ping_task = asyncio.create_task(self.ping_forever()) async def handle_request(self, request): @@ -78,11 +78,12 @@ class BaseNetwork: async def start(self): self.running = True delay = 0.0 + connect_timeout = self.config.get('connect_timeout', 6) for server in cycle(self.config['default_servers']): self.client = ClientSession(network=self, server=server) connection_string = '{}:{}'.format(*server) try: - await self.client.create_connection() + await self.client.create_connection(connect_timeout) await self.ensure_server_version() log.info("Successfully connected to SPV wallet server: %s", connection_string) self._on_connected_controller.add(True) @@ -90,6 +91,8 @@ class BaseNetwork: await self.client.on_disconnected.first except CancelledError: self.running = False + except asyncio.TimeoutError: + log.warning("Timed out connecting to: %s", connection_string) except Exception: # pylint: disable=broad-except log.exception("Connecting to %s raised an exception:", connection_string) if not self.running: From f134bc264b5d4d6de8159a8bbae2e867d628de0a Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Wed, 13 Feb 2019 17:46:52 -0500 Subject: [PATCH 306/383] add run_nofk to AIOSQLite to run without foreign keys --- torba/client/basedatabase.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 4e2d1ee51..ccbffb7e5 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -67,6 +67,25 @@ class AIOSQLite: self.connection.rollback() raise + def run_nofk(self, fun, *args, **kwargs) -> Awaitable: + return wrap_future(self.executor.submit(self.__run_transaction_no_fk, fun, *args, **kwargs)) + + def __run_transaction_no_fk(self, fun: Callable[[sqlite3.Connection, Any, Any], Any], *args, **kwargs): + try: + self.connection.execute('pragma foreign_keys=off') + self.connection.commit() + try: + self.connection.execute('begin') + result = fun(self.connection, *args, **kwargs) # type: ignore + self.connection.commit() + return result + except (Exception, OSError): # as e: + self.connection.rollback() + raise + finally: + self.connection.execute('pragma foreign_keys=on') + self.connection.commit() + def constraints_to_sql(constraints, joiner=' AND ', prepend_key=''): sql, values = [], {} From 97e4d51c2910999f6dad9195f823376484be4123 Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Wed, 13 Feb 2019 22:34:07 -0500 Subject: [PATCH 307/383] tests and feedback --- tests/client_tests/unit/test_database.py | 43 +++++++++++++++++++++++- torba/client/basedatabase.py | 21 ++++++------ 2 files changed, 52 insertions(+), 12 deletions(-) diff --git a/tests/client_tests/unit/test_database.py b/tests/client_tests/unit/test_database.py index e9d873d77..29aaa684b 100644 --- a/tests/client_tests/unit/test_database.py +++ b/tests/client_tests/unit/test_database.py @@ -1,15 +1,56 @@ import unittest +import sqlite3 from torba.client.wallet import Wallet from torba.client.constants import COIN from torba.coin.bitcoinsegwit import MainNetLedger as ledger_class -from torba.client.basedatabase import query, constraints_to_sql +from torba.client.basedatabase import query, constraints_to_sql, AIOSQLite from torba.testcase import AsyncioTestCase from client_tests.unit.test_transaction import get_output, NULL_HASH +class TestAIOSQLite(AsyncioTestCase): + async def asyncSetUp(self): + self.db = await AIOSQLite.connect(':memory:') + await self.db.executescript(""" + pragma foreign_keys=on; + create table parent (id integer primary key, name); + create table child (id integer primary key, parent_id references parent); + """) + await self.db.execute("insert into parent values (1, 'test')") + await self.db.execute("insert into child values (2, 1)") + + @staticmethod + def delete_item(transaction): + transaction.execute('delete from parent where id=1') + + async def test_foreign_keys_integrity_error(self): + self.assertListEqual([(1, 'test')], await self.db.execute_fetchall("select * from parent")) + + with self.assertRaises(sqlite3.IntegrityError): + await self.db.run(self.delete_item) + self.assertListEqual([(1, 'test')], await self.db.execute_fetchall("select * from parent")) + + await self.db.executescript("pragma foreign_keys=off;") + + await self.db.run(self.delete_item) + self.assertListEqual([], await self.db.execute_fetchall("select * from parent")) + + async def test_run_without_foreign_keys(self): + self.assertListEqual([(1, 'test')], await self.db.execute_fetchall("select * from parent")) + await self.db.run_with_foreign_keys_disabled(self.delete_item) + self.assertListEqual([], await self.db.execute_fetchall("select * from parent")) + + async def test_integrity_error_when_foreign_keys_disabled_and_skipped(self): + await self.db.executescript("pragma foreign_keys=off;") + self.assertListEqual([(1, 'test')], await self.db.execute_fetchall("select * from parent")) + with self.assertRaises(sqlite3.IntegrityError): + await self.db.run_with_foreign_keys_disabled(self.delete_item) + self.assertListEqual([(1, 'test')], await self.db.execute_fetchall("select * from parent")) + + class TestQueryBuilder(unittest.TestCase): def test_dot(self): diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index ccbffb7e5..77a2bb647 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -67,21 +67,20 @@ class AIOSQLite: self.connection.rollback() raise - def run_nofk(self, fun, *args, **kwargs) -> Awaitable: - return wrap_future(self.executor.submit(self.__run_transaction_no_fk, fun, *args, **kwargs)) + def run_with_foreign_keys_disabled(self, fun, *args, **kwargs) -> Awaitable: + return wrap_future( + self.executor.submit(self.__run_transaction_with_foreign_keys_disabled, fun, *args, **kwargs) + ) - def __run_transaction_no_fk(self, fun: Callable[[sqlite3.Connection, Any, Any], Any], *args, **kwargs): + def __run_transaction_with_foreign_keys_disabled(self, fun: Callable[[sqlite3.Connection, Any, Any], Any], *args, + **kwargs): + foreign_keys_enabled, = self.connection.execute("pragma foreign_keys").fetchone() + if not foreign_keys_enabled: + raise sqlite3.IntegrityError("foreign keys are disabled, use `AIOSQLite.run` instead") try: self.connection.execute('pragma foreign_keys=off') self.connection.commit() - try: - self.connection.execute('begin') - result = fun(self.connection, *args, **kwargs) # type: ignore - self.connection.commit() - return result - except (Exception, OSError): # as e: - self.connection.rollback() - raise + return self.__run_transaction(fun, *args, **kwargs) finally: self.connection.execute('pragma foreign_keys=on') self.connection.commit() From 45c6ad3f6d214c86d1eff3c59999d8be4feef5d0 Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Wed, 13 Feb 2019 22:38:07 -0500 Subject: [PATCH 308/383] remove commits after pragma --- torba/client/basedatabase.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 77a2bb647..3ed0fcae9 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -79,11 +79,9 @@ class AIOSQLite: raise sqlite3.IntegrityError("foreign keys are disabled, use `AIOSQLite.run` instead") try: self.connection.execute('pragma foreign_keys=off') - self.connection.commit() return self.__run_transaction(fun, *args, **kwargs) finally: self.connection.execute('pragma foreign_keys=on') - self.connection.commit() def constraints_to_sql(constraints, joiner=' AND ', prepend_key=''): From 09726876ada936b3d65311e9629d461ab24be9b2 Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Wed, 13 Feb 2019 22:42:29 -0500 Subject: [PATCH 309/383] pylint --- torba/client/basedatabase.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 3ed0fcae9..ac4c252b2 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -72,8 +72,9 @@ class AIOSQLite: self.executor.submit(self.__run_transaction_with_foreign_keys_disabled, fun, *args, **kwargs) ) - def __run_transaction_with_foreign_keys_disabled(self, fun: Callable[[sqlite3.Connection, Any, Any], Any], *args, - **kwargs): + def __run_transaction_with_foreign_keys_disabled(self, + fun: Callable[[sqlite3.Connection, Any, Any], Any], + *args, **kwargs): foreign_keys_enabled, = self.connection.execute("pragma foreign_keys").fetchone() if not foreign_keys_enabled: raise sqlite3.IntegrityError("foreign keys are disabled, use `AIOSQLite.run` instead") From 4eff0d26608281652e0f81617239199837225aa0 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 22 Feb 2019 19:25:27 -0500 Subject: [PATCH 310/383] only install plyvel on linux --- setup.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/setup.py b/setup.py index 075bd0c8f..10be21d2a 100644 --- a/setup.py +++ b/setup.py @@ -14,11 +14,10 @@ REQUIRES = [ 'pbkdf2', 'cryptography', 'attrs', - 'plyvel', 'pylru' ] -if sys.platform.startswith('win32'): - REQUIRES.remove('plyvel') +if sys.platform.startswith('linux'): + REQUIRES.append('plyvel') setup( From 9e4c1120fad505e7d90d6a1eec40e3e40f8a14cf Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 22 Feb 2019 19:26:03 -0500 Subject: [PATCH 311/383] 0.3.2 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index b3f7f9e86..32bd9f40d 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.3.0' +__version__ = '0.3.2' From bd2512c27ebfa899b50d65c0c68c7e4592cb75f7 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 26 Feb 2019 15:33:14 -0500 Subject: [PATCH 312/383] pin dependency versions --- setup.py | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/setup.py b/setup.py index 10be21d2a..029b83209 100644 --- a/setup.py +++ b/setup.py @@ -9,15 +9,16 @@ with open(os.path.join(BASE, 'README.md'), encoding='utf-8') as fh: long_description = fh.read() REQUIRES = [ - 'aiohttp', - 'coincurve', - 'pbkdf2', - 'cryptography', - 'attrs', - 'pylru' + 'aiohttp==3.4.4', + 'cffi==1.12.1', # TODO: 1.12.2 fails on travis in wine + 'coincurve==11.0.0', + 'pbkdf2==1.3', + 'cryptography==2.5', + 'attrs==18.2.0', + 'pylru==1.1.0' ] if sys.platform.startswith('linux'): - REQUIRES.append('plyvel') + REQUIRES.append('plyvel==1.0.5') setup( From 589768864aaa5d310fcde447187cd9035510a0ba Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 26 Feb 2019 15:38:37 -0500 Subject: [PATCH 313/383] try latest mypy and aiohttp --- .travis.yml | 2 +- setup.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 63ae9794d..8fe7ff2fc 100644 --- a/.travis.yml +++ b/.travis.yml @@ -9,7 +9,7 @@ jobs: - stage: code quality name: "pylint & mypy" install: - - pip install astroid==2.0.4 aiohttp==3.4.4 + #- pip install astroid==2.0.4 aiohttp==3.4.4 # newer astroid and aiohttp fails in pylint so we pre-install older version - pip install pylint mypy - pip install -e . diff --git a/setup.py b/setup.py index 029b83209..adee3235c 100644 --- a/setup.py +++ b/setup.py @@ -9,7 +9,7 @@ with open(os.path.join(BASE, 'README.md'), encoding='utf-8') as fh: long_description = fh.read() REQUIRES = [ - 'aiohttp==3.4.4', + 'aiohttp',#==3.4.4', 'cffi==1.12.1', # TODO: 1.12.2 fails on travis in wine 'coincurve==11.0.0', 'pbkdf2==1.3', From f8d24d34021a739ded5e7b9ac1256094984d1539 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 26 Feb 2019 15:43:20 -0500 Subject: [PATCH 314/383] older aiohttp but newer astroid --- .travis.yml | 2 +- setup.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 8fe7ff2fc..0119a03ca 100644 --- a/.travis.yml +++ b/.travis.yml @@ -9,7 +9,7 @@ jobs: - stage: code quality name: "pylint & mypy" install: - #- pip install astroid==2.0.4 aiohttp==3.4.4 + #- pip install astroid==2.0.4 # newer astroid and aiohttp fails in pylint so we pre-install older version - pip install pylint mypy - pip install -e . diff --git a/setup.py b/setup.py index adee3235c..7460ef845 100644 --- a/setup.py +++ b/setup.py @@ -9,7 +9,7 @@ with open(os.path.join(BASE, 'README.md'), encoding='utf-8') as fh: long_description = fh.read() REQUIRES = [ - 'aiohttp',#==3.4.4', + 'aiohttp==3.4.4', # more recent version of aiohttp break with pylint/astroid 'cffi==1.12.1', # TODO: 1.12.2 fails on travis in wine 'coincurve==11.0.0', 'pbkdf2==1.3', From b86d2e6e7309b0ad5b1c106eaaea0fcca3ad16f5 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 26 Feb 2019 15:46:47 -0500 Subject: [PATCH 315/383] use older astroid for pylint --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 0119a03ca..373466211 100644 --- a/.travis.yml +++ b/.travis.yml @@ -9,7 +9,7 @@ jobs: - stage: code quality name: "pylint & mypy" install: - #- pip install astroid==2.0.4 + - pip install astroid==2.0.4 # newer astroid and aiohttp fails in pylint so we pre-install older version - pip install pylint mypy - pip install -e . From 569ac502edddd5bba63a0d66183256f12a1cbfb5 Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Thu, 28 Feb 2019 11:56:39 -0500 Subject: [PATCH 316/383] update aiohttp and astroid requirement pylint 2.3.0 fixes aiohttp failure --- .travis.yml | 2 -- setup.py | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 373466211..1e5893468 100644 --- a/.travis.yml +++ b/.travis.yml @@ -9,8 +9,6 @@ jobs: - stage: code quality name: "pylint & mypy" install: - - pip install astroid==2.0.4 - # newer astroid and aiohttp fails in pylint so we pre-install older version - pip install pylint mypy - pip install -e . script: diff --git a/setup.py b/setup.py index 7460ef845..784a27a80 100644 --- a/setup.py +++ b/setup.py @@ -9,7 +9,7 @@ with open(os.path.join(BASE, 'README.md'), encoding='utf-8') as fh: long_description = fh.read() REQUIRES = [ - 'aiohttp==3.4.4', # more recent version of aiohttp break with pylint/astroid + 'aiohttp==3.5.4', 'cffi==1.12.1', # TODO: 1.12.2 fails on travis in wine 'coincurve==11.0.0', 'pbkdf2==1.3', From a79be0513bfb845e13ae50171967742af20c0e2f Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Thu, 28 Feb 2019 12:00:44 -0500 Subject: [PATCH 317/383] pylint --- torba/client/basetransaction.py | 4 ++-- torba/orchstr8/node.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/torba/client/basetransaction.py b/torba/client/basetransaction.py index a022bfa2b..ff4582250 100644 --- a/torba/client/basetransaction.py +++ b/torba/client/basetransaction.py @@ -350,7 +350,7 @@ class BaseTransaction: "Cannot access net_account_balance if inputs/outputs do not " "have is_my_account set properly." ) - elif txi.is_my_account: + if txi.is_my_account: balance -= txi.amount for txo in self.outputs: if txo.is_my_account is None: @@ -358,7 +358,7 @@ class BaseTransaction: "Cannot access net_account_balance if inputs/outputs do not " "have is_my_account set properly." ) - elif txo.is_my_account: + if txo.is_my_account: balance += txo.amount return balance diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index e9113de8c..769504690 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -243,7 +243,7 @@ class BlockchainProcess(asyncio.SubprocessProtocol): if b'Error:' in data: self.ready.set() raise SystemError(data.decode()) - elif b'Done loading' in data: + if b'Done loading' in data: self.ready.set() def process_exited(self): From b07ca20e0e764140d8a19f0c0c6a6665265cb7a0 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 11 Mar 2019 12:04:06 -0400 Subject: [PATCH 318/383] working sync --- torba/client/baseaccount.py | 27 +++++++++++++++++++-------- torba/client/hash.py | 21 ++++++++++++++++++++- torba/client/wallet.py | 24 +++++++++++++++++++++++- 3 files changed, 62 insertions(+), 10 deletions(-) diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index 86d1d0d7d..c7cab4d55 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -1,3 +1,4 @@ +import json import asyncio import random import typing @@ -5,7 +6,7 @@ from typing import Dict, Tuple, Type, Optional, Any, List from torba.client.mnemonic import Mnemonic from torba.client.bip32 import PrivateKey, PubKey, from_extended_key_string -from torba.client.hash import aes_encrypt, aes_decrypt +from torba.client.hash import aes_encrypt, aes_decrypt, sha256 from torba.client.constants import COIN if typing.TYPE_CHECKING: @@ -235,7 +236,8 @@ class BaseAccount: ) @classmethod - def from_dict(cls, ledger: 'baseledger.BaseLedger', wallet: 'basewallet.Wallet', d: dict): + def keys_from_dict(cls, ledger: 'baseledger.BaseLedger', d: dict) \ + -> Tuple[str, Optional[PrivateKey], PubKey]: seed = d.get('seed', '') private_key_string = d.get('private_key', '') private_key = None @@ -250,6 +252,11 @@ class BaseAccount: public_key = private_key.public_key if public_key is None: public_key = from_extended_key_string(ledger, d['public_key']) + return seed, private_key, public_key + + @classmethod + def from_dict(cls, ledger: 'baseledger.BaseLedger', wallet: 'basewallet.Wallet', d: dict): + seed, private_key, public_key = cls.keys_from_dict(ledger, d) name = d.get('name') if not name: name = 'Account #{}'.format(public_key.address) @@ -258,8 +265,8 @@ class BaseAccount: wallet=wallet, name=name, seed=seed, - private_key_string=private_key_string, - encrypted=encrypted, + private_key_string=d.get('private_key', ''), + encrypted=d.get('encrypted', False), private_key=private_key, public_key=public_key, address_generator=d.get('address_generator', {}) @@ -273,8 +280,8 @@ class BaseAccount: assert None not in [self.seed_encryption_init_vector, self.private_key_encryption_init_vector] private_key_string = aes_encrypt( self.password, private_key_string, self.private_key_encryption_init_vector - ) - seed = aes_encrypt(self.password, self.seed, self.seed_encryption_init_vector) + )[0] + seed = aes_encrypt(self.password, self.seed, self.seed_encryption_init_vector)[0] return { 'ledger': self.ledger.get_id(), 'name': self.name, @@ -285,6 +292,10 @@ class BaseAccount: 'address_generator': self.address_generator.to_dict(self.receiving, self.change) } + @property + def hash(self) -> bytes: + return sha256(json.dumps(self.to_dict()).encode()) + async def get_details(self, show_seed=False, **kwargs): satoshis = await self.get_balance(**kwargs) details = { @@ -329,10 +340,10 @@ class BaseAccount: assert not self.encrypted, "Key is already encrypted." assert isinstance(self.private_key, PrivateKey) - self.seed = aes_encrypt(password, self.seed, self.seed_encryption_init_vector) + self.seed = aes_encrypt(password, self.seed, self.seed_encryption_init_vector)[0] self.private_key_string = aes_encrypt( password, self.private_key.extended_key_string(), self.private_key_encryption_init_vector - ) + )[0] self.private_key = None self.password = None self.encrypted = True diff --git a/torba/client/hash.py b/torba/client/hash.py index dcd61a080..bb18ee57a 100644 --- a/torba/client/hash.py +++ b/torba/client/hash.py @@ -121,7 +121,7 @@ def hex_str_to_hash(x): return reversed(unhexlify(x)) -def aes_encrypt(secret: str, value: str, init_vector: bytes = None) -> str: +def aes_encrypt(secret: str, value: str, init_vector: bytes = None) -> typing.Tuple[str, bytes]: if init_vector is not None: assert len(init_vector) == 16 else: @@ -144,6 +144,25 @@ def aes_decrypt(secret: str, value: str) -> typing.Tuple[str, bytes]: return result.decode(), init_vector +def better_aes_encrypt(secret: str, value: bytes) -> bytes: + init_vector = os.urandom(16) + key = double_sha256(secret.encode()) + encryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).encryptor() + padder = PKCS7(AES.block_size).padder() + padded_data = padder.update(value) + padder.finalize() + encrypted_data = encryptor.update(padded_data) + encryptor.finalize() + return base64.b64encode(init_vector + encrypted_data) + + +def better_aes_decrypt(secret: str, value: bytes) -> bytes: + data = base64.b64decode(value) + key = double_sha256(secret.encode()) + init_vector, data = data[:16], data[16:] + decryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).decryptor() + unpadder = PKCS7(AES.block_size).unpadder() + return unpadder.update(decryptor.update(data)) + unpadder.finalize() + + class Base58Error(Exception): """ Exception used for Base58 errors. """ diff --git a/torba/client/wallet.py b/torba/client/wallet.py index 66dc23252..166891899 100644 --- a/torba/client/wallet.py +++ b/torba/client/wallet.py @@ -1,8 +1,12 @@ +import os import stat import json -import os +import zlib import typing +from hashlib import sha256 from typing import Sequence, MutableSequence +from torba.client.hash import better_aes_encrypt, better_aes_decrypt +from operator import attrgetter if typing.TYPE_CHECKING: from torba.client import basemanager, baseaccount, baseledger @@ -55,6 +59,24 @@ class Wallet: for account in self.accounts: return account + @property + def hash(self) -> str: + h = sha256() + for account in sorted(self.accounts, key=attrgetter('id')): + h.update(account.hash) + return h.digest() + + def pack(self, password): + new_data = json.dumps(self.to_dict()) + new_data_compressed = zlib.compress(new_data.encode()) + return better_aes_encrypt(password, new_data_compressed) + + @classmethod + def unpack(cls, password, encrypted): + decrypted = better_aes_decrypt(password, encrypted) + decompressed = zlib.decompress(decrypted) + return json.loads(decompressed) + class WalletStorage: From d9df2ead84c5a3317848f9a4b86a3e65b7d4d469 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 11 Mar 2019 12:12:26 -0400 Subject: [PATCH 319/383] pylint fixes --- torba/client/wallet.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torba/client/wallet.py b/torba/client/wallet.py index 166891899..e3bd604bf 100644 --- a/torba/client/wallet.py +++ b/torba/client/wallet.py @@ -3,10 +3,10 @@ import stat import json import zlib import typing -from hashlib import sha256 from typing import Sequence, MutableSequence -from torba.client.hash import better_aes_encrypt, better_aes_decrypt +from hashlib import sha256 from operator import attrgetter +from torba.client.hash import better_aes_encrypt, better_aes_decrypt if typing.TYPE_CHECKING: from torba.client import basemanager, baseaccount, baseledger From 7979f0a68372ef4fed30ae083e88dea7e351e5e8 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 11 Mar 2019 12:26:24 -0400 Subject: [PATCH 320/383] typing fix --- torba/client/hash.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/client/hash.py b/torba/client/hash.py index bb18ee57a..9b0e94f73 100644 --- a/torba/client/hash.py +++ b/torba/client/hash.py @@ -121,7 +121,7 @@ def hex_str_to_hash(x): return reversed(unhexlify(x)) -def aes_encrypt(secret: str, value: str, init_vector: bytes = None) -> typing.Tuple[str, bytes]: +def aes_encrypt(secret: str, value: str, init_vector: bytes = None) -> str: if init_vector is not None: assert len(init_vector) == 16 else: From f655fefe52fc69e6d4165213faad35c0df48c4a0 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 11 Mar 2019 12:30:32 -0400 Subject: [PATCH 321/383] typing fix --- torba/client/wallet.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/client/wallet.py b/torba/client/wallet.py index e3bd604bf..0496a99ed 100644 --- a/torba/client/wallet.py +++ b/torba/client/wallet.py @@ -60,7 +60,7 @@ class Wallet: return account @property - def hash(self) -> str: + def hash(self) -> bytes: h = sha256() for account in sorted(self.accounts, key=attrgetter('id')): h.update(account.hash) From fcac4f148832d86a5186535f215b298ffecaad1e Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 11 Mar 2019 13:57:51 -0400 Subject: [PATCH 322/383] fix encrypt --- torba/client/baseaccount.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index c7cab4d55..f77c59836 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -280,8 +280,8 @@ class BaseAccount: assert None not in [self.seed_encryption_init_vector, self.private_key_encryption_init_vector] private_key_string = aes_encrypt( self.password, private_key_string, self.private_key_encryption_init_vector - )[0] - seed = aes_encrypt(self.password, self.seed, self.seed_encryption_init_vector)[0] + ) + seed = aes_encrypt(self.password, self.seed, self.seed_encryption_init_vector) return { 'ledger': self.ledger.get_id(), 'name': self.name, @@ -340,10 +340,10 @@ class BaseAccount: assert not self.encrypted, "Key is already encrypted." assert isinstance(self.private_key, PrivateKey) - self.seed = aes_encrypt(password, self.seed, self.seed_encryption_init_vector)[0] + self.seed = aes_encrypt(password, self.seed, self.seed_encryption_init_vector) self.private_key_string = aes_encrypt( password, self.private_key.extended_key_string(), self.private_key_encryption_init_vector - )[0] + ) self.private_key = None self.password = None self.encrypted = True From 1286417aec2d0958556d659db99c6346fe4f3f48 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Mon, 11 Mar 2019 17:55:56 -0300 Subject: [PATCH 323/383] apply scrypt as kdf, add tests --- tests/client_tests/unit/test_hash.py | 9 ++++++++- torba/client/hash.py | 13 ++++++++++--- 2 files changed, 18 insertions(+), 4 deletions(-) diff --git a/tests/client_tests/unit/test_hash.py b/tests/client_tests/unit/test_hash.py index 4b3a8de5c..19ad79249 100644 --- a/tests/client_tests/unit/test_hash.py +++ b/tests/client_tests/unit/test_hash.py @@ -1,5 +1,5 @@ from unittest import TestCase, mock -from torba.client.hash import aes_decrypt, aes_encrypt +from torba.client.hash import aes_decrypt, aes_encrypt, better_aes_decrypt, better_aes_encrypt class TestAESEncryptDecrypt(TestCase): @@ -33,3 +33,10 @@ class TestAESEncryptDecrypt(TestCase): aes_decrypt('bubblegum', aes_encrypt('bubblegum', self.message))[0], self.message ) + + def test_better_encrypt_decrypt(self): + self.assertEqual( + b'valuable value', + better_aes_decrypt( + 'super secret', + better_aes_encrypt('super secret', b'valuable value'))) diff --git a/torba/client/hash.py b/torba/client/hash.py index 9b0e94f73..cb2a17696 100644 --- a/torba/client/hash.py +++ b/torba/client/hash.py @@ -14,6 +14,7 @@ import hashlib import hmac import typing from binascii import hexlify, unhexlify +from cryptography.hazmat.primitives.kdf.scrypt import Scrypt from cryptography.hazmat.primitives.ciphers import Cipher, modes from cryptography.hazmat.primitives.ciphers.algorithms import AES from cryptography.hazmat.primitives.padding import PKCS7 @@ -146,23 +147,29 @@ def aes_decrypt(secret: str, value: str) -> typing.Tuple[str, bytes]: def better_aes_encrypt(secret: str, value: bytes) -> bytes: init_vector = os.urandom(16) - key = double_sha256(secret.encode()) + key = scrypt(secret.encode(), salt=init_vector) encryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).encryptor() padder = PKCS7(AES.block_size).padder() padded_data = padder.update(value) + padder.finalize() encrypted_data = encryptor.update(padded_data) + encryptor.finalize() - return base64.b64encode(init_vector + encrypted_data) + return base64.b64encode(b's:8192:16:1:' + init_vector + encrypted_data) def better_aes_decrypt(secret: str, value: bytes) -> bytes: data = base64.b64decode(value) - key = double_sha256(secret.encode()) + type, n, r, p, data = data.split(b':', maxsplit=4) init_vector, data = data[:16], data[16:] + key = scrypt(secret.encode(), salt=init_vector, n=int(n), r=int(r), p=int(p)) decryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).decryptor() unpadder = PKCS7(AES.block_size).unpadder() return unpadder.update(decryptor.update(data)) + unpadder.finalize() +def scrypt(passphrase, salt, n=1<<13, r=16, p=1): + kdf = Scrypt(salt, length=32, n=n, r=r, p=p, backend=default_backend()) + return kdf.derive(passphrase) + + class Base58Error(Exception): """ Exception used for Base58 errors. """ From cdd25e3b0fbd661a9d78962344d0a1627f0276a1 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Mon, 11 Mar 2019 21:12:04 -0300 Subject: [PATCH 324/383] pylint --- torba/client/hash.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/torba/client/hash.py b/torba/client/hash.py index cb2a17696..e25bfff11 100644 --- a/torba/client/hash.py +++ b/torba/client/hash.py @@ -157,16 +157,16 @@ def better_aes_encrypt(secret: str, value: bytes) -> bytes: def better_aes_decrypt(secret: str, value: bytes) -> bytes: data = base64.b64decode(value) - type, n, r, p, data = data.split(b':', maxsplit=4) + _, scryp_n, scrypt_r, scrypt_p, data = data.split(b':', maxsplit=4) init_vector, data = data[:16], data[16:] - key = scrypt(secret.encode(), salt=init_vector, n=int(n), r=int(r), p=int(p)) + key = scrypt(secret.encode(), init_vector, int(scryp_n), int(scrypt_r), int(scrypt_p)) decryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).decryptor() unpadder = PKCS7(AES.block_size).unpadder() return unpadder.update(decryptor.update(data)) + unpadder.finalize() -def scrypt(passphrase, salt, n=1<<13, r=16, p=1): - kdf = Scrypt(salt, length=32, n=n, r=r, p=p, backend=default_backend()) +def scrypt(passphrase, salt, scrypt_n=1<<13, scrypt_r=16, scrypt_p=1): + kdf = Scrypt(salt, length=32, n=scrypt_n, r=scrypt_r, p=scrypt_p, backend=default_backend()) return kdf.derive(passphrase) From a021ddeffd8fc67dc48cbc944b0eb1e4187b02b4 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 11 Mar 2019 22:24:57 -0400 Subject: [PATCH 325/383] + account.modified_on --- tests/client_tests/unit/test_account.py | 2 ++ tests/client_tests/unit/test_wallet.py | 9 +++++++++ torba/client/baseaccount.py | 10 +++++++--- 3 files changed, 18 insertions(+), 3 deletions(-) diff --git a/tests/client_tests/unit/test_account.py b/tests/client_tests/unit/test_account.py index b6a6d6895..8c451d2a6 100644 --- a/tests/client_tests/unit/test_account.py +++ b/tests/client_tests/unit/test_account.py @@ -143,6 +143,7 @@ class TestHierarchicalDeterministicAccount(AsyncioTestCase): async def test_load_and_save_account(self): account_data = { 'name': 'My Account', + 'modified_on': 123.456, 'seed': "carbon smart garage balance margin twelve chest sword toast envelope bottom stomac" "h absent", @@ -302,6 +303,7 @@ class TestSingleKeyAccount(AsyncioTestCase): async def test_load_and_save_account(self): account_data = { 'name': 'My Account', + 'modified_on': 123.456, 'seed': "carbon smart garage balance margin twelve chest sword toast envelope bottom stomac" "h absent", diff --git a/tests/client_tests/unit/test_wallet.py b/tests/client_tests/unit/test_wallet.py index d61490c44..afe8ea14f 100644 --- a/tests/client_tests/unit/test_wallet.py +++ b/tests/client_tests/unit/test_wallet.py @@ -1,4 +1,5 @@ import tempfile +from binascii import hexlify from torba.testcase import AsyncioTestCase @@ -35,6 +36,7 @@ class TestWalletCreation(AsyncioTestCase): { 'name': 'An Account', 'ledger': 'btc_mainnet', + 'modified_on': 123.456, 'seed': "carbon smart garage balance margin twelve chest sword toast envelope bottom stomac" "h absent", @@ -57,12 +59,19 @@ class TestWalletCreation(AsyncioTestCase): storage = WalletStorage(default=wallet_dict) wallet = Wallet.from_storage(storage, self.manager) self.assertEqual(wallet.name, 'Main Wallet') + self.assertEqual( + hexlify(wallet.hash), b'9f462b8dd802eb8c913e54f09a09827ebc14abbc13f33baa90d8aec5ae920fc7' + ) self.assertEqual(len(wallet.accounts), 1) account = wallet.default_account self.assertIsInstance(account, BTCLedger.account_class) self.maxDiff = None self.assertDictEqual(wallet_dict, wallet.to_dict()) + encrypted = wallet.pack('password') + decrypted = Wallet.unpack('password', encrypted) + self.assertEqual(decrypted['accounts'][0]['name'], 'An Account') + def test_read_write(self): manager = BaseWalletManager() config = {'data_path': '/tmp/wallet'} diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index f77c59836..fac1276b3 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -1,4 +1,5 @@ import json +import time import asyncio import random import typing @@ -198,12 +199,13 @@ class BaseAccount: def __init__(self, ledger: 'baseledger.BaseLedger', wallet: 'basewallet.Wallet', name: str, seed: str, private_key_string: str, encrypted: bool, private_key: Optional[PrivateKey], public_key: PubKey, - address_generator: dict) -> None: + address_generator: dict, modified_on: float) -> None: self.ledger = ledger self.wallet = wallet self.id = public_key.address self.name = name self.seed = seed + self.modified_on = modified_on self.private_key_string = private_key_string self.password: Optional[str] = None self.private_key_encryption_init_vector: Optional[bytes] = None @@ -269,7 +271,8 @@ class BaseAccount: encrypted=d.get('encrypted', False), private_key=private_key, public_key=public_key, - address_generator=d.get('address_generator', {}) + address_generator=d.get('address_generator', {}), + modified_on=d.get('modified_on', time.time()) ) def to_dict(self): @@ -289,7 +292,8 @@ class BaseAccount: 'encrypted': self.serialize_encrypted, 'private_key': private_key_string, 'public_key': self.public_key.extended_key_string(), - 'address_generator': self.address_generator.to_dict(self.receiving, self.change) + 'address_generator': self.address_generator.to_dict(self.receiving, self.change), + 'modified_on': self.modified_on } @property From c44de4848129be54052fa5c42626faf31d043526 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 12 Mar 2019 13:19:17 -0400 Subject: [PATCH 326/383] + account.apply and addressmanager.apply --- tests/client_tests/unit/test_account.py | 48 +++++++++++++++++++++++++ torba/client/baseaccount.py | 17 +++++++++ 2 files changed, 65 insertions(+) diff --git a/tests/client_tests/unit/test_account.py b/tests/client_tests/unit/test_account.py index 8c451d2a6..7ca2cf33a 100644 --- a/tests/client_tests/unit/test_account.py +++ b/tests/client_tests/unit/test_account.py @@ -174,6 +174,54 @@ class TestHierarchicalDeterministicAccount(AsyncioTestCase): account_data['ledger'] = 'btc_mainnet' self.assertDictEqual(account_data, account.to_dict()) + def test_apply_diff(self): + account_data = { + 'name': 'My Account', + 'modified_on': 123.456, + 'seed': + "carbon smart garage balance margin twelve chest sword toast envelope bottom stomac" + "h absent", + 'encrypted': False, + 'private_key': + 'xprv9s21ZrQH143K3TsAz5efNV8K93g3Ms3FXcjaWB9fVUsMwAoE3ZT4vYymkp' + '5BxKKfnpz8J6sHDFriX1SnpvjNkzcks8XBnxjGLS83BTyfpna', + 'public_key': + 'xpub661MyMwAqRbcFwwe67Bfjd53h5WXmKm6tqfBJZZH3pQLoy8Nb6mKUMJFc7' + 'UbpVNzmwFPN2evn3YHnig1pkKVYcvCV8owTd2yAcEkJfCX53g', + 'address_generator': { + 'name': 'deterministic-chain', + 'receiving': {'gap': 5, 'maximum_uses_per_address': 2}, + 'change': {'gap': 5, 'maximum_uses_per_address': 2} + } + } + account = self.ledger.account_class.from_dict(self.ledger, Wallet(), account_data) + + self.assertEqual(account.name, 'My Account') + self.assertEqual(account.modified_on, 123.456) + self.assertEqual(account.change.gap, 5) + self.assertEqual(account.change.maximum_uses_per_address, 2) + self.assertEqual(account.receiving.gap, 5) + self.assertEqual(account.receiving.maximum_uses_per_address, 2) + + account_data['name'] = 'Changed Name' + account_data['address_generator']['change']['gap'] = 6 + account_data['address_generator']['change']['maximum_uses_per_address'] = 7 + account_data['address_generator']['receiving']['gap'] = 8 + account_data['address_generator']['receiving']['maximum_uses_per_address'] = 9 + + account.apply(account_data) + # no change because modified_on is not newer + self.assertEqual(account.name, 'My Account') + + account_data['modified_on'] = 200.00 + + account.apply(account_data) + self.assertEqual(account.name, 'Changed Name') + self.assertEqual(account.change.gap, 6) + self.assertEqual(account.change.maximum_uses_per_address, 7) + self.assertEqual(account.receiving.gap, 8) + self.assertEqual(account.receiving.maximum_uses_per_address, 9) + class TestSingleKeyAccount(AsyncioTestCase): diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index fac1276b3..896bc3840 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -42,6 +42,9 @@ class AddressManager: d['change'] = change_dict return d + def apply(self, d: dict): + raise NotImplementedError + def to_dict_instance(self) -> Optional[dict]: raise NotImplementedError @@ -95,6 +98,10 @@ class HierarchicalDeterministic(AddressManager): cls(account, 1, **d.get('change', {'gap': 6, 'maximum_uses_per_address': 1})) ) + def apply(self, d: dict): + self.gap = d.get('gap', self.gap) + self.maximum_uses_per_address = d.get('maximum_uses_per_address', self.maximum_uses_per_address) + def to_dict_instance(self): return {'gap': self.gap, 'maximum_uses_per_address': self.maximum_uses_per_address} @@ -296,6 +303,16 @@ class BaseAccount: 'modified_on': self.modified_on } + def apply(self, d: dict): + if d.get('modified_on', 0) > self.modified_on: + self.name = d['name'] + self.modified_on = d.get('modified_on', time.time()) + assert self.address_generator.name == d['address_generator']['name'] + for chain_name in ('change', 'receiving'): + if chain_name in d['address_generator']: + chain_object = getattr(self, chain_name) + chain_object.apply(d['address_generator'][chain_name]) + @property def hash(self) -> bytes: return sha256(json.dumps(self.to_dict()).encode()) From 27558ffd890b4ad66846dec11ff74bf7b1fb58f6 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 12 Mar 2019 13:33:28 -0400 Subject: [PATCH 327/383] implement abstract method for pylint --- torba/client/baseaccount.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index 896bc3840..581fe1459 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -168,6 +168,9 @@ class SingleKey(AddressManager): same_address_manager = cls(account, account.public_key, 0) return same_address_manager, same_address_manager + def apply(self, d: dict): + pass + def to_dict_instance(self): return None From 4ba90a727b63d79dc0d9c25b3e576cd2ced0bf76 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 12 Mar 2019 13:56:38 -0400 Subject: [PATCH 328/383] make apply not abstract --- torba/client/baseaccount.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index 581fe1459..9851582cd 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -43,7 +43,7 @@ class AddressManager: return d def apply(self, d: dict): - raise NotImplementedError + pass def to_dict_instance(self) -> Optional[dict]: raise NotImplementedError @@ -168,9 +168,6 @@ class SingleKey(AddressManager): same_address_manager = cls(account, account.public_key, 0) return same_address_manager, same_address_manager - def apply(self, d: dict): - pass - def to_dict_instance(self): return None From 61a254f58094ac13d5e516f82157f5913b017c8b Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 12 Mar 2019 15:36:24 -0400 Subject: [PATCH 329/383] 0.4.0 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 32bd9f40d..65ca0062a 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.3.2' +__version__ = '0.4.0' From 80b65ae7e746645568a1d3b16abcd0e344629be6 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 18 Mar 2019 18:13:49 -0400 Subject: [PATCH 330/383] OP_0 can be an OP but also an empty string, figure this out contextually in parser --- torba/client/basescript.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/torba/client/basescript.py b/torba/client/basescript.py index 3b8b43783..e452a4b3f 100644 --- a/torba/client/basescript.py +++ b/torba/client/basescript.py @@ -158,6 +158,8 @@ class Parser: while self.token_index < len(self.tokens) and self.opcode_index < len(self.opcodes): token = self.tokens[self.token_index] opcode = self.opcodes[self.opcode_index] + if token.value == 0 and isinstance(opcode, PUSH_SINGLE): + token = DataToken(b'') if isinstance(token, DataToken): if isinstance(opcode, (PUSH_SINGLE, PUSH_INTEGER, PUSH_SUBSCRIPT)): self.push_single(opcode, token.value) From 9281bdb61b3d4acb9d1178e5fa9234867d41b1b7 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 18 Mar 2019 23:25:00 -0400 Subject: [PATCH 331/383] lazy parse scripts --- torba/client/basescript.py | 29 ++++++++++++++++++++--------- 1 file changed, 20 insertions(+), 9 deletions(-) diff --git a/torba/client/basescript.py b/torba/client/basescript.py index e452a4b3f..a849a9346 100644 --- a/torba/client/basescript.py +++ b/torba/client/basescript.py @@ -284,19 +284,30 @@ class Template: class Script: - __slots__ = 'source', 'template', 'values' + __slots__ = 'source', '_template', '_values', '_template_hint' templates: List[Template] = [] def __init__(self, source=None, template=None, values=None, template_hint=None): self.source = source - self.template = template - self.values = values - if source: - self.parse(template_hint) - elif template and values: + self._template = template + self._values = values + self._template_hint = template_hint + if source is None and template and values: self.generate() + @property + def template(self): + if self._template is None: + self.parse(self._template_hint) + return self._template + + @property + def values(self): + if self._values is None: + self.parse(self._template_hint) + return self._values + @property def tokens(self): return tokenize(BCDataStream(self.source)) @@ -311,15 +322,15 @@ class Script: if not template: continue try: - self.values = template.parse(tokens) - self.template = template + self._values = template.parse(tokens) + self._template = template return except ParseError: continue raise ValueError('No matching templates for source: {}'.format(hexlify(self.source))) def generate(self): - self.source = self.template.generate(self.values) + self.source = self.template.generate(self._values) class BaseInputScript(Script): From ca4a07f766f7c59e200346bd257de2caf956e9e0 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 20 Mar 2019 01:36:30 -0400 Subject: [PATCH 332/383] ledger.is_valid_address added --- torba/client/baseledger.py | 5 +++++ torba/client/basescript.py | 2 +- torba/testcase.py | 2 ++ 3 files changed, 8 insertions(+), 1 deletion(-) diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index 721236e07..1f35fb2eb 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -153,6 +153,11 @@ class BaseLedger(metaclass=LedgerRegistry): def address_to_hash160(address): return Base58.decode(address)[1:21] + @classmethod + def is_valid_address(cls, address): + decoded = Base58.decode(address) + return decoded[0] == cls.pubkey_address_prefix + @classmethod def public_key_to_address(cls, public_key): return cls.hash160_to_address(hash160(public_key)) diff --git a/torba/client/basescript.py b/torba/client/basescript.py index a849a9346..560525c09 100644 --- a/torba/client/basescript.py +++ b/torba/client/basescript.py @@ -64,7 +64,7 @@ def push_data(data): else: yield BCDataStream.uint8.pack(OP_PUSHDATA4) yield BCDataStream.uint32.pack(size) - yield data + yield bytes(data) def read_data(token, stream): diff --git a/torba/testcase.py b/torba/testcase.py index 7e3913bb8..42390ee07 100644 --- a/torba/testcase.py +++ b/torba/testcase.py @@ -61,6 +61,8 @@ class AsyncioTestCase(unittest.TestCase): # Implementation inspired by discussion: # https://bugs.python.org/issue32972 + maxDiff = None + async def asyncSetUp(self): # pylint: disable=C0103 pass From 38ae660a68c62d93d799a44aa4096470b2c593ae Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Wed, 20 Mar 2019 13:56:53 -0300 Subject: [PATCH 333/383] add hash property to txoref --- torba/client/basetransaction.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/torba/client/basetransaction.py b/torba/client/basetransaction.py index ff4582250..2e6c441d8 100644 --- a/torba/client/basetransaction.py +++ b/torba/client/basetransaction.py @@ -53,6 +53,10 @@ class TXORef: self.tx_ref = tx_ref self.position = position + @property + def hash(self): + return self.tx_ref.hash + @property def id(self): return '{}:{}'.format(self.tx_ref.id, self.position) From cfa74985e05881e8159468ff8ca0d4c06299987c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 20 Mar 2019 14:17:14 -0400 Subject: [PATCH 334/383] Revert "add hash property to txoref" This reverts commit 38ae660a68c62d93d799a44aa4096470b2c593ae. --- torba/client/basetransaction.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/torba/client/basetransaction.py b/torba/client/basetransaction.py index 2e6c441d8..ff4582250 100644 --- a/torba/client/basetransaction.py +++ b/torba/client/basetransaction.py @@ -53,10 +53,6 @@ class TXORef: self.tx_ref = tx_ref self.position = position - @property - def hash(self): - return self.tx_ref.hash - @property def id(self): return '{}:{}'.format(self.tx_ref.id, self.position) From 9589ac6d023446aaeab2d3306816e94a8e4492a0 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 22 Mar 2019 03:03:48 -0400 Subject: [PATCH 335/383] include tx in db get_txos() --- torba/client/basedatabase.py | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index ac4c252b2..c36626e53 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -444,19 +444,16 @@ class BaseDatabase(SQLiteMixin): if 'order_by' not in constraints: constraints['order_by'] = ["tx.height=0 DESC", "tx.height DESC", "tx.position DESC"] rows = await self.select_txos( - "amount, script, txid, tx.height, txo.position, chain, account", **constraints + "raw, txo.position, chain, account", **constraints ) - output_class = self.ledger.transaction_class.output_class - return [ - output_class( - amount=row[0], - script=output_class.script_class(row[1]), - tx_ref=TXRefImmutable.from_id(row[2], row[3]), - position=row[4], - is_change=row[5] == 1, - is_my_account=row[6] == my_account - ) for row in rows - ] + txos = [] + for row in rows: + tx = self.ledger.transaction_class(row[0]) + txo = tx.outputs[row[1]] + txo.is_change = row[2] == 1 + txo.is_my_account = row[3] == my_account + txos.append(txo) + return txos async def get_txo_count(self, **constraints): constraints.pop('offset', None) From 9ff41f748e1f6e64b192325044289bf419fe2d7c Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 24 Mar 2019 17:09:55 -0400 Subject: [PATCH 336/383] upgrades --- torba/client/baseaccount.py | 4 +--- torba/client/basedatabase.py | 1 - torba/client/baseledger.py | 3 +++ torba/client/basetransaction.py | 11 +++++++---- torba/client/errors.py | 2 ++ 5 files changed, 13 insertions(+), 8 deletions(-) create mode 100644 torba/client/errors.py diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index 9851582cd..5864655c2 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -447,8 +447,6 @@ class BaseAccount: if broadcast: await self.ledger.broadcast(tx) else: - await self.ledger.release_outputs( - [txi.txo_ref.txo for txi in tx.inputs] - ) + await self.ledger.release_tx(tx) return tx diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index c36626e53..75f3cb991 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -7,7 +7,6 @@ from typing import Tuple, List, Union, Callable, Any, Awaitable, Iterable import sqlite3 -from torba.client.hash import TXRefImmutable from torba.client.basetransaction import BaseTransaction from torba.client.baseaccount import BaseAccount diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index 1f35fb2eb..7b543c258 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -206,6 +206,9 @@ class BaseLedger(metaclass=LedgerRegistry): def release_outputs(self, txos): return self.db.release_outputs(txos) + def release_tx(self, tx): + return self.release_outputs([txi.txo_ref.txo for txi in tx.inputs]) + async def get_local_status_and_history(self, address): address_details = await self.db.get_address(address=address) history = address_details['history'] or '' diff --git a/torba/client/basetransaction.py b/torba/client/basetransaction.py index ff4582250..358ea168c 100644 --- a/torba/client/basetransaction.py +++ b/torba/client/basetransaction.py @@ -9,6 +9,7 @@ from torba.client.constants import COIN, NULL_HASH32 from torba.client.bcd_data_stream import BCDataStream from torba.client.hash import sha256, TXRef, TXRefImmutable from torba.client.util import ReadOnlyList +from torba.client.errors import InsufficientFundsError if typing.TYPE_CHECKING: from torba.client import baseledger @@ -441,7 +442,8 @@ class BaseTransaction: @classmethod async def create(cls, inputs: Iterable[BaseInput], outputs: Iterable[BaseOutput], - funding_accounts: Iterable[BaseAccount], change_account: BaseAccount): + funding_accounts: Iterable[BaseAccount], change_account: BaseAccount, + sign: bool = True): """ Find optimal set of inputs when only outputs are provided; add change outputs if only inputs are provided or if inputs are greater than outputs. """ @@ -467,7 +469,7 @@ class BaseTransaction: deficit = cost - payment spendables = await ledger.get_spendable_utxos(deficit, funding_accounts) if not spendables: - raise ValueError('Not enough funds to cover this transaction.') + raise InsufficientFundsError('Not enough funds to cover this transaction.') payment += sum(s.effective_amount for s in spendables) tx.add_inputs(s.txi for s in spendables) @@ -500,11 +502,12 @@ class BaseTransaction: # less than the fee, after 5 attempts we give up and go home cost += cost_of_change + 1 - await tx.sign(funding_accounts) + if sign: + await tx.sign(funding_accounts) except Exception as e: log.exception('Failed to create transaction:') - await ledger.release_outputs(tx.outputs) + await ledger.release_tx(tx) raise e return tx diff --git a/torba/client/errors.py b/torba/client/errors.py new file mode 100644 index 000000000..cd290cf05 --- /dev/null +++ b/torba/client/errors.py @@ -0,0 +1,2 @@ +class InsufficientFundsError(Exception): + pass From 33ac9eea137a5391a3fdbb3145cef530a4f04d5f Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 24 Mar 2019 21:53:52 -0400 Subject: [PATCH 337/383] fix is_valid_address --- torba/client/baseledger.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index 7b543c258..740f91377 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -156,7 +156,7 @@ class BaseLedger(metaclass=LedgerRegistry): @classmethod def is_valid_address(cls, address): decoded = Base58.decode(address) - return decoded[0] == cls.pubkey_address_prefix + return decoded[0] == cls.pubkey_address_prefix[0] @classmethod def public_key_to_address(cls, public_key): From d7dadc2f0e8fc790e08738614e6e1cf012d5b453 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 25 Mar 2019 22:04:48 -0400 Subject: [PATCH 338/383] + __not_like db condition --- torba/client/basedatabase.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 75f3cb991..d914ce9d6 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -101,6 +101,8 @@ def constraints_to_sql(constraints, joiner=' AND ', prepend_key=''): col, op = col[:-len('__gt')], '>' elif key.endswith('__like'): col, op = col[:-len('__like')], 'LIKE' + elif key.endswith('__not_like'): + col, op = col[:-len('__not_like')], 'NOT LIKE' elif key.endswith('__in') or key.endswith('__not_in'): if key.endswith('__in'): col, op = col[:-len('__in')], 'IN' From aa93b94b61e2f1c287acebd863e1827345c7f939 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 25 Mar 2019 22:27:52 -0400 Subject: [PATCH 339/383] fix unit tests --- torba/client/basedatabase.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index d914ce9d6..d161c8120 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -445,14 +445,14 @@ class BaseDatabase(SQLiteMixin): if 'order_by' not in constraints: constraints['order_by'] = ["tx.height=0 DESC", "tx.height DESC", "tx.position DESC"] rows = await self.select_txos( - "raw, txo.position, chain, account", **constraints + "raw, tx.height, tx.position, tx.is_verified, txo.position, chain, account", **constraints ) txos = [] for row in rows: - tx = self.ledger.transaction_class(row[0]) - txo = tx.outputs[row[1]] - txo.is_change = row[2] == 1 - txo.is_my_account = row[3] == my_account + tx = self.ledger.transaction_class(row[0], height=row[1], position=row[2], is_verified=row[3]) + txo = tx.outputs[row[4]] + txo.is_change = row[5] == 1 + txo.is_my_account = row[6] == my_account txos.append(txo) return txos From 169ef00b9e7a9ad2c161fadc956587f1e4a9d7f5 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 29 Mar 2019 17:59:18 -0400 Subject: [PATCH 340/383] + txo.pubkey_hash property --- torba/client/basetransaction.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/torba/client/basetransaction.py b/torba/client/basetransaction.py index 358ea168c..3b7c9735d 100644 --- a/torba/client/basetransaction.py +++ b/torba/client/basetransaction.py @@ -218,10 +218,12 @@ class BaseOutput(InputOutput): def id(self): return self.ref.id + @property + def pubkey_hash(self): + return self.script.values['pubkey_hash'] + def get_address(self, ledger): - return ledger.hash160_to_address( - self.script.values['pubkey_hash'] - ) + return ledger.hash160_to_address(self.pubkey_hash) def get_estimator(self, ledger): return self.estimator_class(ledger, self) From 9b21bd1a6f56544a27867d208d978a46e1e31d5a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 29 Mar 2019 21:11:13 -0400 Subject: [PATCH 341/383] 0.5.1 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 65ca0062a..8ba93204a 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.4.0' +__version__ = '0.5.1' From f0c2d16749ae07e06310eb6c0bf48875009645da Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 6 Apr 2019 15:27:58 -0400 Subject: [PATCH 342/383] changed account list to use is_default instead of is_default_account and improved blockchain deamon port settings --- torba/client/basemanager.py | 2 +- torba/orchstr8/node.py | 17 +++++++++-------- 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/torba/client/basemanager.py b/torba/client/basemanager.py index 3beb1a7c2..37f3eaefb 100644 --- a/torba/client/basemanager.py +++ b/torba/client/basemanager.py @@ -45,7 +45,7 @@ class BaseWalletManager: ledgers = {} for i, account in enumerate(self.accounts): details = await account.get_details(**kwargs) - details['is_default_account'] = i == 0 + details['is_default'] = i == 0 ledger_id = account.ledger.get_id() ledgers.setdefault(ledger_id, []) ledgers[ledger_id].append(details) diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index 769504690..554021961 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -263,14 +263,15 @@ class BlockchainNode: self.protocol = None self.transport = None self._block_expected = 0 + self.hostname = 'localhost' + self.peerport = 9246 + 2 # avoid conflict with default peer port + self.rpcport = 9245 + 2 # avoid conflict with default rpc port self.rpcuser = 'rpcuser' self.rpcpassword = 'rpcpassword' - self.hostname = 'localhost' - self.port = 9245 + 1 # avoid conflict with default daemon @property def rpc_url(self): - return f'http://{self.rpcuser}:{self.rpcpassword}@{self.hostname}:{self.port}/' + return f'http://{self.rpcuser}:{self.rpcpassword}@{self.hostname}:{self.rpcport}/' def is_expected_block(self, e: BlockHeightEvent): return self._block_expected == e.height @@ -322,9 +323,9 @@ class BlockchainNode: asyncio.get_child_watcher().attach_loop(loop) command = ( self.daemon_bin, - '-datadir={}'.format(self.data_path), - '-printtoconsole', '-regtest', '-server', '-txindex', - f'-rpcuser={self.rpcuser}', f'-rpcpassword={self.rpcpassword}', f'-rpcport={self.port}' + f'-datadir={self.data_path}', '-printtoconsole', '-regtest', '-server', '-txindex', + f'-rpcuser={self.rpcuser}', f'-rpcpassword={self.rpcpassword}', f'-rpcport={self.rpcport}', + f'-port={self.peerport}' ) self.log.info(' '.join(command)) self.transport, self.protocol = await loop.subprocess_exec( @@ -346,8 +347,8 @@ class BlockchainNode: async def _cli_cmnd(self, *args): cmnd_args = [ - self.cli_bin, '-datadir={}'.format(self.data_path), '-regtest', - f'-rpcuser={self.rpcuser}', f'-rpcpassword={self.rpcpassword}', f'-rpcport={self.port}' + self.cli_bin, f'-datadir={self.data_path}', '-regtest', + f'-rpcuser={self.rpcuser}', f'-rpcpassword={self.rpcpassword}', f'-rpcport={self.rpcport}' ] + list(args) self.log.info(' '.join(cmnd_args)) loop = asyncio.get_event_loop() From 6788e09ae922df55c9d164d77d351665b4138d10 Mon Sep 17 00:00:00 2001 From: binaryflesh Date: Tue, 16 Apr 2019 02:50:35 -0500 Subject: [PATCH 343/383] PEP-257 docstrings Signed-off-by: binaryflesh --- torba/rpc/framing.py | 32 ++-- torba/rpc/jsonrpc.py | 68 ++++----- torba/rpc/session.py | 78 +++++----- torba/rpc/socks.py | 42 +++--- torba/server/block_processor.py | 70 ++++----- torba/server/coins.py | 120 +++++++-------- torba/server/daemon.py | 100 ++++++------- torba/server/db.py | 76 +++++----- torba/server/enum.py | 4 +- torba/server/env.py | 12 +- torba/server/hash.py | 28 ++-- torba/server/history.py | 22 +-- torba/server/mempool.py | 60 ++++---- torba/server/merkle.py | 52 +++---- torba/server/peer.py | 56 +++---- torba/server/peers.py | 46 +++--- torba/server/script.py | 16 +- torba/server/session.py | 256 ++++++++++++++++---------------- torba/server/storage.py | 28 ++-- torba/server/text.py | 12 +- torba/server/tx.py | 54 +++---- torba/server/util.py | 56 +++---- 22 files changed, 644 insertions(+), 644 deletions(-) diff --git a/torba/rpc/framing.py b/torba/rpc/framing.py index 6a5c2b9be..754d68139 100644 --- a/torba/rpc/framing.py +++ b/torba/rpc/framing.py @@ -23,7 +23,7 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -'''RPC message framing in a byte stream.''' +"""RPC message framing in a byte stream.""" __all__ = ('FramerBase', 'NewlineFramer', 'BinaryFramer', 'BitcoinFramer', 'OversizedPayloadError', 'BadChecksumError', 'BadMagicError') @@ -34,38 +34,38 @@ from asyncio import Queue class FramerBase(object): - '''Abstract base class for a framer. + """Abstract base class for a framer. A framer breaks an incoming byte stream into protocol messages, buffering if necesary. It also frames outgoing messages into a byte stream. - ''' + """ def frame(self, message): - '''Return the framed message.''' + """Return the framed message.""" raise NotImplementedError def received_bytes(self, data): - '''Pass incoming network bytes.''' + """Pass incoming network bytes.""" raise NotImplementedError async def receive_message(self): - '''Wait for a complete unframed message to arrive, and return it.''' + """Wait for a complete unframed message to arrive, and return it.""" raise NotImplementedError class NewlineFramer(FramerBase): - '''A framer for a protocol where messages are separated by newlines.''' + """A framer for a protocol where messages are separated by newlines.""" # The default max_size value is motivated by JSONRPC, where a # normal request will be 250 bytes or less, and a reasonable # batch may contain 4000 requests. def __init__(self, max_size=250 * 4000): - '''max_size - an anti-DoS measure. If, after processing an incoming + """max_size - an anti-DoS measure. If, after processing an incoming message, buffered data would exceed max_size bytes, that buffered data is dropped entirely and the framer waits for a newline character to re-synchronize the stream. - ''' + """ self.max_size = max_size self.queue = Queue() self.received_bytes = self.queue.put_nowait @@ -105,9 +105,9 @@ class NewlineFramer(FramerBase): class ByteQueue(object): - '''A producer-comsumer queue. Incoming network data is put as it + """A producer-comsumer queue. Incoming network data is put as it arrives, and the consumer calls an async method waiting for data of - a specific length.''' + a specific length.""" def __init__(self): self.queue = Queue() @@ -127,7 +127,7 @@ class ByteQueue(object): class BinaryFramer(object): - '''A framer for binary messaging protocols.''' + """A framer for binary messaging protocols.""" def __init__(self): self.byte_queue = ByteQueue() @@ -165,12 +165,12 @@ pack_le_uint32 = struct_le_I.pack def sha256(x): - '''Simple wrapper of hashlib sha256.''' + """Simple wrapper of hashlib sha256.""" return _sha256(x).digest() def double_sha256(x): - '''SHA-256 of SHA-256, as used extensively in bitcoin.''' + """SHA-256 of SHA-256, as used extensively in bitcoin.""" return sha256(sha256(x)) @@ -187,7 +187,7 @@ class OversizedPayloadError(Exception): class BitcoinFramer(BinaryFramer): - '''Provides a framer of binary message payloads in the style of the + """Provides a framer of binary message payloads in the style of the Bitcoin network protocol. Each binary message has the following elements, in order: @@ -201,7 +201,7 @@ class BitcoinFramer(BinaryFramer): Call frame(command, payload) to get a framed message. Pass incoming network bytes to received_bytes(). Wait on receive_message() to get incoming (command, payload) pairs. - ''' + """ def __init__(self, magic, max_block_size): def pad_command(command): diff --git a/torba/rpc/jsonrpc.py b/torba/rpc/jsonrpc.py index 3aaa95e83..84830ecd2 100644 --- a/torba/rpc/jsonrpc.py +++ b/torba/rpc/jsonrpc.py @@ -23,7 +23,7 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -'''Classes for JSONRPC versions 1.0 and 2.0, and a loose interpretation.''' +"""Classes for JSONRPC versions 1.0 and 2.0, and a loose interpretation.""" __all__ = ('JSONRPC', 'JSONRPCv1', 'JSONRPCv2', 'JSONRPCLoose', 'JSONRPCAutoDetect', 'Request', 'Notification', 'Batch', @@ -156,7 +156,7 @@ class ProtocolError(CodeMessageError): class JSONRPC(object): - '''Abstract base class that interprets and constructs JSON RPC messages.''' + """Abstract base class that interprets and constructs JSON RPC messages.""" # Error codes. See http://www.jsonrpc.org/specification PARSE_ERROR = -32700 @@ -172,24 +172,24 @@ class JSONRPC(object): @classmethod def _message_id(cls, message, require_id): - '''Validate the message is a dictionary and return its ID. + """Validate the message is a dictionary and return its ID. Raise an error if the message is invalid or the ID is of an invalid type. If it has no ID, raise an error if require_id is True, otherwise return None. - ''' + """ raise NotImplementedError @classmethod def _validate_message(cls, message): - '''Validate other parts of the message other than those - done in _message_id.''' + """Validate other parts of the message other than those + done in _message_id.""" pass @classmethod def _request_args(cls, request): - '''Validate the existence and type of the arguments passed - in the request dictionary.''' + """Validate the existence and type of the arguments passed + in the request dictionary.""" raise NotImplementedError @classmethod @@ -221,7 +221,7 @@ class JSONRPC(object): @classmethod def _message_to_payload(cls, message): - '''Returns a Python object or a ProtocolError.''' + """Returns a Python object or a ProtocolError.""" try: return json.loads(message.decode()) except UnicodeDecodeError: @@ -245,7 +245,7 @@ class JSONRPC(object): @classmethod def message_to_item(cls, message): - '''Translate an unframed received message and return an + """Translate an unframed received message and return an (item, request_id) pair. The item can be a Request, Notification, Response or a list. @@ -264,7 +264,7 @@ class JSONRPC(object): the response was bad. raises: ProtocolError - ''' + """ payload = cls._message_to_payload(message) if isinstance(payload, dict): if 'method' in payload: @@ -282,19 +282,19 @@ class JSONRPC(object): # Message formation @classmethod def request_message(cls, item, request_id): - '''Convert an RPCRequest item to a message.''' + """Convert an RPCRequest item to a message.""" assert isinstance(item, Request) return cls.encode_payload(cls.request_payload(item, request_id)) @classmethod def notification_message(cls, item): - '''Convert an RPCRequest item to a message.''' + """Convert an RPCRequest item to a message.""" assert isinstance(item, Notification) return cls.encode_payload(cls.request_payload(item, None)) @classmethod def response_message(cls, result, request_id): - '''Convert a response result (or RPCError) to a message.''' + """Convert a response result (or RPCError) to a message.""" if isinstance(result, CodeMessageError): payload = cls.error_payload(result, request_id) else: @@ -303,7 +303,7 @@ class JSONRPC(object): @classmethod def batch_message(cls, batch, request_ids): - '''Convert a request Batch to a message.''' + """Convert a request Batch to a message.""" assert isinstance(batch, Batch) if not cls.allow_batches: raise ProtocolError.invalid_request( @@ -317,9 +317,9 @@ class JSONRPC(object): @classmethod def batch_message_from_parts(cls, messages): - '''Convert messages, one per batch item, into a batch message. At + """Convert messages, one per batch item, into a batch message. At least one message must be passed. - ''' + """ # Comma-separate the messages and wrap the lot in square brackets middle = b', '.join(messages) if not middle: @@ -328,7 +328,7 @@ class JSONRPC(object): @classmethod def encode_payload(cls, payload): - '''Encode a Python object as JSON and convert it to bytes.''' + """Encode a Python object as JSON and convert it to bytes.""" try: return json.dumps(payload).encode() except TypeError: @@ -337,7 +337,7 @@ class JSONRPC(object): class JSONRPCv1(JSONRPC): - '''JSON RPC version 1.0.''' + """JSON RPC version 1.0.""" allow_batches = False @@ -392,7 +392,7 @@ class JSONRPCv1(JSONRPC): @classmethod def request_payload(cls, request, request_id): - '''JSON v1 request (or notification) payload.''' + """JSON v1 request (or notification) payload.""" if isinstance(request.args, dict): raise ProtocolError.invalid_args( 'JSONRPCv1 does not support named arguments') @@ -404,7 +404,7 @@ class JSONRPCv1(JSONRPC): @classmethod def response_payload(cls, result, request_id): - '''JSON v1 response payload.''' + """JSON v1 response payload.""" return { 'result': result, 'error': None, @@ -421,7 +421,7 @@ class JSONRPCv1(JSONRPC): class JSONRPCv2(JSONRPC): - '''JSON RPC version 2.0.''' + """JSON RPC version 2.0.""" @classmethod def _message_id(cls, message, require_id): @@ -477,7 +477,7 @@ class JSONRPCv2(JSONRPC): @classmethod def request_payload(cls, request, request_id): - '''JSON v2 request (or notification) payload.''' + """JSON v2 request (or notification) payload.""" payload = { 'jsonrpc': '2.0', 'method': request.method, @@ -492,7 +492,7 @@ class JSONRPCv2(JSONRPC): @classmethod def response_payload(cls, result, request_id): - '''JSON v2 response payload.''' + """JSON v2 response payload.""" return { 'jsonrpc': '2.0', 'result': result, @@ -509,7 +509,7 @@ class JSONRPCv2(JSONRPC): class JSONRPCLoose(JSONRPC): - '''A relaxed versin of JSON RPC.''' + """A relaxed versin of JSON RPC.""" # Don't be so loose we accept any old message ID _message_id = JSONRPCv2._message_id @@ -546,7 +546,7 @@ class JSONRPCAutoDetect(JSONRPCv2): @classmethod def detect_protocol(cls, message): - '''Attempt to detect the protocol from the message.''' + """Attempt to detect the protocol from the message.""" main = cls._message_to_payload(message) def protocol_for_payload(payload): @@ -581,13 +581,13 @@ class JSONRPCAutoDetect(JSONRPCv2): class JSONRPCConnection(object): - '''Maintains state of a JSON RPC connection, in particular + """Maintains state of a JSON RPC connection, in particular encapsulating the handling of request IDs. protocol - the JSON RPC protocol to follow max_response_size - responses over this size send an error response instead. - ''' + """ _id_counter = itertools.count() @@ -684,7 +684,7 @@ class JSONRPCConnection(object): # External API # def send_request(self, request): - '''Send a Request. Return a (message, event) pair. + """Send a Request. Return a (message, event) pair. The message is an unframed message to send over the network. Wait on the event for the response; which will be in the @@ -692,7 +692,7 @@ class JSONRPCConnection(object): Raises: ProtocolError if the request violates the protocol in some way.. - ''' + """ request_id = next(self._id_counter) message = self._protocol.request_message(request, request_id) return message, self._event(request, request_id) @@ -708,13 +708,13 @@ class JSONRPCConnection(object): return message, event def receive_message(self, message): - '''Call with an unframed message received from the network. + """Call with an unframed message received from the network. Raises: ProtocolError if the message violates the protocol in some way. However, if it happened in a response that can be paired with a request, the ProtocolError is instead set in the result attribute of the send_request() that caused the error. - ''' + """ try: item, request_id = self._protocol.message_to_item(message) except ProtocolError as e: @@ -743,7 +743,7 @@ class JSONRPCConnection(object): return self.receive_message(message) def cancel_pending_requests(self): - '''Cancel all pending requests.''' + """Cancel all pending requests.""" exception = CancelledError() for request, event in self._requests.values(): event.result = exception @@ -751,7 +751,7 @@ class JSONRPCConnection(object): self._requests.clear() def pending_requests(self): - '''All sent requests that have not received a response.''' + """All sent requests that have not received a response.""" return [request for request, event in self._requests.values()] diff --git a/torba/rpc/session.py b/torba/rpc/session.py index e23f78b47..c8b8c6945 100644 --- a/torba/rpc/session.py +++ b/torba/rpc/session.py @@ -54,7 +54,7 @@ class Connector: self.kwargs = kwargs async def create_connection(self): - '''Initiate a connection.''' + """Initiate a connection.""" connector = self.proxy or self.loop return await connector.create_connection( self.session_factory, self.host, self.port, **self.kwargs) @@ -70,7 +70,7 @@ class Connector: class SessionBase(asyncio.Protocol): - '''Base class of networking sessions. + """Base class of networking sessions. There is no client / server distinction other than who initiated the connection. @@ -81,7 +81,7 @@ class SessionBase(asyncio.Protocol): Alternatively if used in a with statement, the connection is made on entry to the block, and closed on exit from the block. - ''' + """ max_errors = 10 @@ -138,7 +138,7 @@ class SessionBase(asyncio.Protocol): await self._concurrency.set_max_concurrent(target) def _using_bandwidth(self, size): - '''Called when sending or receiving size bytes.''' + """Called when sending or receiving size bytes.""" self.bw_charge += size async def _limited_wait(self, secs): @@ -173,7 +173,7 @@ class SessionBase(asyncio.Protocol): # asyncio framework def data_received(self, framed_message): - '''Called by asyncio when a message comes in.''' + """Called by asyncio when a message comes in.""" if self.verbosity >= 4: self.logger.debug(f'Received framed message {framed_message}') self.recv_size += len(framed_message) @@ -181,21 +181,21 @@ class SessionBase(asyncio.Protocol): self.framer.received_bytes(framed_message) def pause_writing(self): - '''Transport calls when the send buffer is full.''' + """Transport calls when the send buffer is full.""" if not self.is_closing(): self._can_send.clear() self.transport.pause_reading() def resume_writing(self): - '''Transport calls when the send buffer has room.''' + """Transport calls when the send buffer has room.""" if not self._can_send.is_set(): self._can_send.set() self.transport.resume_reading() def connection_made(self, transport): - '''Called by asyncio when a connection is established. + """Called by asyncio when a connection is established. - Derived classes overriding this method must call this first.''' + Derived classes overriding this method must call this first.""" self.transport = transport # This would throw if called on a closed SSL transport. Fixed # in asyncio in Python 3.6.1 and 3.5.4 @@ -209,9 +209,9 @@ class SessionBase(asyncio.Protocol): self._pm_task = self.loop.create_task(self._receive_messages()) def connection_lost(self, exc): - '''Called by asyncio when the connection closes. + """Called by asyncio when the connection closes. - Tear down things done in connection_made.''' + Tear down things done in connection_made.""" self._address = None self.transport = None self._task_group.cancel() @@ -221,21 +221,21 @@ class SessionBase(asyncio.Protocol): # External API def default_framer(self): - '''Return a default framer.''' + """Return a default framer.""" raise NotImplementedError def peer_address(self): - '''Returns the peer's address (Python networking address), or None if + """Returns the peer's address (Python networking address), or None if no connection or an error. This is the result of socket.getpeername() when the connection was made. - ''' + """ return self._address def peer_address_str(self): - '''Returns the peer's IP address and port as a human-readable - string.''' + """Returns the peer's IP address and port as a human-readable + string.""" if not self._address: return 'unknown' ip_addr_str, port = self._address[:2] @@ -245,16 +245,16 @@ class SessionBase(asyncio.Protocol): return f'{ip_addr_str}:{port}' def is_closing(self): - '''Return True if the connection is closing.''' + """Return True if the connection is closing.""" return not self.transport or self.transport.is_closing() def abort(self): - '''Forcefully close the connection.''' + """Forcefully close the connection.""" if self.transport: self.transport.abort() async def close(self, *, force_after=30): - '''Close the connection and return when closed.''' + """Close the connection and return when closed.""" self._close() if self._pm_task: with suppress(CancelledError): @@ -264,12 +264,12 @@ class SessionBase(asyncio.Protocol): class MessageSession(SessionBase): - '''Session class for protocols where messages are not tied to responses, + """Session class for protocols where messages are not tied to responses, such as the Bitcoin protocol. To use as a client (connection-opening) session, pass host, port and perhaps a proxy. - ''' + """ async def _receive_messages(self): while not self.is_closing(): try: @@ -303,7 +303,7 @@ class MessageSession(SessionBase): await self._task_group.add(self._throttled_message(message)) async def _throttled_message(self, message): - '''Process a single request, respecting the concurrency limit.''' + """Process a single request, respecting the concurrency limit.""" async with self._concurrency.semaphore: try: await self.handle_message(message) @@ -318,15 +318,15 @@ class MessageSession(SessionBase): # External API def default_framer(self): - '''Return a bitcoin framer.''' + """Return a bitcoin framer.""" return BitcoinFramer(bytes.fromhex('e3e1f3e8'), 128_000_000) async def handle_message(self, message): - '''message is a (command, payload) pair.''' + """message is a (command, payload) pair.""" pass async def send_message(self, message): - '''Send a message (command, payload) over the network.''' + """Send a message (command, payload) over the network.""" await self._send_message(message) @@ -337,7 +337,7 @@ class BatchError(Exception): class BatchRequest(object): - '''Used to build a batch request to send to the server. Stores + """Used to build a batch request to send to the server. Stores the Attributes batch and results are initially None. @@ -367,7 +367,7 @@ class BatchRequest(object): RPC error response, or violated the protocol in some way, a BatchError exception is raised. Otherwise the caller can be certain each request returned a standard result. - ''' + """ def __init__(self, session, raise_errors): self._session = session @@ -401,8 +401,8 @@ class BatchRequest(object): class RPCSession(SessionBase): - '''Base class for protocols where a message can lead to a response, - for example JSON RPC.''' + """Base class for protocols where a message can lead to a response, + for example JSON RPC.""" def __init__(self, *, framer=None, loop=None, connection=None): super().__init__(framer=framer, loop=loop) @@ -435,7 +435,7 @@ class RPCSession(SessionBase): await self._task_group.add(self._throttled_request(request)) async def _throttled_request(self, request): - '''Process a single request, respecting the concurrency limit.''' + """Process a single request, respecting the concurrency limit.""" async with self._concurrency.semaphore: try: result = await self.handle_request(request) @@ -461,18 +461,18 @@ class RPCSession(SessionBase): # External API def default_connection(self): - '''Return a default connection if the user provides none.''' + """Return a default connection if the user provides none.""" return JSONRPCConnection(JSONRPCv2) def default_framer(self): - '''Return a default framer.''' + """Return a default framer.""" return NewlineFramer() async def handle_request(self, request): pass async def send_request(self, method, args=()): - '''Send an RPC request over the network.''' + """Send an RPC request over the network.""" message, event = self.connection.send_request(Request(method, args)) await self._send_message(message) await event.wait() @@ -482,12 +482,12 @@ class RPCSession(SessionBase): return result async def send_notification(self, method, args=()): - '''Send an RPC notification over the network.''' + """Send an RPC notification over the network.""" message = self.connection.send_notification(Notification(method, args)) await self._send_message(message) def send_batch(self, raise_errors=False): - '''Return a BatchRequest. Intended to be used like so: + """Return a BatchRequest. Intended to be used like so: async with session.send_batch() as batch: batch.add_request("method1") @@ -499,12 +499,12 @@ class RPCSession(SessionBase): Note that in some circumstances exceptions can be raised; see BatchRequest doc string. - ''' + """ return BatchRequest(self, raise_errors) class Server(object): - '''A simple wrapper around an asyncio.Server object.''' + """A simple wrapper around an asyncio.Server object.""" def __init__(self, session_factory, host=None, port=None, *, loop=None, **kwargs): @@ -520,9 +520,9 @@ class Server(object): self._session_factory, self.host, self.port, **self._kwargs) async def close(self): - '''Close the listening socket. This does not close any ServerSession + """Close the listening socket. This does not close any ServerSession objects created to handle incoming connections. - ''' + """ if self.server: self.server.close() await self.server.wait_closed() diff --git a/torba/rpc/socks.py b/torba/rpc/socks.py index cc4b63f13..776f86a29 100644 --- a/torba/rpc/socks.py +++ b/torba/rpc/socks.py @@ -23,7 +23,7 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -'''SOCKS proxying.''' +"""SOCKS proxying.""" import sys import asyncio @@ -42,16 +42,16 @@ SOCKSUserAuth = collections.namedtuple("SOCKSUserAuth", "username password") class SOCKSError(Exception): - '''Base class for SOCKS exceptions. Each raised exception will be - an instance of a derived class.''' + """Base class for SOCKS exceptions. Each raised exception will be + an instance of a derived class.""" class SOCKSProtocolError(SOCKSError): - '''Raised when the proxy does not follow the SOCKS protocol''' + """Raised when the proxy does not follow the SOCKS protocol""" class SOCKSFailure(SOCKSError): - '''Raised when the proxy refuses or fails to make a connection''' + """Raised when the proxy refuses or fails to make a connection""" class NeedData(Exception): @@ -83,7 +83,7 @@ class SOCKSBase(object): class SOCKS4(SOCKSBase): - '''SOCKS4 protocol wrapper.''' + """SOCKS4 protocol wrapper.""" # See http://ftp.icm.edu.pl/packages/socks/socks4/SOCKS4.protocol REPLY_CODES = { @@ -159,7 +159,7 @@ class SOCKS4a(SOCKS4): class SOCKS5(SOCKSBase): - '''SOCKS protocol wrapper.''' + """SOCKS protocol wrapper.""" # See https://tools.ietf.org/html/rfc1928 ERROR_CODES = { @@ -269,12 +269,12 @@ class SOCKS5(SOCKSBase): class SOCKSProxy(object): def __init__(self, address, protocol, auth): - '''A SOCKS proxy at an address following a SOCKS protocol. auth is an + """A SOCKS proxy at an address following a SOCKS protocol. auth is an authentication method to use when connecting, or None. address is a (host, port) pair; for IPv6 it can instead be a (host, port, flowinfo, scopeid) 4-tuple. - ''' + """ self.address = address self.protocol = protocol self.auth = auth @@ -305,11 +305,11 @@ class SOCKSProxy(object): client.receive_data(data) async def _connect_one(self, host, port): - '''Connect to the proxy and perform a handshake requesting a + """Connect to the proxy and perform a handshake requesting a connection to (host, port). Return the open socket on success, or the exception on failure. - ''' + """ client = self.protocol(host, port, self.auth) sock = socket.socket() loop = asyncio.get_event_loop() @@ -327,11 +327,11 @@ class SOCKSProxy(object): return e async def _connect(self, addresses): - '''Connect to the proxy and perform a handshake requesting a + """Connect to the proxy and perform a handshake requesting a connection to each address in addresses. Return an (open_socket, address) pair on success. - ''' + """ assert len(addresses) > 0 exceptions = [] @@ -347,9 +347,9 @@ class SOCKSProxy(object): OSError(f'multiple exceptions: {", ".join(strings)}')) async def _detect_proxy(self): - '''Return True if it appears we can connect to a SOCKS proxy, + """Return True if it appears we can connect to a SOCKS proxy, otherwise False. - ''' + """ if self.protocol is SOCKS4a: host, port = 'www.apple.com', 80 else: @@ -366,7 +366,7 @@ class SOCKSProxy(object): @classmethod async def auto_detect_address(cls, address, auth): - '''Try to detect a SOCKS proxy at address using the authentication + """Try to detect a SOCKS proxy at address using the authentication method (or None). SOCKS5, SOCKS4a and SOCKS are tried in order. If a SOCKS proxy is detected a SOCKSProxy object is returned. @@ -375,7 +375,7 @@ class SOCKSProxy(object): example, it may have no network connectivity. If no proxy is detected return None. - ''' + """ for protocol in (SOCKS5, SOCKS4a, SOCKS4): proxy = cls(address, protocol, auth) if await proxy._detect_proxy(): @@ -384,7 +384,7 @@ class SOCKSProxy(object): @classmethod async def auto_detect_host(cls, host, ports, auth): - '''Try to detect a SOCKS proxy on a host on one of the ports. + """Try to detect a SOCKS proxy on a host on one of the ports. Calls auto_detect for the ports in order. Returns SOCKS are tried in order; a SOCKSProxy object for the first detected @@ -394,7 +394,7 @@ class SOCKSProxy(object): example, it may have no network connectivity. If no proxy is detected return None. - ''' + """ for port in ports: address = (host, port) proxy = await cls.auto_detect_address(address, auth) @@ -406,7 +406,7 @@ class SOCKSProxy(object): async def create_connection(self, protocol_factory, host, port, *, resolve=False, ssl=None, family=0, proto=0, flags=0): - '''Set up a connection to (host, port) through the proxy. + """Set up a connection to (host, port) through the proxy. If resolve is True then host is resolved locally with getaddrinfo using family, proto and flags, otherwise the proxy @@ -417,7 +417,7 @@ class SOCKSProxy(object): protocol to the address of the successful remote connection. Additionally raises SOCKSError if something goes wrong with the proxy handshake. - ''' + """ loop = asyncio.get_event_loop() if resolve: infos = await loop.getaddrinfo(host, port, family=family, diff --git a/torba/server/block_processor.py b/torba/server/block_processor.py index 93925b1ed..b575d9123 100644 --- a/torba/server/block_processor.py +++ b/torba/server/block_processor.py @@ -6,7 +6,7 @@ # See the file "LICENCE" for information about the copyright # and warranty status of this software. -'''Block prefetcher and chain processor.''' +"""Block prefetcher and chain processor.""" import asyncio @@ -21,7 +21,7 @@ from torba.server.db import FlushData class Prefetcher: - '''Prefetches blocks (in the forward direction only).''' + """Prefetches blocks (in the forward direction only).""" def __init__(self, daemon, coin, blocks_event): self.logger = class_logger(__name__, self.__class__.__name__) @@ -43,7 +43,7 @@ class Prefetcher: self.polling_delay = 5 async def main_loop(self, bp_height): - '''Loop forever polling for more blocks.''' + """Loop forever polling for more blocks.""" await self.reset_height(bp_height) while True: try: @@ -55,7 +55,7 @@ class Prefetcher: self.logger.info(f'ignoring daemon error: {e}') def get_prefetched_blocks(self): - '''Called by block processor when it is processing queued blocks.''' + """Called by block processor when it is processing queued blocks.""" blocks = self.blocks self.blocks = [] self.cache_size = 0 @@ -63,12 +63,12 @@ class Prefetcher: return blocks async def reset_height(self, height): - '''Reset to prefetch blocks from the block processor's height. + """Reset to prefetch blocks from the block processor's height. Used in blockchain reorganisations. This coroutine can be called asynchronously to the _prefetch_blocks coroutine so we must synchronize with a semaphore. - ''' + """ async with self.semaphore: self.blocks.clear() self.cache_size = 0 @@ -86,10 +86,10 @@ class Prefetcher: .format(daemon_height)) async def _prefetch_blocks(self): - '''Prefetch some blocks and put them on the queue. + """Prefetch some blocks and put them on the queue. Repeats until the queue is full or caught up. - ''' + """ daemon = self.daemon daemon_height = await daemon.height() async with self.semaphore: @@ -136,15 +136,15 @@ class Prefetcher: class ChainError(Exception): - '''Raised on error processing blocks.''' + """Raised on error processing blocks.""" class BlockProcessor: - '''Process blocks and update the DB state to match. + """Process blocks and update the DB state to match. Employ a prefetcher to prefetch blocks in batches for processing. Coordinate backing up in case of chain reorganisations. - ''' + """ def __init__(self, env, db, daemon, notifications): self.env = env @@ -187,9 +187,9 @@ class BlockProcessor: return await asyncio.shield(run_in_thread_locked()) async def check_and_advance_blocks(self, raw_blocks): - '''Process the list of raw blocks passed. Detects and handles + """Process the list of raw blocks passed. Detects and handles reorgs. - ''' + """ if not raw_blocks: return first = self.height + 1 @@ -224,10 +224,10 @@ class BlockProcessor: await self.prefetcher.reset_height(self.height) async def reorg_chain(self, count=None): - '''Handle a chain reorganisation. + """Handle a chain reorganisation. Count is the number of blocks to simulate a reorg, or None for - a real reorg.''' + a real reorg.""" if count is None: self.logger.info('chain reorg detected') else: @@ -260,12 +260,12 @@ class BlockProcessor: await self.prefetcher.reset_height(self.height) async def reorg_hashes(self, count): - '''Return a pair (start, last, hashes) of blocks to back up during a + """Return a pair (start, last, hashes) of blocks to back up during a reorg. The hashes are returned in order of increasing height. Start is the height of the first hash, last of the last. - ''' + """ start, count = await self.calc_reorg_range(count) last = start + count - 1 s = '' if count == 1 else 's' @@ -275,11 +275,11 @@ class BlockProcessor: return start, last, await self.db.fs_block_hashes(start, count) async def calc_reorg_range(self, count): - '''Calculate the reorg range''' + """Calculate the reorg range""" def diff_pos(hashes1, hashes2): - '''Returns the index of the first difference in the hash lists. - If both lists match returns their length.''' + """Returns the index of the first difference in the hash lists. + If both lists match returns their length.""" for n, (hash1, hash2) in enumerate(zip(hashes1, hashes2)): if hash1 != hash2: return n @@ -318,7 +318,7 @@ class BlockProcessor: # - Flushing def flush_data(self): - '''The data for a flush. The lock must be taken.''' + """The data for a flush. The lock must be taken.""" assert self.state_lock.locked() return FlushData(self.height, self.tx_count, self.headers, self.tx_hashes, self.undo_infos, self.utxo_cache, @@ -342,7 +342,7 @@ class BlockProcessor: self.next_cache_check = time.time() + 30 def check_cache_size(self): - '''Flush a cache if it gets too big.''' + """Flush a cache if it gets too big.""" # Good average estimates based on traversal of subobjects and # requesting size from Python (see deep_getsizeof). one_MB = 1000*1000 @@ -368,10 +368,10 @@ class BlockProcessor: return None def advance_blocks(self, blocks): - '''Synchronously advance the blocks. + """Synchronously advance the blocks. It is already verified they correctly connect onto our tip. - ''' + """ min_height = self.db.min_undo_height(self.daemon.cached_height()) height = self.height @@ -436,11 +436,11 @@ class BlockProcessor: return undo_info def backup_blocks(self, raw_blocks): - '''Backup the raw blocks and flush. + """Backup the raw blocks and flush. The blocks should be in order of decreasing height, starting at. self.height. A flush is performed once the blocks are backed up. - ''' + """ self.db.assert_flushed(self.flush_data()) assert self.height >= len(raw_blocks) @@ -500,7 +500,7 @@ class BlockProcessor: assert n == 0 self.tx_count -= len(txs) - '''An in-memory UTXO cache, representing all changes to UTXO state + """An in-memory UTXO cache, representing all changes to UTXO state since the last DB flush. We want to store millions of these in memory for optimal @@ -552,15 +552,15 @@ class BlockProcessor: looking up a UTXO the prefix space of the compressed hash needs to be searched and resolved if necessary with the tx_num. The collision rate is low (<0.1%). - ''' + """ def spend_utxo(self, tx_hash, tx_idx): - '''Spend a UTXO and return the 33-byte value. + """Spend a UTXO and return the 33-byte value. If the UTXO is not in the cache it must be on disk. We store all UTXOs so not finding one indicates a logic error or DB corruption. - ''' + """ # Fast track is it being in the cache idx_packed = pack('= cls.FORK_HEIGHT: return double_sha256(header) @@ -511,7 +511,7 @@ class Emercoin(Coin): @classmethod def block_header(cls, block, height): - '''Returns the block header given a block and its height.''' + """Returns the block header given a block and its height.""" deserializer = cls.DESERIALIZER(block) if deserializer.is_merged_block(): @@ -520,7 +520,7 @@ class Emercoin(Coin): @classmethod def header_hash(cls, header): - '''Given a header return hash''' + """Given a header return hash""" return double_sha256(header[:cls.BASIC_HEADER_SIZE]) @@ -543,7 +543,7 @@ class BitcoinTestnetMixin: class BitcoinCashTestnet(BitcoinTestnetMixin, Coin): - '''Bitcoin Testnet for Bitcoin Cash daemons.''' + """Bitcoin Testnet for Bitcoin Cash daemons.""" NAME = "BitcoinCash" PEERS = [ 'electrum-testnet-abc.criptolayer.net s50112', @@ -563,7 +563,7 @@ class BitcoinCashRegtest(BitcoinCashTestnet): class BitcoinSegwitTestnet(BitcoinTestnetMixin, Coin): - '''Bitcoin Testnet for Core bitcoind >= 0.13.1.''' + """Bitcoin Testnet for Core bitcoind >= 0.13.1.""" NAME = "BitcoinSegwit" DESERIALIZER = lib_tx.DeserializerSegWit PEERS = [ @@ -588,7 +588,7 @@ class BitcoinSegwitRegtest(BitcoinSegwitTestnet): class BitcoinNolnet(BitcoinCash): - '''Bitcoin Unlimited nolimit testnet.''' + """Bitcoin Unlimited nolimit testnet.""" NET = "nolnet" GENESIS_HASH = ('0000000057e31bd2066c939a63b7b862' '3bd0f10d8c001304bdfc1a7902ae6d35') @@ -878,7 +878,7 @@ class Motion(Coin): @classmethod def header_hash(cls, header): - '''Given a header return the hash.''' + """Given a header return the hash.""" import x16r_hash return x16r_hash.getPoWHash(header) @@ -912,7 +912,7 @@ class Dash(Coin): @classmethod def header_hash(cls, header): - '''Given a header return the hash.''' + """Given a header return the hash.""" import x11_hash return x11_hash.getPoWHash(header) @@ -1014,7 +1014,7 @@ class FairCoin(Coin): @classmethod def block(cls, raw_block, height): - '''Return a Block namedtuple given a raw block and its height.''' + """Return a Block namedtuple given a raw block and its height.""" if height > 0: return super().block(raw_block, height) else: @@ -1465,7 +1465,7 @@ class Bitzeny(Coin): @classmethod def header_hash(cls, header): - '''Given a header return the hash.''' + """Given a header return the hash.""" import zny_yescrypt return zny_yescrypt.getPoWHash(header) @@ -1513,7 +1513,7 @@ class Denarius(Coin): @classmethod def header_hash(cls, header): - '''Given a header return the hash.''' + """Given a header return the hash.""" import tribus_hash return tribus_hash.getPoWHash(header) @@ -1552,11 +1552,11 @@ class Sibcoin(Dash): @classmethod def header_hash(cls, header): - ''' + """ Given a header return the hash for sibcoin. Need to download `x11_gost_hash` module Source code: https://github.com/ivansib/x11_gost_hash - ''' + """ import x11_gost_hash return x11_gost_hash.getPoWHash(header) @@ -1724,7 +1724,7 @@ class BitcoinAtom(Coin): @classmethod def header_hash(cls, header): - '''Given a header return hash''' + """Given a header return hash""" header_to_be_hashed = header[:cls.BASIC_HEADER_SIZE] # New block header format has some extra flags in the end if len(header) == cls.HEADER_SIZE_POST_FORK: @@ -1737,7 +1737,7 @@ class BitcoinAtom(Coin): @classmethod def block_header(cls, block, height): - '''Return the block header bytes''' + """Return the block header bytes""" deserializer = cls.DESERIALIZER(block) return deserializer.read_header(height, cls.BASIC_HEADER_SIZE) @@ -1777,12 +1777,12 @@ class Decred(Coin): @classmethod def header_hash(cls, header): - '''Given a header return the hash.''' + """Given a header return the hash.""" return cls.HEADER_HASH(header) @classmethod def block(cls, raw_block, height): - '''Return a Block namedtuple given a raw block and its height.''' + """Return a Block namedtuple given a raw block and its height.""" if height > 0: return super().block(raw_block, height) else: @@ -1837,11 +1837,11 @@ class Axe(Dash): @classmethod def header_hash(cls, header): - ''' + """ Given a header return the hash for AXE. Need to download `axe_hash` module Source code: https://github.com/AXErunners/axe_hash - ''' + """ import x11_hash return x11_hash.getPoWHash(header) @@ -1867,11 +1867,11 @@ class Xuez(Coin): @classmethod def header_hash(cls, header): - ''' + """ Given a header return the hash for Xuez. Need to download `xevan_hash` module Source code: https://github.com/xuez/xuez - ''' + """ version, = util.unpack_le_uint32_from(header) import xevan_hash @@ -1915,7 +1915,7 @@ class Pac(Coin): @classmethod def header_hash(cls, header): - '''Given a header return the hash.''' + """Given a header return the hash.""" import x11_hash return x11_hash.getPoWHash(header) @@ -1960,7 +1960,7 @@ class Polis(Coin): @classmethod def header_hash(cls, header): - '''Given a header return the hash.''' + """Given a header return the hash.""" import x11_hash return x11_hash.getPoWHash(header) @@ -1989,7 +1989,7 @@ class ColossusXT(Coin): @classmethod def header_hash(cls, header): - '''Given a header return the hash.''' + """Given a header return the hash.""" import quark_hash return quark_hash.getPoWHash(header) @@ -2018,7 +2018,7 @@ class GoByte(Coin): @classmethod def header_hash(cls, header): - '''Given a header return the hash.''' + """Given a header return the hash.""" import neoscrypt return neoscrypt.getPoWHash(header) @@ -2047,7 +2047,7 @@ class Monoeci(Coin): @classmethod def header_hash(cls, header): - '''Given a header return the hash.''' + """Given a header return the hash.""" import x11_hash return x11_hash.getPoWHash(header) @@ -2082,7 +2082,7 @@ class Minexcoin(EquihashMixin, Coin): @classmethod def block_header(cls, block, height): - '''Return the block header bytes''' + """Return the block header bytes""" deserializer = cls.DESERIALIZER(block) return deserializer.read_header(height, cls.HEADER_SIZE_NO_SOLUTION) @@ -2116,7 +2116,7 @@ class Groestlcoin(Coin): @classmethod def header_hash(cls, header): - '''Given a header return the hash.''' + """Given a header return the hash.""" return cls.grshash(header) ENCODE_CHECK = partial(Base58.encode_check, hash_fn=grshash) @@ -2224,7 +2224,7 @@ class Bitg(Coin): @classmethod def header_hash(cls, header): - '''Given a header return the hash.''' + """Given a header return the hash.""" import quark_hash return quark_hash.getPoWHash(header) diff --git a/torba/server/daemon.py b/torba/server/daemon.py index dba43abd8..5a89bb1f8 100644 --- a/torba/server/daemon.py +++ b/torba/server/daemon.py @@ -5,8 +5,8 @@ # See the file "LICENCE" for information about the copyright # and warranty status of this software. -'''Class for handling asynchronous connections to a blockchain -daemon.''' +"""Class for handling asynchronous connections to a blockchain +daemon.""" import asyncio import itertools @@ -26,19 +26,19 @@ from torba.rpc import JSONRPC class DaemonError(Exception): - '''Raised when the daemon returns an error in its results.''' + """Raised when the daemon returns an error in its results.""" class WarmingUpError(Exception): - '''Internal - when the daemon is warming up.''' + """Internal - when the daemon is warming up.""" class WorkQueueFullError(Exception): - '''Internal - when the daemon's work queue is full.''' + """Internal - when the daemon's work queue is full.""" class Daemon: - '''Handles connections to a daemon at the given URL.''' + """Handles connections to a daemon at the given URL.""" WARMING_UP = -28 id_counter = itertools.count() @@ -57,7 +57,7 @@ class Daemon: self.available_rpcs = {} def set_url(self, url): - '''Set the URLS to the given list, and switch to the first one.''' + """Set the URLS to the given list, and switch to the first one.""" urls = url.split(',') urls = [self.coin.sanitize_url(url) for url in urls] for n, url in enumerate(urls): @@ -68,19 +68,19 @@ class Daemon: self.urls = urls def current_url(self): - '''Returns the current daemon URL.''' + """Returns the current daemon URL.""" return self.urls[self.url_index] def logged_url(self, url=None): - '''The host and port part, for logging.''' + """The host and port part, for logging.""" url = url or self.current_url() return url[url.rindex('@') + 1:] def failover(self): - '''Call to fail-over to the next daemon URL. + """Call to fail-over to the next daemon URL. Returns False if there is only one, otherwise True. - ''' + """ if len(self.urls) > 1: self.url_index = (self.url_index + 1) % len(self.urls) self.logger.info(f'failing over to {self.logged_url()}') @@ -88,7 +88,7 @@ class Daemon: return False def client_session(self): - '''An aiohttp client session.''' + """An aiohttp client session.""" return aiohttp.ClientSession() async def _send_data(self, data): @@ -107,11 +107,11 @@ class Daemon: raise DaemonError(text) async def _send(self, payload, processor): - '''Send a payload to be converted to JSON. + """Send a payload to be converted to JSON. Handles temporary connection issues. Daemon reponse errors are raise through DaemonError. - ''' + """ def log_error(error): nonlocal last_error_log, retry now = time.time() @@ -154,7 +154,7 @@ class Daemon: retry = max(min(self.max_retry, retry * 2), self.init_retry) async def _send_single(self, method, params=None): - '''Send a single request to the daemon.''' + """Send a single request to the daemon.""" def processor(result): err = result['error'] if not err: @@ -169,11 +169,11 @@ class Daemon: return await self._send(payload, processor) async def _send_vector(self, method, params_iterable, replace_errs=False): - '''Send several requests of the same method. + """Send several requests of the same method. The result will be an array of the same length as params_iterable. If replace_errs is true, any item with an error is returned as None, - otherwise an exception is raised.''' + otherwise an exception is raised.""" def processor(result): errs = [item['error'] for item in result if item['error']] if any(err.get('code') == self.WARMING_UP for err in errs): @@ -189,10 +189,10 @@ class Daemon: return [] async def _is_rpc_available(self, method): - '''Return whether given RPC method is available in the daemon. + """Return whether given RPC method is available in the daemon. Results are cached and the daemon will generally not be queried with - the same method more than once.''' + the same method more than once.""" available = self.available_rpcs.get(method) if available is None: available = True @@ -206,30 +206,30 @@ class Daemon: return available async def block_hex_hashes(self, first, count): - '''Return the hex hashes of count block starting at height first.''' + """Return the hex hashes of count block starting at height first.""" params_iterable = ((h, ) for h in range(first, first + count)) return await self._send_vector('getblockhash', params_iterable) async def deserialised_block(self, hex_hash): - '''Return the deserialised block with the given hex hash.''' + """Return the deserialised block with the given hex hash.""" return await self._send_single('getblock', (hex_hash, True)) async def raw_blocks(self, hex_hashes): - '''Return the raw binary blocks with the given hex hashes.''' + """Return the raw binary blocks with the given hex hashes.""" params_iterable = ((h, False) for h in hex_hashes) blocks = await self._send_vector('getblock', params_iterable) # Convert hex string to bytes return [hex_to_bytes(block) for block in blocks] async def mempool_hashes(self): - '''Update our record of the daemon's mempool hashes.''' + """Update our record of the daemon's mempool hashes.""" return await self._send_single('getrawmempool') async def estimatefee(self, block_count): - '''Return the fee estimate for the block count. Units are whole + """Return the fee estimate for the block count. Units are whole currency units per KB, e.g. 0.00000995, or -1 if no estimate is available. - ''' + """ args = (block_count, ) if await self._is_rpc_available('estimatesmartfee'): estimate = await self._send_single('estimatesmartfee', args) @@ -237,25 +237,25 @@ class Daemon: return await self._send_single('estimatefee', args) async def getnetworkinfo(self): - '''Return the result of the 'getnetworkinfo' RPC call.''' + """Return the result of the 'getnetworkinfo' RPC call.""" return await self._send_single('getnetworkinfo') async def relayfee(self): - '''The minimum fee a low-priority tx must pay in order to be accepted - to the daemon's memory pool.''' + """The minimum fee a low-priority tx must pay in order to be accepted + to the daemon's memory pool.""" network_info = await self.getnetworkinfo() return network_info['relayfee'] async def getrawtransaction(self, hex_hash, verbose=False): - '''Return the serialized raw transaction with the given hash.''' + """Return the serialized raw transaction with the given hash.""" # Cast to int because some coin daemons are old and require it return await self._send_single('getrawtransaction', (hex_hash, int(verbose))) async def getrawtransactions(self, hex_hashes, replace_errs=True): - '''Return the serialized raw transactions with the given hashes. + """Return the serialized raw transactions with the given hashes. - Replaces errors with None by default.''' + Replaces errors with None by default.""" params_iterable = ((hex_hash, 0) for hex_hash in hex_hashes) txs = await self._send_vector('getrawtransaction', params_iterable, replace_errs=replace_errs) @@ -263,57 +263,57 @@ class Daemon: return [hex_to_bytes(tx) if tx else None for tx in txs] async def broadcast_transaction(self, raw_tx): - '''Broadcast a transaction to the network.''' + """Broadcast a transaction to the network.""" return await self._send_single('sendrawtransaction', (raw_tx, )) async def height(self): - '''Query the daemon for its current height.''' + """Query the daemon for its current height.""" self._height = await self._send_single('getblockcount') return self._height def cached_height(self): - '''Return the cached daemon height. + """Return the cached daemon height. - If the daemon has not been queried yet this returns None.''' + If the daemon has not been queried yet this returns None.""" return self._height class DashDaemon(Daemon): async def masternode_broadcast(self, params): - '''Broadcast a transaction to the network.''' + """Broadcast a transaction to the network.""" return await self._send_single('masternodebroadcast', params) async def masternode_list(self, params): - '''Return the masternode status.''' + """Return the masternode status.""" return await self._send_single('masternodelist', params) class FakeEstimateFeeDaemon(Daemon): - '''Daemon that simulates estimatefee and relayfee RPC calls. Coin that - wants to use this daemon must define ESTIMATE_FEE & RELAY_FEE''' + """Daemon that simulates estimatefee and relayfee RPC calls. Coin that + wants to use this daemon must define ESTIMATE_FEE & RELAY_FEE""" async def estimatefee(self, block_count): - '''Return the fee estimate for the given parameters.''' + """Return the fee estimate for the given parameters.""" return self.coin.ESTIMATE_FEE async def relayfee(self): - '''The minimum fee a low-priority tx must pay in order to be accepted - to the daemon's memory pool.''' + """The minimum fee a low-priority tx must pay in order to be accepted + to the daemon's memory pool.""" return self.coin.RELAY_FEE class LegacyRPCDaemon(Daemon): - '''Handles connections to a daemon at the given URL. + """Handles connections to a daemon at the given URL. This class is useful for daemons that don't have the new 'getblock' RPC call that returns the block in hex, the workaround is to manually recreate the block bytes. The recreated block bytes may not be the exact as in the underlying blockchain but it is good enough for our indexing - purposes.''' + purposes.""" async def raw_blocks(self, hex_hashes): - '''Return the raw binary blocks with the given hex hashes.''' + """Return the raw binary blocks with the given hex hashes.""" params_iterable = ((h, ) for h in hex_hashes) block_info = await self._send_vector('getblock', params_iterable) @@ -339,7 +339,7 @@ class LegacyRPCDaemon(Daemon): ]) async def make_raw_block(self, b): - '''Construct a raw block''' + """Construct a raw block""" header = await self.make_raw_header(b) @@ -365,7 +365,7 @@ class LegacyRPCDaemon(Daemon): class DecredDaemon(Daemon): async def raw_blocks(self, hex_hashes): - '''Return the raw binary blocks with the given hex hashes.''' + """Return the raw binary blocks with the given hex hashes.""" params_iterable = ((h, False) for h in hex_hashes) blocks = await self._send_vector('getblock', params_iterable) @@ -448,12 +448,12 @@ class DecredDaemon(Daemon): class PreLegacyRPCDaemon(LegacyRPCDaemon): - '''Handles connections to a daemon at the given URL. + """Handles connections to a daemon at the given URL. This class is useful for daemons that don't have the new 'getblock' RPC call that returns the block in hex, and need the False parameter - for the getblock''' + for the getblock""" async def deserialised_block(self, hex_hash): - '''Return the deserialised block with the given hex hash.''' + """Return the deserialised block with the given hex hash.""" return await self._send_single('getblock', (hex_hash, False)) diff --git a/torba/server/db.py b/torba/server/db.py index 16e165bc9..8fff9dadf 100644 --- a/torba/server/db.py +++ b/torba/server/db.py @@ -6,7 +6,7 @@ # See the file "LICENCE" for information about the copyright # and warranty status of this software. -'''Interface to the blockchain database.''' +"""Interface to the blockchain database.""" import asyncio @@ -47,16 +47,16 @@ class FlushData: class DB: - '''Simple wrapper of the backend database for querying. + """Simple wrapper of the backend database for querying. Performs no DB update, though the DB will be cleaned on opening if it was shutdown uncleanly. - ''' + """ DB_VERSIONS = [6] class DBError(Exception): - '''Raised on general DB errors generally indicating corruption.''' + """Raised on general DB errors generally indicating corruption.""" def __init__(self, env): self.logger = util.class_logger(__name__, self.__class__.__name__) @@ -142,18 +142,18 @@ class DB: await self._open_dbs(True, True) async def open_for_sync(self): - '''Open the databases to sync to the daemon. + """Open the databases to sync to the daemon. When syncing we want to reserve a lot of open files for the synchronization. When serving clients we want the open files for serving network connections. - ''' + """ await self._open_dbs(True, False) async def open_for_serving(self): - '''Open the databases for serving. If they are already open they are + """Open the databases for serving. If they are already open they are closed first. - ''' + """ if self.utxo_db: self.logger.info('closing DBs to re-open for serving') self.utxo_db.close() @@ -176,7 +176,7 @@ class DB: # Flushing def assert_flushed(self, flush_data): - '''Asserts state is fully flushed.''' + """Asserts state is fully flushed.""" assert flush_data.tx_count == self.fs_tx_count == self.db_tx_count assert flush_data.height == self.fs_height == self.db_height assert flush_data.tip == self.db_tip @@ -188,8 +188,8 @@ class DB: self.history.assert_flushed() def flush_dbs(self, flush_data, flush_utxos, estimate_txs_remaining): - '''Flush out cached state. History is always flushed; UTXOs are - flushed if flush_utxos.''' + """Flush out cached state. History is always flushed; UTXOs are + flushed if flush_utxos.""" if flush_data.height == self.db_height: self.assert_flushed(flush_data) return @@ -231,12 +231,12 @@ class DB: f'ETA: {formatted_time(eta)}') def flush_fs(self, flush_data): - '''Write headers, tx counts and block tx hashes to the filesystem. + """Write headers, tx counts and block tx hashes to the filesystem. The first height to write is self.fs_height + 1. The FS metadata is all append-only, so in a crash we just pick up again from the height stored in the DB. - ''' + """ prior_tx_count = (self.tx_counts[self.fs_height] if self.fs_height >= 0 else 0) assert len(flush_data.block_tx_hashes) == len(flush_data.headers) @@ -274,7 +274,7 @@ class DB: self.history.flush() def flush_utxo_db(self, batch, flush_data): - '''Flush the cached DB writes and UTXO set to the batch.''' + """Flush the cached DB writes and UTXO set to the batch.""" # Care is needed because the writes generated by flushing the # UTXO state may have keys in common with our write cache or # may be in the DB already. @@ -317,7 +317,7 @@ class DB: self.db_tip = flush_data.tip def flush_state(self, batch): - '''Flush chain state to the batch.''' + """Flush chain state to the batch.""" now = time.time() self.wall_time += now - self.last_flush self.last_flush = now @@ -325,7 +325,7 @@ class DB: self.write_utxo_state(batch) def flush_backup(self, flush_data, touched): - '''Like flush_dbs() but when backing up. All UTXOs are flushed.''' + """Like flush_dbs() but when backing up. All UTXOs are flushed.""" assert not flush_data.headers assert not flush_data.block_tx_hashes assert flush_data.height < self.db_height @@ -369,28 +369,28 @@ class DB: - self.dynamic_header_offset(height) def backup_fs(self, height, tx_count): - '''Back up during a reorg. This just updates our pointers.''' + """Back up during a reorg. This just updates our pointers.""" self.fs_height = height self.fs_tx_count = tx_count # Truncate header_mc: header count is 1 more than the height. self.header_mc.truncate(height + 1) async def raw_header(self, height): - '''Return the binary header at the given height.''' + """Return the binary header at the given height.""" header, n = await self.read_headers(height, 1) if n != 1: raise IndexError(f'height {height:,d} out of range') return header async def read_headers(self, start_height, count): - '''Requires start_height >= 0, count >= 0. Reads as many headers as + """Requires start_height >= 0, count >= 0. Reads as many headers as are available starting at start_height up to count. This would be zero if start_height is beyond self.db_height, for example. Returns a (binary, n) pair where binary is the concatenated binary headers, and n is the count of headers returned. - ''' + """ if start_height < 0 or count < 0: raise self.DBError(f'{count:,d} headers starting at ' f'{start_height:,d} not on disk') @@ -407,9 +407,9 @@ class DB: return await asyncio.get_event_loop().run_in_executor(None, read_headers) def fs_tx_hash(self, tx_num): - '''Return a par (tx_hash, tx_height) for the given tx number. + """Return a par (tx_hash, tx_height) for the given tx number. - If the tx_height is not on disk, returns (None, tx_height).''' + If the tx_height is not on disk, returns (None, tx_height).""" tx_height = bisect_right(self.tx_counts, tx_num) if tx_height > self.db_height: tx_hash = None @@ -432,12 +432,12 @@ class DB: return [self.coin.header_hash(header) for header in headers] async def limited_history(self, hashX, *, limit=1000): - '''Return an unpruned, sorted list of (tx_hash, height) tuples of + """Return an unpruned, sorted list of (tx_hash, height) tuples of confirmed transactions that touched the address, earliest in the blockchain first. Includes both spending and receiving transactions. By default returns at most 1000 entries. Set limit to None to get them all. - ''' + """ def read_history(): tx_nums = list(self.history.get_txnums(hashX, limit)) fs_tx_hash = self.fs_tx_hash @@ -454,19 +454,19 @@ class DB: # -- Undo information def min_undo_height(self, max_height): - '''Returns a height from which we should store undo info.''' + """Returns a height from which we should store undo info.""" return max_height - self.env.reorg_limit + 1 def undo_key(self, height): - '''DB key for undo information at the given height.''' + """DB key for undo information at the given height.""" return b'U' + pack('>I', height) def read_undo_info(self, height): - '''Read undo information from a file for the current height.''' + """Read undo information from a file for the current height.""" return self.utxo_db.get(self.undo_key(height)) def flush_undo_infos(self, batch_put, undo_infos): - '''undo_infos is a list of (undo_info, height) pairs.''' + """undo_infos is a list of (undo_info, height) pairs.""" for undo_info, height in undo_infos: batch_put(self.undo_key(height), b''.join(undo_info)) @@ -477,13 +477,13 @@ class DB: return f'{self.raw_block_prefix()}{height:d}' def read_raw_block(self, height): - '''Returns a raw block read from disk. Raises FileNotFoundError - if the block isn't on-disk.''' + """Returns a raw block read from disk. Raises FileNotFoundError + if the block isn't on-disk.""" with util.open_file(self.raw_block_path(height)) as f: return f.read(-1) def write_raw_block(self, block, height): - '''Write a raw block to disk.''' + """Write a raw block to disk.""" with util.open_truncate(self.raw_block_path(height)) as f: f.write(block) # Delete old blocks to prevent them accumulating @@ -494,7 +494,7 @@ class DB: pass def clear_excess_undo_info(self): - '''Clear excess undo info. Only most recent N are kept.''' + """Clear excess undo info. Only most recent N are kept.""" prefix = b'U' min_height = self.min_undo_height(self.db_height) keys = [] @@ -578,7 +578,7 @@ class DB: .format(util.formatted_time(self.wall_time))) def write_utxo_state(self, batch): - '''Write (UTXO) state to the batch.''' + """Write (UTXO) state to the batch.""" state = { 'genesis': self.coin.GENESIS_HASH, 'height': self.db_height, @@ -597,7 +597,7 @@ class DB: self.write_utxo_state(batch) async def all_utxos(self, hashX): - '''Return all UTXOs for an address sorted in no particular order.''' + """Return all UTXOs for an address sorted in no particular order.""" def read_utxos(): utxos = [] utxos_append = utxos.append @@ -621,15 +621,15 @@ class DB: await sleep(0.25) async def lookup_utxos(self, prevouts): - '''For each prevout, lookup it up in the DB and return a (hashX, + """For each prevout, lookup it up in the DB and return a (hashX, value) pair or None if not found. Used by the mempool code. - ''' + """ def lookup_hashXs(): - '''Return (hashX, suffix) pairs, or None if not found, + """Return (hashX, suffix) pairs, or None if not found, for each prevout. - ''' + """ def lookup_hashX(tx_hash, tx_idx): idx_packed = pack(' MemPoolTx hashXs: hashX -> set of all hashes of txs touching the hashX - ''' + """ def __init__(self, coin, api, refresh_secs=5.0, log_status_secs=120.0): assert isinstance(api, MemPoolAPI) @@ -107,7 +107,7 @@ class MemPool: self.lock = Lock() async def _logging(self, synchronized_event): - '''Print regular logs of mempool stats.''' + """Print regular logs of mempool stats.""" self.logger.info('beginning processing of daemon mempool. ' 'This can take some time...') start = time.time() @@ -156,12 +156,12 @@ class MemPool: self.cached_compact_histogram = compact def _accept_transactions(self, tx_map, utxo_map, touched): - '''Accept transactions in tx_map to the mempool if all their inputs + """Accept transactions in tx_map to the mempool if all their inputs can be found in the existing mempool or a utxo_map from the DB. Returns an (unprocessed tx_map, unspent utxo_map) pair. - ''' + """ hashXs = self.hashXs txs = self.txs @@ -200,7 +200,7 @@ class MemPool: return deferred, {prevout: utxo_map[prevout] for prevout in unspent} async def _refresh_hashes(self, synchronized_event): - '''Refresh our view of the daemon's mempool.''' + """Refresh our view of the daemon's mempool.""" while True: height = self.api.cached_height() hex_hashes = await self.api.mempool_hashes() @@ -256,7 +256,7 @@ class MemPool: return touched async def _fetch_and_accept(self, hashes, all_hashes, touched): - '''Fetch a list of mempool transactions.''' + """Fetch a list of mempool transactions.""" hex_hashes_iter = (hash_to_hex_str(hash) for hash in hashes) raw_txs = await self.api.raw_transactions(hex_hashes_iter) @@ -303,7 +303,7 @@ class MemPool: # async def keep_synchronized(self, synchronized_event): - '''Keep the mempool synchronized with the daemon.''' + """Keep the mempool synchronized with the daemon.""" await asyncio.wait([ self._refresh_hashes(synchronized_event), self._refresh_histogram(synchronized_event), @@ -311,10 +311,10 @@ class MemPool: ]) async def balance_delta(self, hashX): - '''Return the unconfirmed amount in the mempool for hashX. + """Return the unconfirmed amount in the mempool for hashX. Can be positive or negative. - ''' + """ value = 0 if hashX in self.hashXs: for hash in self.hashXs[hashX]: @@ -324,16 +324,16 @@ class MemPool: return value async def compact_fee_histogram(self): - '''Return a compact fee histogram of the current mempool.''' + """Return a compact fee histogram of the current mempool.""" return self.cached_compact_histogram async def potential_spends(self, hashX): - '''Return a set of (prev_hash, prev_idx) pairs from mempool + """Return a set of (prev_hash, prev_idx) pairs from mempool transactions that touch hashX. None, some or all of these may be spends of the hashX, but all actual spends of it (in the DB or mempool) will be included. - ''' + """ result = set() for tx_hash in self.hashXs.get(hashX, ()): tx = self.txs[tx_hash] @@ -341,7 +341,7 @@ class MemPool: return result async def transaction_summaries(self, hashX): - '''Return a list of MemPoolTxSummary objects for the hashX.''' + """Return a list of MemPoolTxSummary objects for the hashX.""" result = [] for tx_hash in self.hashXs.get(hashX, ()): tx = self.txs[tx_hash] @@ -350,12 +350,12 @@ class MemPool: return result async def unordered_UTXOs(self, hashX): - '''Return an unordered list of UTXO named tuples from mempool + """Return an unordered list of UTXO named tuples from mempool transactions that pay to hashX. This does not consider if any other mempool transactions spend the outputs. - ''' + """ utxos = [] for tx_hash in self.hashXs.get(hashX, ()): tx = self.txs.get(tx_hash) diff --git a/torba/server/merkle.py b/torba/server/merkle.py index e8e54a06c..8cfa89c68 100644 --- a/torba/server/merkle.py +++ b/torba/server/merkle.py @@ -24,7 +24,7 @@ # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # and warranty status of this software. -'''Merkle trees, branches, proofs and roots.''' +"""Merkle trees, branches, proofs and roots.""" from asyncio import Event from math import ceil, log @@ -33,12 +33,12 @@ from torba.server.hash import double_sha256 class Merkle: - '''Perform merkle tree calculations on binary hashes using a given hash + """Perform merkle tree calculations on binary hashes using a given hash function. If the hash count is not even, the final hash is repeated when calculating the next merkle layer up the tree. - ''' + """ def __init__(self, hash_func=double_sha256): self.hash_func = hash_func @@ -47,7 +47,7 @@ class Merkle: return self.branch_length(hash_count) + 1 def branch_length(self, hash_count): - '''Return the length of a merkle branch given the number of hashes.''' + """Return the length of a merkle branch given the number of hashes.""" if not isinstance(hash_count, int): raise TypeError('hash_count must be an integer') if hash_count < 1: @@ -55,9 +55,9 @@ class Merkle: return ceil(log(hash_count, 2)) def branch_and_root(self, hashes, index, length=None): - '''Return a (merkle branch, merkle_root) pair given hashes, and the + """Return a (merkle branch, merkle_root) pair given hashes, and the index of one of those hashes. - ''' + """ hashes = list(hashes) if not isinstance(index, int): raise TypeError('index must be an integer') @@ -86,12 +86,12 @@ class Merkle: return branch, hashes[0] def root(self, hashes, length=None): - '''Return the merkle root of a non-empty iterable of binary hashes.''' + """Return the merkle root of a non-empty iterable of binary hashes.""" branch, root = self.branch_and_root(hashes, 0, length) return root def root_from_proof(self, hash, branch, index): - '''Return the merkle root given a hash, a merkle branch to it, and + """Return the merkle root given a hash, a merkle branch to it, and its index in the hashes array. branch is an iterable sorted deepest to shallowest. If the @@ -102,7 +102,7 @@ class Merkle: branch_length(). Unfortunately this is not easily done for bitcoin transactions as the number of transactions in a block is unknown to an SPV client. - ''' + """ hash_func = self.hash_func for elt in branch: if index & 1: @@ -115,8 +115,8 @@ class Merkle: return hash def level(self, hashes, depth_higher): - '''Return a level of the merkle tree of hashes the given depth - higher than the bottom row of the original tree.''' + """Return a level of the merkle tree of hashes the given depth + higher than the bottom row of the original tree.""" size = 1 << depth_higher root = self.root return [root(hashes[n: n + size], depth_higher) @@ -124,7 +124,7 @@ class Merkle: def branch_and_root_from_level(self, level, leaf_hashes, index, depth_higher): - '''Return a (merkle branch, merkle_root) pair when a merkle-tree has a + """Return a (merkle branch, merkle_root) pair when a merkle-tree has a level cached. To maximally reduce the amount of data hashed in computing a @@ -140,7 +140,7 @@ class Merkle: index is the index in the full list of hashes of the hash whose merkle branch we want. - ''' + """ if not isinstance(level, list): raise TypeError("level must be a list") if not isinstance(leaf_hashes, list): @@ -157,14 +157,14 @@ class Merkle: class MerkleCache: - '''A cache to calculate merkle branches efficiently.''' + """A cache to calculate merkle branches efficiently.""" def __init__(self, merkle, source_func): - '''Initialise a cache hashes taken from source_func: + """Initialise a cache hashes taken from source_func: async def source_func(index, count): ... - ''' + """ self.merkle = merkle self.source_func = source_func self.length = 0 @@ -175,9 +175,9 @@ class MerkleCache: return 1 << self.depth_higher def _leaf_start(self, index): - '''Given a level's depth higher and a hash index, return the leaf + """Given a level's depth higher and a hash index, return the leaf index and leaf hash count needed to calculate a merkle branch. - ''' + """ depth_higher = self.depth_higher return (index >> depth_higher) << depth_higher @@ -185,7 +185,7 @@ class MerkleCache: return self.merkle.level(hashes, self.depth_higher) async def _extend_to(self, length): - '''Extend the length of the cache if necessary.''' + """Extend the length of the cache if necessary.""" if length <= self.length: return # Start from the beginning of any final partial segment. @@ -196,8 +196,8 @@ class MerkleCache: self.length = length async def _level_for(self, length): - '''Return a (level_length, final_hash) pair for a truncation - of the hashes to the given length.''' + """Return a (level_length, final_hash) pair for a truncation + of the hashes to the given length.""" if length == self.length: return self.level level = self.level[:length >> self.depth_higher] @@ -208,15 +208,15 @@ class MerkleCache: return level async def initialize(self, length): - '''Call to initialize the cache to a source of given length.''' + """Call to initialize the cache to a source of given length.""" self.length = length self.depth_higher = self.merkle.tree_depth(length) // 2 self.level = self._level(await self.source_func(0, length)) self.initialized.set() def truncate(self, length): - '''Truncate the cache so it covers no more than length underlying - hashes.''' + """Truncate the cache so it covers no more than length underlying + hashes.""" if not isinstance(length, int): raise TypeError('length must be an integer') if length <= 0: @@ -228,11 +228,11 @@ class MerkleCache: self.level[length >> self.depth_higher:] = [] async def branch_and_root(self, length, index): - '''Return a merkle branch and root. Length is the number of + """Return a merkle branch and root. Length is the number of hashes used to calculate the merkle root, index is the position of the hash to calculate the branch of. - index must be less than length, which must be at least 1.''' + index must be less than length, which must be at least 1.""" if not isinstance(length, int): raise TypeError('length must be an integer') if not isinstance(index, int): diff --git a/torba/server/peer.py b/torba/server/peer.py index c59c84a34..a3f268da3 100644 --- a/torba/server/peer.py +++ b/torba/server/peer.py @@ -23,7 +23,7 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -'''Representation of a peer server.''' +"""Representation of a peer server.""" from ipaddress import ip_address @@ -47,8 +47,8 @@ class Peer: def __init__(self, host, features, source='unknown', ip_addr=None, last_good=0, last_try=0, try_count=0): - '''Create a peer given a host name (or IP address as a string), - a dictionary of features, and a record of the source.''' + """Create a peer given a host name (or IP address as a string), + a dictionary of features, and a record of the source.""" assert isinstance(host, str) assert isinstance(features, dict) assert host in features.get('hosts', {}) @@ -83,14 +83,14 @@ class Peer: @classmethod def deserialize(cls, item): - '''Deserialize from a dictionary.''' + """Deserialize from a dictionary.""" return cls(**item) def matches(self, peers): - '''Return peers whose host matches our hostname or IP address. + """Return peers whose host matches our hostname or IP address. Additionally include all peers whose IP address matches our hostname if that is an IP address. - ''' + """ candidates = (self.host.lower(), self.ip_addr) return [peer for peer in peers if peer.host.lower() in candidates @@ -100,7 +100,7 @@ class Peer: return self.host def update_features(self, features): - '''Update features in-place.''' + """Update features in-place.""" try: tmp = Peer(self.host, features) except Exception: @@ -115,8 +115,8 @@ class Peer: setattr(self, feature, getattr(peer, feature)) def connection_port_pairs(self): - '''Return a list of (kind, port) pairs to try when making a - connection.''' + """Return a list of (kind, port) pairs to try when making a + connection.""" # Use a list not a set - it's important to try the registered # ports first. pairs = [('SSL', self.ssl_port), ('TCP', self.tcp_port)] @@ -125,13 +125,13 @@ class Peer: return [pair for pair in pairs if pair[1]] def mark_bad(self): - '''Mark as bad to avoid reconnects but also to remember for a - while.''' + """Mark as bad to avoid reconnects but also to remember for a + while.""" self.bad = True def check_ports(self, other): - '''Remember differing ports in case server operator changed them - or removed one.''' + """Remember differing ports in case server operator changed them + or removed one.""" if other.ssl_port != self.ssl_port: self.other_port_pairs.add(('SSL', other.ssl_port)) if other.tcp_port != self.tcp_port: @@ -160,7 +160,7 @@ class Peer: @cachedproperty def ip_address(self): - '''The host as a python ip_address object, or None.''' + """The host as a python ip_address object, or None.""" try: return ip_address(self.host) except ValueError: @@ -174,7 +174,7 @@ class Peer: return tuple(self.ip_addr.split('.')[:2]) def serialize(self): - '''Serialize to a dictionary.''' + """Serialize to a dictionary.""" return {attr: getattr(self, attr) for attr in self.ATTRS} def _port(self, key): @@ -202,28 +202,28 @@ class Peer: @cachedproperty def genesis_hash(self): - '''Returns None if no SSL port, otherwise the port as an integer.''' + """Returns None if no SSL port, otherwise the port as an integer.""" return self._string('genesis_hash') @cachedproperty def ssl_port(self): - '''Returns None if no SSL port, otherwise the port as an integer.''' + """Returns None if no SSL port, otherwise the port as an integer.""" return self._port('ssl_port') @cachedproperty def tcp_port(self): - '''Returns None if no TCP port, otherwise the port as an integer.''' + """Returns None if no TCP port, otherwise the port as an integer.""" return self._port('tcp_port') @cachedproperty def server_version(self): - '''Returns the server version as a string if known, otherwise None.''' + """Returns the server version as a string if known, otherwise None.""" return self._string('server_version') @cachedproperty def pruning(self): - '''Returns the pruning level as an integer. None indicates no - pruning.''' + """Returns the pruning level as an integer. None indicates no + pruning.""" pruning = self._integer('pruning') if pruning and pruning > 0: return pruning @@ -236,22 +236,22 @@ class Peer: @cachedproperty def protocol_min(self): - '''Minimum protocol version as a string, e.g., 1.0''' + """Minimum protocol version as a string, e.g., 1.0""" return self._protocol_version_string('protocol_min') @cachedproperty def protocol_max(self): - '''Maximum protocol version as a string, e.g., 1.1''' + """Maximum protocol version as a string, e.g., 1.1""" return self._protocol_version_string('protocol_max') def to_tuple(self): - '''The tuple ((ip, host, details) expected in response - to a peers subscription.''' + """The tuple ((ip, host, details) expected in response + to a peers subscription.""" details = self.real_name().split()[1:] return (self.ip_addr or self.host, self.host, details) def real_name(self): - '''Real name of this peer as used on IRC.''' + """Real name of this peer as used on IRC.""" def port_text(letter, port): if port == self.DEFAULT_PORTS.get(letter): return letter @@ -268,12 +268,12 @@ class Peer: @classmethod def from_real_name(cls, real_name, source): - '''Real name is a real name as on IRC, such as + """Real name is a real name as on IRC, such as "erbium1.sytes.net v1.0 s t" Returns an instance of this Peer class. - ''' + """ host = 'nohost' features = {} ports = {} diff --git a/torba/server/peers.py b/torba/server/peers.py index 842111466..1ea4ebc91 100644 --- a/torba/server/peers.py +++ b/torba/server/peers.py @@ -5,7 +5,7 @@ # See the file "LICENCE" for information about the copyright # and warranty status of this software. -'''Peer management.''' +"""Peer management.""" import asyncio import random @@ -39,7 +39,7 @@ def assert_good(message, result, instance): class PeerSession(RPCSession): - '''An outgoing session to a peer.''' + """An outgoing session to a peer.""" async def handle_request(self, request): # We subscribe so might be unlucky enough to get a notification... @@ -51,11 +51,11 @@ class PeerSession(RPCSession): class PeerManager: - '''Looks after the DB of peer network servers. + """Looks after the DB of peer network servers. Attempts to maintain a connection with up to 8 peers. Issues a 'peers.subscribe' RPC to them and tells them our data. - ''' + """ def __init__(self, env, db): self.logger = class_logger(__name__, self.__class__.__name__) # Initialise the Peer class @@ -78,12 +78,12 @@ class PeerManager: self.group = TaskGroup() def _my_clearnet_peer(self): - '''Returns the clearnet peer representing this server, if any.''' + """Returns the clearnet peer representing this server, if any.""" clearnet = [peer for peer in self.myselves if not peer.is_tor] return clearnet[0] if clearnet else None def _set_peer_statuses(self): - '''Set peer statuses.''' + """Set peer statuses.""" cutoff = time.time() - STALE_SECS for peer in self.peers: if peer.bad: @@ -96,10 +96,10 @@ class PeerManager: peer.status = PEER_NEVER def _features_to_register(self, peer, remote_peers): - '''If we should register ourselves to the remote peer, which has + """If we should register ourselves to the remote peer, which has reported the given list of known peers, return the clearnet identity features to register, otherwise None. - ''' + """ # Announce ourself if not present. Don't if disabled, we # are a non-public IP address, or to ourselves. if not self.env.peer_announce or peer in self.myselves: @@ -114,7 +114,7 @@ class PeerManager: return my.features def _permit_new_onion_peer(self): - '''Accept a new onion peer only once per random time interval.''' + """Accept a new onion peer only once per random time interval.""" now = time.time() if now < self.permit_onion_peer_time: return False @@ -122,7 +122,7 @@ class PeerManager: return True async def _import_peers(self): - '''Import hard-coded peers from a file or the coin defaults.''' + """Import hard-coded peers from a file or the coin defaults.""" imported_peers = self.myselves.copy() # Add the hard-coded ones unless only reporting ourself if self.env.peer_discovery != self.env.PD_SELF: @@ -131,12 +131,12 @@ class PeerManager: await self._note_peers(imported_peers, limit=None) async def _detect_proxy(self): - '''Detect a proxy if we don't have one and some time has passed since + """Detect a proxy if we don't have one and some time has passed since the last attempt. If found self.proxy is set to a SOCKSProxy instance, otherwise None. - ''' + """ host = self.env.tor_proxy_host if self.env.tor_proxy_port is None: ports = [9050, 9150, 1080] @@ -155,7 +155,7 @@ class PeerManager: async def _note_peers(self, peers, limit=2, check_ports=False, source=None): - '''Add a limited number of peers that are not already present.''' + """Add a limited number of peers that are not already present.""" new_peers = [] for peer in peers: if not peer.is_public or (peer.is_tor and not self.proxy): @@ -378,12 +378,12 @@ class PeerManager: # External interface # async def discover_peers(self): - '''Perform peer maintenance. This includes + """Perform peer maintenance. This includes 1) Forgetting unreachable peers. 2) Verifying connectivity of new peers. 3) Retrying old peers at regular intervals. - ''' + """ if self.env.peer_discovery != self.env.PD_ON: self.logger.info('peer discovery is disabled') return @@ -395,7 +395,7 @@ class PeerManager: self.group.add(self._import_peers()) def info(self): - '''The number of peers.''' + """The number of peers.""" self._set_peer_statuses() counter = Counter(peer.status for peer in self.peers) return { @@ -407,11 +407,11 @@ class PeerManager: } async def add_localRPC_peer(self, real_name): - '''Add a peer passed by the admin over LocalRPC.''' + """Add a peer passed by the admin over LocalRPC.""" await self._note_peers([Peer.from_real_name(real_name, 'RPC')]) async def on_add_peer(self, features, source_info): - '''Add a peer (but only if the peer resolves to the source).''' + """Add a peer (but only if the peer resolves to the source).""" if not source_info: self.logger.info('ignored add_peer request: no source info') return False @@ -449,12 +449,12 @@ class PeerManager: return permit def on_peers_subscribe(self, is_tor): - '''Returns the server peers as a list of (ip, host, details) tuples. + """Returns the server peers as a list of (ip, host, details) tuples. We return all peers we've connected to in the last day. Additionally, if we don't have onion routing, we return a few hard-coded onion servers. - ''' + """ cutoff = time.time() - STALE_SECS recent = [peer for peer in self.peers if peer.last_good > cutoff and @@ -485,12 +485,12 @@ class PeerManager: return [peer.to_tuple() for peer in peers] def proxy_peername(self): - '''Return the peername of the proxy, if there is a proxy, otherwise - None.''' + """Return the peername of the proxy, if there is a proxy, otherwise + None.""" return self.proxy.peername if self.proxy else None def rpc_data(self): - '''Peer data for the peers RPC method.''' + """Peer data for the peers RPC method.""" self._set_peer_statuses() descs = ['good', 'stale', 'never', 'bad'] diff --git a/torba/server/script.py b/torba/server/script.py index 00f7472b6..d47811eb2 100644 --- a/torba/server/script.py +++ b/torba/server/script.py @@ -24,7 +24,7 @@ # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # and warranty status of this software. -'''Script-related classes and functions.''' +"""Script-related classes and functions.""" import struct @@ -37,7 +37,7 @@ from torba.server.util import unpack_le_uint16_from, unpack_le_uint32_from, \ class ScriptError(Exception): - '''Exception used for script errors.''' + """Exception used for script errors.""" OpCodes = Enumeration("Opcodes", [ @@ -92,9 +92,9 @@ def _match_ops(ops, pattern): class ScriptPubKey: - '''A class for handling a tx output script that gives conditions + """A class for handling a tx output script that gives conditions necessary for spending. - ''' + """ TO_ADDRESS_OPS = [OpCodes.OP_DUP, OpCodes.OP_HASH160, -1, OpCodes.OP_EQUALVERIFY, OpCodes.OP_CHECKSIG] @@ -106,7 +106,7 @@ class ScriptPubKey: @classmethod def pay_to(cls, handlers, script): - '''Parse a script, invoke the appropriate handler and + """Parse a script, invoke the appropriate handler and return the result. One of the following handlers is invoked: @@ -115,7 +115,7 @@ class ScriptPubKey: handlers.pubkey(pubkey) handlers.unspendable() handlers.strange(script) - ''' + """ try: ops = Script.get_ops(script) except ScriptError: @@ -163,7 +163,7 @@ class ScriptPubKey: @classmethod def multisig_script(cls, m, pubkeys): - '''Returns the script for a pay-to-multisig transaction.''' + """Returns the script for a pay-to-multisig transaction.""" n = len(pubkeys) if not 1 <= m <= n <= 15: raise ScriptError('{:d} of {:d} multisig script not possible' @@ -218,7 +218,7 @@ class Script: @classmethod def push_data(cls, data): - '''Returns the opcodes to push the data on the stack.''' + """Returns the opcodes to push the data on the stack.""" assert isinstance(data, (bytes, bytearray)) n = len(data) diff --git a/torba/server/session.py b/torba/server/session.py index c5b063ec5..47d611484 100644 --- a/torba/server/session.py +++ b/torba/server/session.py @@ -5,7 +5,7 @@ # See the file "LICENCE" for information about the copyright # and warranty status of this software. -'''Classes for local RPC server and remote client TCP/SSL servers.''' +"""Classes for local RPC server and remote client TCP/SSL servers.""" import asyncio import codecs @@ -48,8 +48,8 @@ def scripthash_to_hashX(scripthash): def non_negative_integer(value): - '''Return param value it is or can be converted to a non-negative - integer, otherwise raise an RPCError.''' + """Return param value it is or can be converted to a non-negative + integer, otherwise raise an RPCError.""" try: value = int(value) if value >= 0: @@ -61,15 +61,15 @@ def non_negative_integer(value): def assert_boolean(value): - '''Return param value it is boolean otherwise raise an RPCError.''' + """Return param value it is boolean otherwise raise an RPCError.""" if value in (False, True): return value raise RPCError(BAD_REQUEST, f'{value} should be a boolean value') def assert_tx_hash(value): - '''Raise an RPCError if the value is not a valid transaction - hash.''' + """Raise an RPCError if the value is not a valid transaction + hash.""" try: if len(util.hex_to_bytes(value)) == 32: return @@ -79,7 +79,7 @@ def assert_tx_hash(value): class Semaphores: - '''For aiorpcX's semaphore handling.''' + """For aiorpcX's semaphore handling.""" def __init__(self, semaphores): self.semaphores = semaphores @@ -104,7 +104,7 @@ class SessionGroup: class SessionManager: - '''Holds global state about all sessions.''' + """Holds global state about all sessions.""" def __init__(self, env, db, bp, daemon, mempool, shutdown_event): env.max_send = max(350000, env.max_send) @@ -159,9 +159,9 @@ class SessionManager: self.logger.info(f'{kind} server listening on {host}:{port:d}') async def _start_external_servers(self): - '''Start listening on TCP and SSL ports, but only if the respective + """Start listening on TCP and SSL ports, but only if the respective port was given in the environment. - ''' + """ env = self.env host = env.cs_host(for_rpc=False) if env.tcp_port is not None: @@ -172,7 +172,7 @@ class SessionManager: await self._start_server('SSL', host, env.ssl_port, ssl=sslc) async def _close_servers(self, kinds): - '''Close the servers of the given kinds (TCP etc.).''' + """Close the servers of the given kinds (TCP etc.).""" if kinds: self.logger.info('closing down {} listening servers' .format(', '.join(kinds))) @@ -203,7 +203,7 @@ class SessionManager: paused = False async def _log_sessions(self): - '''Periodically log sessions.''' + """Periodically log sessions.""" log_interval = self.env.log_sessions if log_interval: while True: @@ -247,7 +247,7 @@ class SessionManager: return result async def _clear_stale_sessions(self): - '''Cut off sessions that haven't done anything for 10 minutes.''' + """Cut off sessions that haven't done anything for 10 minutes.""" while True: await sleep(60) stale_cutoff = time.time() - self.env.session_timeout @@ -276,7 +276,7 @@ class SessionManager: session.group = new_group def _get_info(self): - '''A summary of server state.''' + """A summary of server state.""" group_map = self._group_map() return { 'closing': len([s for s in self.sessions if s.is_closing()]), @@ -298,7 +298,7 @@ class SessionManager: } def _session_data(self, for_log): - '''Returned to the RPC 'sessions' call.''' + """Returned to the RPC 'sessions' call.""" now = time.time() sessions = sorted(self.sessions, key=lambda s: s.start_time) return [(session.session_id, @@ -315,7 +315,7 @@ class SessionManager: for session in sessions] def _group_data(self): - '''Returned to the RPC 'groups' call.''' + """Returned to the RPC 'groups' call.""" result = [] group_map = self._group_map() for group, sessions in group_map.items(): @@ -338,9 +338,9 @@ class SessionManager: return electrum_header, raw_header async def _refresh_hsub_results(self, height): - '''Refresh the cached header subscription responses to be for height, + """Refresh the cached header subscription responses to be for height, and record that as notified_height. - ''' + """ # Paranoia: a reorg could race and leave db_height lower height = min(height, self.db.db_height) electrum, raw = await self._electrum_and_raw_headers(height) @@ -350,39 +350,39 @@ class SessionManager: # --- LocalRPC command handlers async def rpc_add_peer(self, real_name): - '''Add a peer. + """Add a peer. real_name: "bch.electrumx.cash t50001 s50002" for example - ''' + """ await self.peer_mgr.add_localRPC_peer(real_name) return "peer '{}' added".format(real_name) async def rpc_disconnect(self, session_ids): - '''Disconnect sesssions. + """Disconnect sesssions. session_ids: array of session IDs - ''' + """ async def close(session): - '''Close the session's transport.''' + """Close the session's transport.""" await session.close(force_after=2) return f'disconnected {session.session_id}' return await self._for_each_session(session_ids, close) async def rpc_log(self, session_ids): - '''Toggle logging of sesssions. + """Toggle logging of sesssions. session_ids: array of session IDs - ''' + """ async def toggle_logging(session): - '''Toggle logging of the session.''' + """Toggle logging of the session.""" session.toggle_logging() return f'log {session.session_id}: {session.log_me}' return await self._for_each_session(session_ids, toggle_logging) async def rpc_daemon_url(self, daemon_url): - '''Replace the daemon URL.''' + """Replace the daemon URL.""" daemon_url = daemon_url or self.env.daemon_url try: self.daemon.set_url(daemon_url) @@ -391,24 +391,24 @@ class SessionManager: return f'now using daemon at {self.daemon.logged_url()}' async def rpc_stop(self): - '''Shut down the server cleanly.''' + """Shut down the server cleanly.""" self.shutdown_event.set() return 'stopping' async def rpc_getinfo(self): - '''Return summary information about the server process.''' + """Return summary information about the server process.""" return self._get_info() async def rpc_groups(self): - '''Return statistics about the session groups.''' + """Return statistics about the session groups.""" return self._group_data() async def rpc_peers(self): - '''Return a list of data about server peers.''' + """Return a list of data about server peers.""" return self.peer_mgr.rpc_data() async def rpc_query(self, items, limit): - '''Return a list of data about server peers.''' + """Return a list of data about server peers.""" coin = self.env.coin db = self.db lines = [] @@ -459,14 +459,14 @@ class SessionManager: return lines async def rpc_sessions(self): - '''Return statistics about connected sessions.''' + """Return statistics about connected sessions.""" return self._session_data(for_log=False) async def rpc_reorg(self, count): - '''Force a reorg of the given number of blocks. + """Force a reorg of the given number of blocks. count: number of blocks to reorg - ''' + """ count = non_negative_integer(count) if not self.bp.force_chain_reorg(count): raise RPCError(BAD_REQUEST, 'still catching up with daemon') @@ -475,8 +475,8 @@ class SessionManager: # --- External Interface async def serve(self, notifications, server_listening_event): - '''Start the RPC server if enabled. When the event is triggered, - start TCP and SSL servers.''' + """Start the RPC server if enabled. When the event is triggered, + start TCP and SSL servers.""" try: if self.env.rpc_port is not None: await self._start_server('RPC', self.env.cs_host(for_rpc=True), @@ -515,18 +515,18 @@ class SessionManager: ]) def session_count(self): - '''The number of connections that we've sent something to.''' + """The number of connections that we've sent something to.""" return len(self.sessions) async def daemon_request(self, method, *args): - '''Catch a DaemonError and convert it to an RPCError.''' + """Catch a DaemonError and convert it to an RPCError.""" try: return await getattr(self.daemon, method)(*args) except DaemonError as e: raise RPCError(DAEMON_ERROR, f'daemon error: {e!r}') from None async def raw_header(self, height): - '''Return the binary header at the given height.''' + """Return the binary header at the given height.""" try: return await self.db.raw_header(height) except IndexError: @@ -534,7 +534,7 @@ class SessionManager: 'out of range') from None async def electrum_header(self, height): - '''Return the deserialized header at the given height.''' + """Return the deserialized header at the given height.""" electrum_header, _ = await self._electrum_and_raw_headers(height) return electrum_header @@ -544,7 +544,7 @@ class SessionManager: return hex_hash async def limited_history(self, hashX): - '''A caching layer.''' + """A caching layer.""" hc = self.history_cache if hashX not in hc: # History DoS limit. Each element of history is about 99 @@ -556,7 +556,7 @@ class SessionManager: return hc[hashX] async def _notify_sessions(self, height, touched): - '''Notify sessions about height changes and touched addresses.''' + """Notify sessions about height changes and touched addresses.""" height_changed = height != self.notified_height if height_changed: await self._refresh_hsub_results(height) @@ -579,7 +579,7 @@ class SessionManager: return self.cur_group def remove_session(self, session): - '''Remove a session from our sessions list if there.''' + """Remove a session from our sessions list if there.""" self.sessions.remove(session) self.session_event.set() @@ -593,11 +593,11 @@ class SessionManager: class SessionBase(RPCSession): - '''Base class of ElectrumX JSON sessions. + """Base class of ElectrumX JSON sessions. Each session runs its tasks in asynchronous parallelism with other sessions. - ''' + """ MAX_CHUNK_SIZE = 2016 session_counter = itertools.count() @@ -627,8 +627,8 @@ class SessionBase(RPCSession): pass def peer_address_str(self, *, for_log=True): - '''Returns the peer's IP address and port as a human-readable - string, respecting anon logs if the output is for a log.''' + """Returns the peer's IP address and port as a human-readable + string, respecting anon logs if the output is for a log.""" if for_log and self.anon_logs: return 'xx.xx.xx.xx:xx' return super().peer_address_str() @@ -642,7 +642,7 @@ class SessionBase(RPCSession): self.log_me = not self.log_me def flags(self): - '''Status flags.''' + """Status flags.""" status = self.kind[0] if self.is_closing(): status += 'C' @@ -652,7 +652,7 @@ class SessionBase(RPCSession): return status def connection_made(self, transport): - '''Handle an incoming client connection.''' + """Handle an incoming client connection.""" super().connection_made(transport) self.session_id = next(self.session_counter) context = {'conn_id': f'{self.session_id}'} @@ -662,7 +662,7 @@ class SessionBase(RPCSession): f'{self.session_mgr.session_count():,d} total') def connection_lost(self, exc): - '''Handle client disconnection.''' + """Handle client disconnection.""" super().connection_lost(exc) self.session_mgr.remove_session(self) msg = '' @@ -687,9 +687,9 @@ class SessionBase(RPCSession): return 0 async def handle_request(self, request): - '''Handle an incoming request. ElectrumX doesn't receive + """Handle an incoming request. ElectrumX doesn't receive notifications from client sessions. - ''' + """ if isinstance(request, Request): handler = self.request_handlers.get(request.method) else: @@ -699,7 +699,7 @@ class SessionBase(RPCSession): class ElectrumX(SessionBase): - '''A TCP server that handles incoming Electrum connections.''' + """A TCP server that handles incoming Electrum connections.""" PROTOCOL_MIN = (1, 1) PROTOCOL_MAX = (1, 4) @@ -722,7 +722,7 @@ class ElectrumX(SessionBase): @classmethod def server_features(cls, env): - '''Return the server features dictionary.''' + """Return the server features dictionary.""" min_str, max_str = cls.protocol_min_max_strings() return { 'hosts': env.hosts_dict(), @@ -739,7 +739,7 @@ class ElectrumX(SessionBase): @classmethod def server_version_args(cls): - '''The arguments to a server.version RPC call to a peer.''' + """The arguments to a server.version RPC call to a peer.""" return [torba.__version__, cls.protocol_min_max_strings()] def protocol_version_string(self): @@ -749,9 +749,9 @@ class ElectrumX(SessionBase): return len(self.hashX_subs) async def notify(self, touched, height_changed): - '''Notify the client about changes to touched addresses (from mempool + """Notify the client about changes to touched addresses (from mempool updates or new blocks) and height. - ''' + """ if height_changed and self.subscribe_headers: args = (await self.subscribe_headers_result(), ) await self.send_notification('blockchain.headers.subscribe', args) @@ -789,40 +789,40 @@ class ElectrumX(SessionBase): self.logger.info(f'notified of {len(changed):,d} address{es}') async def subscribe_headers_result(self): - '''The result of a header subscription or notification.''' + """The result of a header subscription or notification.""" return self.session_mgr.hsub_results[self.subscribe_headers_raw] async def _headers_subscribe(self, raw): - '''Subscribe to get headers of new blocks.''' + """Subscribe to get headers of new blocks.""" self.subscribe_headers_raw = assert_boolean(raw) self.subscribe_headers = True return await self.subscribe_headers_result() async def headers_subscribe(self): - '''Subscribe to get raw headers of new blocks.''' + """Subscribe to get raw headers of new blocks.""" return await self._headers_subscribe(True) async def headers_subscribe_True(self, raw=True): - '''Subscribe to get headers of new blocks.''' + """Subscribe to get headers of new blocks.""" return await self._headers_subscribe(raw) async def headers_subscribe_False(self, raw=False): - '''Subscribe to get headers of new blocks.''' + """Subscribe to get headers of new blocks.""" return await self._headers_subscribe(raw) async def add_peer(self, features): - '''Add a peer (but only if the peer resolves to the source).''' + """Add a peer (but only if the peer resolves to the source).""" return await self.peer_mgr.on_add_peer(features, self.peer_address()) async def peers_subscribe(self): - '''Return the server peers as a list of (ip, host, details) tuples.''' + """Return the server peers as a list of (ip, host, details) tuples.""" return self.peer_mgr.on_peers_subscribe(self.is_tor()) async def address_status(self, hashX): - '''Returns an address status. + """Returns an address status. Status is a hex string, but must be None if there is no history. - ''' + """ # Note history is ordered and mempool unordered in electrum-server # For mempool, height is -1 if it has unconfirmed inputs, otherwise 0 db_history = await self.session_mgr.limited_history(hashX) @@ -847,8 +847,8 @@ class ElectrumX(SessionBase): return status async def hashX_listunspent(self, hashX): - '''Return the list of UTXOs of a script hash, including mempool - effects.''' + """Return the list of UTXOs of a script hash, including mempool + effects.""" utxos = await self.db.all_utxos(hashX) utxos = sorted(utxos) utxos.extend(await self.mempool.unordered_UTXOs(hashX)) @@ -879,29 +879,29 @@ class ElectrumX(SessionBase): raise RPCError(BAD_REQUEST, f'{address} is not a valid address') async def address_get_balance(self, address): - '''Return the confirmed and unconfirmed balance of an address.''' + """Return the confirmed and unconfirmed balance of an address.""" hashX = self.address_to_hashX(address) return await self.get_balance(hashX) async def address_get_history(self, address): - '''Return the confirmed and unconfirmed history of an address.''' + """Return the confirmed and unconfirmed history of an address.""" hashX = self.address_to_hashX(address) return await self.confirmed_and_unconfirmed_history(hashX) async def address_get_mempool(self, address): - '''Return the mempool transactions touching an address.''' + """Return the mempool transactions touching an address.""" hashX = self.address_to_hashX(address) return await self.unconfirmed_history(hashX) async def address_listunspent(self, address): - '''Return the list of UTXOs of an address.''' + """Return the list of UTXOs of an address.""" hashX = self.address_to_hashX(address) return await self.hashX_listunspent(hashX) async def address_subscribe(self, address): - '''Subscribe to an address. + """Subscribe to an address. - address: the address to subscribe to''' + address: the address to subscribe to""" hashX = self.address_to_hashX(address) return await self.hashX_subscribe(hashX, address) @@ -912,7 +912,7 @@ class ElectrumX(SessionBase): return {'confirmed': confirmed, 'unconfirmed': unconfirmed} async def scripthash_get_balance(self, scripthash): - '''Return the confirmed and unconfirmed balance of a scripthash.''' + """Return the confirmed and unconfirmed balance of a scripthash.""" hashX = scripthash_to_hashX(scripthash) return await self.get_balance(hashX) @@ -932,24 +932,24 @@ class ElectrumX(SessionBase): return conf + await self.unconfirmed_history(hashX) async def scripthash_get_history(self, scripthash): - '''Return the confirmed and unconfirmed history of a scripthash.''' + """Return the confirmed and unconfirmed history of a scripthash.""" hashX = scripthash_to_hashX(scripthash) return await self.confirmed_and_unconfirmed_history(hashX) async def scripthash_get_mempool(self, scripthash): - '''Return the mempool transactions touching a scripthash.''' + """Return the mempool transactions touching a scripthash.""" hashX = scripthash_to_hashX(scripthash) return await self.unconfirmed_history(hashX) async def scripthash_listunspent(self, scripthash): - '''Return the list of UTXOs of a scripthash.''' + """Return the list of UTXOs of a scripthash.""" hashX = scripthash_to_hashX(scripthash) return await self.hashX_listunspent(hashX) async def scripthash_subscribe(self, scripthash): - '''Subscribe to a script hash. + """Subscribe to a script hash. - scripthash: the SHA256 hash of the script to subscribe to''' + scripthash: the SHA256 hash of the script to subscribe to""" hashX = scripthash_to_hashX(scripthash) return await self.hashX_subscribe(hashX, scripthash) @@ -968,8 +968,8 @@ class ElectrumX(SessionBase): } async def block_header(self, height, cp_height=0): - '''Return a raw block header as a hexadecimal string, or as a - dictionary with a merkle proof.''' + """Return a raw block header as a hexadecimal string, or as a + dictionary with a merkle proof.""" height = non_negative_integer(height) cp_height = non_negative_integer(cp_height) raw_header_hex = (await self.session_mgr.raw_header(height)).hex() @@ -980,18 +980,18 @@ class ElectrumX(SessionBase): return result async def block_header_13(self, height): - '''Return a raw block header as a hexadecimal string. + """Return a raw block header as a hexadecimal string. - height: the header's height''' + height: the header's height""" return await self.block_header(height) async def block_headers(self, start_height, count, cp_height=0): - '''Return count concatenated block headers as hex for the main chain; + """Return count concatenated block headers as hex for the main chain; starting at start_height. start_height and count must be non-negative integers. At most MAX_CHUNK_SIZE headers will be returned. - ''' + """ start_height = non_negative_integer(start_height) count = non_negative_integer(count) cp_height = non_negative_integer(cp_height) @@ -1009,9 +1009,9 @@ class ElectrumX(SessionBase): return await self.block_headers(start_height, count) async def block_get_chunk(self, index): - '''Return a chunk of block headers as a hexadecimal string. + """Return a chunk of block headers as a hexadecimal string. - index: the chunk index''' + index: the chunk index""" index = non_negative_integer(index) size = self.coin.CHUNK_SIZE start_height = index * size @@ -1019,15 +1019,15 @@ class ElectrumX(SessionBase): return headers.hex() async def block_get_header(self, height): - '''The deserialized header at a given height. + """The deserialized header at a given height. - height: the header's height''' + height: the header's height""" height = non_negative_integer(height) return await self.session_mgr.electrum_header(height) def is_tor(self): - '''Try to detect if the connection is to a tor hidden service we are - running.''' + """Try to detect if the connection is to a tor hidden service we are + running.""" peername = self.peer_mgr.proxy_peername() if not peername: return False @@ -1051,11 +1051,11 @@ class ElectrumX(SessionBase): return banner async def donation_address(self): - '''Return the donation address as a string, empty if there is none.''' + """Return the donation address as a string, empty if there is none.""" return self.env.donation_address async def banner(self): - '''Return the server banner text.''' + """Return the server banner text.""" banner = f'You are connected to an {torba.__version__} server.' if self.is_tor(): @@ -1074,31 +1074,31 @@ class ElectrumX(SessionBase): return banner async def relayfee(self): - '''The minimum fee a low-priority tx must pay in order to be accepted - to the daemon's memory pool.''' + """The minimum fee a low-priority tx must pay in order to be accepted + to the daemon's memory pool.""" return await self.daemon_request('relayfee') async def estimatefee(self, number): - '''The estimated transaction fee per kilobyte to be paid for a + """The estimated transaction fee per kilobyte to be paid for a transaction to be included within a certain number of blocks. number: the number of blocks - ''' + """ number = non_negative_integer(number) return await self.daemon_request('estimatefee', number) async def ping(self): - '''Serves as a connection keep-alive mechanism and for the client to + """Serves as a connection keep-alive mechanism and for the client to confirm the server is still responding. - ''' + """ return None async def server_version(self, client_name='', protocol_version=None): - '''Returns the server version as a string. + """Returns the server version as a string. client_name: a string identifying the client protocol_version: the protocol version spoken by the client - ''' + """ if self.sv_seen and self.protocol_tuple >= (1, 4): raise RPCError(BAD_REQUEST, f'server.version already sent') self.sv_seen = True @@ -1129,9 +1129,9 @@ class ElectrumX(SessionBase): return torba.__version__, self.protocol_version_string() async def transaction_broadcast(self, raw_tx): - '''Broadcast a raw transaction to the network. + """Broadcast a raw transaction to the network. - raw_tx: the raw transaction as a hexadecimal string''' + raw_tx: the raw transaction as a hexadecimal string""" # This returns errors as JSON RPC errors, as is natural try: hex_hash = await self.session_mgr.broadcast_transaction(raw_tx) @@ -1146,11 +1146,11 @@ class ElectrumX(SessionBase): f'network rules.\n\n{message}\n[{raw_tx}]') async def transaction_get(self, tx_hash, verbose=False): - '''Return the serialized raw transaction given its hash + """Return the serialized raw transaction given its hash tx_hash: the transaction hash as a hexadecimal string verbose: passed on to the daemon - ''' + """ assert_tx_hash(tx_hash) if verbose not in (True, False): raise RPCError(BAD_REQUEST, f'"verbose" must be a boolean') @@ -1158,12 +1158,12 @@ class ElectrumX(SessionBase): return await self.daemon_request('getrawtransaction', tx_hash, verbose) async def _block_hash_and_tx_hashes(self, height): - '''Returns a pair (block_hash, tx_hashes) for the main chain block at + """Returns a pair (block_hash, tx_hashes) for the main chain block at the given height. block_hash is a hexadecimal string, and tx_hashes is an ordered list of hexadecimal strings. - ''' + """ height = non_negative_integer(height) hex_hashes = await self.daemon_request('block_hex_hashes', height, 1) block_hash = hex_hashes[0] @@ -1171,23 +1171,23 @@ class ElectrumX(SessionBase): return block_hash, block['tx'] def _get_merkle_branch(self, tx_hashes, tx_pos): - '''Return a merkle branch to a transaction. + """Return a merkle branch to a transaction. tx_hashes: ordered list of hex strings of tx hashes in a block tx_pos: index of transaction in tx_hashes to create branch for - ''' + """ hashes = [hex_str_to_hash(hash) for hash in tx_hashes] branch, root = self.db.merkle.branch_and_root(hashes, tx_pos) branch = [hash_to_hex_str(hash) for hash in branch] return branch async def transaction_merkle(self, tx_hash, height): - '''Return the markle branch to a confirmed transaction given its hash + """Return the markle branch to a confirmed transaction given its hash and height. tx_hash: the transaction hash as a hexadecimal string height: the height of the block it is in - ''' + """ assert_tx_hash(tx_hash) block_hash, tx_hashes = await self._block_hash_and_tx_hashes(height) try: @@ -1199,9 +1199,9 @@ class ElectrumX(SessionBase): return {"block_height": height, "merkle": branch, "pos": pos} async def transaction_id_from_pos(self, height, tx_pos, merkle=False): - '''Return the txid and optionally a merkle proof, given + """Return the txid and optionally a merkle proof, given a block height and position in the block. - ''' + """ tx_pos = non_negative_integer(tx_pos) if merkle not in (True, False): raise RPCError(BAD_REQUEST, f'"merkle" must be a boolean') @@ -1279,7 +1279,7 @@ class ElectrumX(SessionBase): class LocalRPC(SessionBase): - '''A local TCP RPC server session.''' + """A local TCP RPC server session.""" def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) @@ -1291,7 +1291,7 @@ class LocalRPC(SessionBase): class DashElectrumX(ElectrumX): - '''A TCP server that handles incoming Electrum Dash connections.''' + """A TCP server that handles incoming Electrum Dash connections.""" def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) @@ -1307,7 +1307,7 @@ class DashElectrumX(ElectrumX): }) async def notify(self, touched, height_changed): - '''Notify the client about changes in masternode list.''' + """Notify the client about changes in masternode list.""" await super().notify(touched, height_changed) for mn in self.mns: status = await self.daemon_request('masternode_list', @@ -1317,10 +1317,10 @@ class DashElectrumX(ElectrumX): # Masternode command handlers async def masternode_announce_broadcast(self, signmnb): - '''Pass through the masternode announce message to be broadcast + """Pass through the masternode announce message to be broadcast by the daemon. - signmnb: signed masternode broadcast message.''' + signmnb: signed masternode broadcast message.""" try: return await self.daemon_request('masternode_broadcast', ['relay', signmnb]) @@ -1332,10 +1332,10 @@ class DashElectrumX(ElectrumX): f'rejected.\n\n{message}\n[{signmnb}]') async def masternode_subscribe(self, collateral): - '''Returns the status of masternode. + """Returns the status of masternode. collateral: masternode collateral. - ''' + """ result = await self.daemon_request('masternode_list', ['status', collateral]) if result is not None: @@ -1344,20 +1344,20 @@ class DashElectrumX(ElectrumX): return None async def masternode_list(self, payees): - ''' + """ Returns the list of masternodes. payees: a list of masternode payee addresses. - ''' + """ if not isinstance(payees, list): raise RPCError(BAD_REQUEST, 'expected a list of payees') def get_masternode_payment_queue(mns): - '''Returns the calculated position in the payment queue for all the + """Returns the calculated position in the payment queue for all the valid masterernodes in the given mns list. mns: a list of masternodes information. - ''' + """ now = int(datetime.datetime.utcnow().strftime("%s")) mn_queue = [] @@ -1383,12 +1383,12 @@ class DashElectrumX(ElectrumX): return mn_queue def get_payment_position(payment_queue, address): - ''' + """ Returns the position of the payment list for the given address. payment_queue: position in the payment queue for the masternode. address: masternode payee address. - ''' + """ position = -1 for pos, mn in enumerate(payment_queue, start=1): if mn[2] == address: diff --git a/torba/server/storage.py b/torba/server/storage.py index f4c92f90d..d52d2eba7 100644 --- a/torba/server/storage.py +++ b/torba/server/storage.py @@ -5,7 +5,7 @@ # See the file "LICENCE" for information about the copyright # and warranty status of this software. -'''Backend database abstraction.''' +"""Backend database abstraction.""" import os from functools import partial @@ -14,7 +14,7 @@ from torba.server import util def db_class(name): - '''Returns a DB engine class.''' + """Returns a DB engine class.""" for db_class in util.subclasses(Storage): if db_class.__name__.lower() == name.lower(): db_class.import_module() @@ -23,7 +23,7 @@ def db_class(name): class Storage: - '''Abstract base class of the DB backend abstraction.''' + """Abstract base class of the DB backend abstraction.""" def __init__(self, name, for_sync): self.is_new = not os.path.exists(name) @@ -32,15 +32,15 @@ class Storage: @classmethod def import_module(cls): - '''Import the DB engine module.''' + """Import the DB engine module.""" raise NotImplementedError def open(self, name, create): - '''Open an existing database or create a new one.''' + """Open an existing database or create a new one.""" raise NotImplementedError def close(self): - '''Close an existing database.''' + """Close an existing database.""" raise NotImplementedError def get(self, key): @@ -50,26 +50,26 @@ class Storage: raise NotImplementedError def write_batch(self): - '''Return a context manager that provides `put` and `delete`. + """Return a context manager that provides `put` and `delete`. Changes should only be committed when the context manager closes without an exception. - ''' + """ raise NotImplementedError def iterator(self, prefix=b'', reverse=False): - '''Return an iterator that yields (key, value) pairs from the + """Return an iterator that yields (key, value) pairs from the database sorted by key. If `prefix` is set, only keys starting with `prefix` will be included. If `reverse` is True the items are returned in reverse order. - ''' + """ raise NotImplementedError class LevelDB(Storage): - '''LevelDB database engine.''' + """LevelDB database engine.""" @classmethod def import_module(cls): @@ -90,7 +90,7 @@ class LevelDB(Storage): class RocksDB(Storage): - '''RocksDB database engine.''' + """RocksDB database engine.""" @classmethod def import_module(cls): @@ -122,7 +122,7 @@ class RocksDB(Storage): class RocksDBWriteBatch: - '''A write batch for RocksDB.''' + """A write batch for RocksDB.""" def __init__(self, db): self.batch = RocksDB.module.WriteBatch() @@ -137,7 +137,7 @@ class RocksDBWriteBatch: class RocksDBIterator: - '''An iterator for RocksDB.''' + """An iterator for RocksDB.""" def __init__(self, db, prefix, reverse): self.prefix = prefix diff --git a/torba/server/text.py b/torba/server/text.py index 7677353ca..800ba0be3 100644 --- a/torba/server/text.py +++ b/torba/server/text.py @@ -4,9 +4,9 @@ from torba.server import util def sessions_lines(data): - '''A generator returning lines for a list of sessions. + """A generator returning lines for a list of sessions. - data is the return value of rpc_sessions().''' + data is the return value of rpc_sessions().""" fmt = ('{:<6} {:<5} {:>17} {:>5} {:>5} {:>5} ' '{:>7} {:>7} {:>7} {:>7} {:>7} {:>9} {:>21}') yield fmt.format('ID', 'Flags', 'Client', 'Proto', @@ -26,9 +26,9 @@ def sessions_lines(data): def groups_lines(data): - '''A generator returning lines for a list of groups. + """A generator returning lines for a list of groups. - data is the return value of rpc_groups().''' + data is the return value of rpc_groups().""" fmt = ('{:<6} {:>9} {:>9} {:>6} {:>6} {:>8}' '{:>7} {:>9} {:>7} {:>9}') @@ -49,9 +49,9 @@ def groups_lines(data): def peers_lines(data): - '''A generator returning lines for a list of peers. + """A generator returning lines for a list of peers. - data is the return value of rpc_peers().''' + data is the return value of rpc_peers().""" def time_fmt(t): if not t: return 'Never' diff --git a/torba/server/tx.py b/torba/server/tx.py index a85a2ccdb..212589d54 100644 --- a/torba/server/tx.py +++ b/torba/server/tx.py @@ -25,7 +25,7 @@ # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # and warranty status of this software. -'''Transaction-related classes and functions.''' +"""Transaction-related classes and functions.""" from collections import namedtuple @@ -42,7 +42,7 @@ MINUS_1 = 4294967295 class Tx(namedtuple("Tx", "version inputs outputs locktime")): - '''Class representing a transaction.''' + """Class representing a transaction.""" def serialize(self): return b''.join(( @@ -56,7 +56,7 @@ class Tx(namedtuple("Tx", "version inputs outputs locktime")): class TxInput(namedtuple("TxInput", "prev_hash prev_idx script sequence")): - '''Class representing a transaction input.''' + """Class representing a transaction input.""" def __str__(self): script = self.script.hex() prev_hash = hash_to_hex_str(self.prev_hash) @@ -64,7 +64,7 @@ class TxInput(namedtuple("TxInput", "prev_hash prev_idx script sequence")): .format(prev_hash, self.prev_idx, script, self.sequence)) def is_generation(self): - '''Test if an input is generation/coinbase like''' + """Test if an input is generation/coinbase like""" return self.prev_idx == MINUS_1 and self.prev_hash == ZERO def serialize(self): @@ -86,14 +86,14 @@ class TxOutput(namedtuple("TxOutput", "value pk_script")): class Deserializer: - '''Deserializes blocks into transactions. + """Deserializes blocks into transactions. External entry points are read_tx(), read_tx_and_hash(), read_tx_and_vsize() and read_block(). This code is performance sensitive as it is executed 100s of millions of times during sync. - ''' + """ TX_HASH_FN = staticmethod(double_sha256) @@ -104,7 +104,7 @@ class Deserializer: self.cursor = start def read_tx(self): - '''Return a deserialized transaction.''' + """Return a deserialized transaction.""" return Tx( self._read_le_int32(), # version self._read_inputs(), # inputs @@ -113,20 +113,20 @@ class Deserializer: ) def read_tx_and_hash(self): - '''Return a (deserialized TX, tx_hash) pair. + """Return a (deserialized TX, tx_hash) pair. The hash needs to be reversed for human display; for efficiency we process it in the natural serialized order. - ''' + """ start = self.cursor return self.read_tx(), self.TX_HASH_FN(self.binary[start:self.cursor]) def read_tx_and_vsize(self): - '''Return a (deserialized TX, vsize) pair.''' + """Return a (deserialized TX, vsize) pair.""" return self.read_tx(), self.binary_length def read_tx_block(self): - '''Returns a list of (deserialized_tx, tx_hash) pairs.''' + """Returns a list of (deserialized_tx, tx_hash) pairs.""" read = self.read_tx_and_hash # Some coins have excess data beyond the end of the transactions return [read() for _ in range(self._read_varint())] @@ -206,7 +206,7 @@ class Deserializer: class TxSegWit(namedtuple("Tx", "version marker flag inputs outputs " "witness locktime")): - '''Class representing a SegWit transaction.''' + """Class representing a SegWit transaction.""" class DeserializerSegWit(Deserializer): @@ -222,7 +222,7 @@ class DeserializerSegWit(Deserializer): return [read_varbytes() for i in range(self._read_varint())] def _read_tx_parts(self): - '''Return a (deserialized TX, tx_hash, vsize) tuple.''' + """Return a (deserialized TX, tx_hash, vsize) tuple.""" start = self.cursor marker = self.binary[self.cursor + 4] if marker: @@ -269,7 +269,7 @@ class DeserializerAuxPow(Deserializer): VERSION_AUXPOW = (1 << 8) def read_header(self, height, static_header_size): - '''Return the AuxPow block header bytes''' + """Return the AuxPow block header bytes""" start = self.cursor version = self._read_le_uint32() if version & self.VERSION_AUXPOW: @@ -298,7 +298,7 @@ class DeserializerAuxPowSegWit(DeserializerSegWit, DeserializerAuxPow): class DeserializerEquihash(Deserializer): def read_header(self, height, static_header_size): - '''Return the block header bytes''' + """Return the block header bytes""" start = self.cursor # We are going to calculate the block size then read it as bytes self.cursor += static_header_size @@ -314,7 +314,7 @@ class DeserializerEquihashSegWit(DeserializerSegWit, DeserializerEquihash): class TxJoinSplit(namedtuple("Tx", "version inputs outputs locktime")): - '''Class representing a JoinSplit transaction.''' + """Class representing a JoinSplit transaction.""" class DeserializerZcash(DeserializerEquihash): @@ -365,7 +365,7 @@ class DeserializerZcash(DeserializerEquihash): class TxTime(namedtuple("Tx", "version time inputs outputs locktime")): - '''Class representing transaction that has a time field.''' + """Class representing transaction that has a time field.""" class DeserializerTxTime(Deserializer): @@ -406,7 +406,7 @@ class DeserializerTxTimeAuxPow(DeserializerTxTime): return False def read_header(self, height, static_header_size): - '''Return the AuxPow block header bytes''' + """Return the AuxPow block header bytes""" start = self.cursor version = self._read_le_uint32() if version & self.VERSION_AUXPOW: @@ -433,7 +433,7 @@ class DeserializerBitcoinAtom(DeserializerSegWit): FORK_BLOCK_HEIGHT = 505888 def read_header(self, height, static_header_size): - '''Return the block header bytes''' + """Return the block header bytes""" header_len = static_header_size if height >= self.FORK_BLOCK_HEIGHT: header_len += 4 # flags @@ -445,7 +445,7 @@ class DeserializerGroestlcoin(DeserializerSegWit): class TxInputTokenPay(TxInput): - '''Class representing a TokenPay transaction input.''' + """Class representing a TokenPay transaction input.""" OP_ANON_MARKER = 0xb9 # 2byte marker (cpubkey + sigc + sigr) @@ -468,7 +468,7 @@ class TxInputTokenPay(TxInput): class TxInputTokenPayStealth( namedtuple("TxInput", "keyimage ringsize script sequence")): - '''Class representing a TokenPay stealth transaction input.''' + """Class representing a TokenPay stealth transaction input.""" def __str__(self): script = self.script.hex() @@ -514,7 +514,7 @@ class DeserializerTokenPay(DeserializerTxTime): # Decred class TxInputDcr(namedtuple("TxInput", "prev_hash prev_idx tree sequence")): - '''Class representing a Decred transaction input.''' + """Class representing a Decred transaction input.""" def __str__(self): prev_hash = hash_to_hex_str(self.prev_hash) @@ -522,18 +522,18 @@ class TxInputDcr(namedtuple("TxInput", "prev_hash prev_idx tree sequence")): .format(prev_hash, self.prev_idx, self.tree, self.sequence)) def is_generation(self): - '''Test if an input is generation/coinbase like''' + """Test if an input is generation/coinbase like""" return self.prev_idx == MINUS_1 and self.prev_hash == ZERO class TxOutputDcr(namedtuple("TxOutput", "value version pk_script")): - '''Class representing a Decred transaction output.''' + """Class representing a Decred transaction output.""" pass class TxDcr(namedtuple("Tx", "version inputs outputs locktime expiry " "witness")): - '''Class representing a Decred transaction.''' + """Class representing a Decred transaction.""" class DeserializerDecred(Deserializer): @@ -559,14 +559,14 @@ class DeserializerDecred(Deserializer): return tx, vsize def read_tx_block(self): - '''Returns a list of (deserialized_tx, tx_hash) pairs.''' + """Returns a list of (deserialized_tx, tx_hash) pairs.""" read = self.read_tx_and_hash txs = [read() for _ in range(self._read_varint())] stxs = [read() for _ in range(self._read_varint())] return txs + stxs def read_tx_tree(self): - '''Returns a list of deserialized_tx without tx hashes.''' + """Returns a list of deserialized_tx without tx hashes.""" read_tx = self.read_tx return [read_tx() for _ in range(self._read_varint())] diff --git a/torba/server/util.py b/torba/server/util.py index 7f36d8cd7..74dfb9566 100644 --- a/torba/server/util.py +++ b/torba/server/util.py @@ -24,7 +24,7 @@ # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # and warranty status of this software. -'''Miscellaneous utility classes and functions.''' +"""Miscellaneous utility classes and functions.""" import array @@ -40,21 +40,21 @@ from struct import pack, Struct class ConnectionLogger(logging.LoggerAdapter): - '''Prepends a connection identifier to a logging message.''' + """Prepends a connection identifier to a logging message.""" def process(self, msg, kwargs): conn_id = self.extra.get('conn_id', 'unknown') return f'[{conn_id}] {msg}', kwargs class CompactFormatter(logging.Formatter): - '''Strips the module from the logger name to leave the class only.''' + """Strips the module from the logger name to leave the class only.""" def format(self, record): record.name = record.name.rpartition('.')[-1] return super().format(record) def make_logger(name, *, handler, level): - '''Return the root ElectrumX logger.''' + """Return the root ElectrumX logger.""" logger = logging.getLogger(name) logger.addHandler(handler) logger.setLevel(logging.INFO) @@ -63,7 +63,7 @@ def make_logger(name, *, handler, level): def class_logger(path, classname): - '''Return a hierarchical logger for a class.''' + """Return a hierarchical logger for a class.""" return logging.getLogger(path).getChild(classname) @@ -83,8 +83,8 @@ class cachedproperty: def formatted_time(t, sep=' '): - '''Return a number of seconds as a string in days, hours, mins and - maybe secs.''' + """Return a number of seconds as a string in days, hours, mins and + maybe secs.""" t = int(t) fmts = (('{:d}d', 86400), ('{:02d}h', 3600), ('{:02d}m', 60)) parts = [] @@ -136,7 +136,7 @@ def deep_getsizeof(obj): def subclasses(base_class, strict=True): - '''Return a list of subclasses of base_class in its module.''' + """Return a list of subclasses of base_class in its module.""" def select(obj): return (inspect.isclass(obj) and issubclass(obj, base_class) and (not strict or obj != base_class)) @@ -146,7 +146,7 @@ def subclasses(base_class, strict=True): def chunks(items, size): - '''Break up items, an iterable, into chunks of length size.''' + """Break up items, an iterable, into chunks of length size.""" for i in range(0, len(items), size): yield items[i: i + size] @@ -159,19 +159,19 @@ def resolve_limit(limit): def bytes_to_int(be_bytes): - '''Interprets a big-endian sequence of bytes as an integer''' + """Interprets a big-endian sequence of bytes as an integer""" return int.from_bytes(be_bytes, 'big') def int_to_bytes(value): - '''Converts an integer to a big-endian sequence of bytes''' + """Converts an integer to a big-endian sequence of bytes""" return value.to_bytes((value.bit_length() + 7) // 8, 'big') def increment_byte_string(bs): - '''Return the lexicographically next byte string of the same length. + """Return the lexicographically next byte string of the same length. - Return None if there is none (when the input is all 0xff bytes).''' + Return None if there is none (when the input is all 0xff bytes).""" for n in range(1, len(bs) + 1): if bs[-n] != 0xff: return bs[:-n] + bytes([bs[-n] + 1]) + bytes(n - 1) @@ -179,7 +179,7 @@ def increment_byte_string(bs): class LogicalFile: - '''A logical binary file split across several separate files on disk.''' + """A logical binary file split across several separate files on disk.""" def __init__(self, prefix, digits, file_size): digit_fmt = '{' + ':0{:d}d'.format(digits) + '}' @@ -187,10 +187,10 @@ class LogicalFile: self.file_size = file_size def read(self, start, size=-1): - '''Read up to size bytes from the virtual file, starting at offset + """Read up to size bytes from the virtual file, starting at offset start, and return them. - If size is -1 all bytes are read.''' + If size is -1 all bytes are read.""" parts = [] while size != 0: try: @@ -207,7 +207,7 @@ class LogicalFile: return b''.join(parts) def write(self, start, b): - '''Write the bytes-like object, b, to the underlying virtual file.''' + """Write the bytes-like object, b, to the underlying virtual file.""" while b: size = min(len(b), self.file_size - (start % self.file_size)) with self.open_file(start, True) as f: @@ -216,10 +216,10 @@ class LogicalFile: start += size def open_file(self, start, create): - '''Open the virtual file and seek to start. Return a file handle. + """Open the virtual file and seek to start. Return a file handle. Raise FileNotFoundError if the file does not exist and create is False. - ''' + """ file_num, offset = divmod(start, self.file_size) filename = self.filename_fmt.format(file_num) f = open_file(filename, create) @@ -228,7 +228,7 @@ class LogicalFile: def open_file(filename, create=False): - '''Open the file name. Return its handle.''' + """Open the file name. Return its handle.""" try: return open(filename, 'rb+') except FileNotFoundError: @@ -238,12 +238,12 @@ def open_file(filename, create=False): def open_truncate(filename): - '''Open the file name. Return its handle.''' + """Open the file name. Return its handle.""" return open(filename, 'wb+') def address_string(address): - '''Return an address as a correctly formatted string.''' + """Return an address as a correctly formatted string.""" fmt = '{}:{:d}' host, port = address try: @@ -273,9 +273,9 @@ def is_valid_hostname(hostname): def protocol_tuple(s): - '''Converts a protocol version number, such as "1.0" to a tuple (1, 0). + """Converts a protocol version number, such as "1.0" to a tuple (1, 0). - If the version number is bad, (0, ) indicating version 0 is returned.''' + If the version number is bad, (0, ) indicating version 0 is returned.""" try: return tuple(int(part) for part in s.split('.')) except Exception: @@ -283,22 +283,22 @@ def protocol_tuple(s): def version_string(ptuple): - '''Convert a version tuple such as (1, 2) to "1.2". - There is always at least one dot, so (1, ) becomes "1.0".''' + """Convert a version tuple such as (1, 2) to "1.2". + There is always at least one dot, so (1, ) becomes "1.0".""" while len(ptuple) < 2: ptuple += (0, ) return '.'.join(str(p) for p in ptuple) def protocol_version(client_req, min_tuple, max_tuple): - '''Given a client's protocol version string, return a pair of + """Given a client's protocol version string, return a pair of protocol tuples: (negotiated version, client min request) If the request is unsupported, the negotiated protocol tuple is None. - ''' + """ if client_req is None: client_min = client_max = min_tuple else: From fe446862c2cdb12e145d7747873d17e1ea57d599 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 7 Apr 2019 21:51:02 -0400 Subject: [PATCH 344/383] txo.hash added --- torba/client/basetransaction.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/torba/client/basetransaction.py b/torba/client/basetransaction.py index 3b7c9735d..3e80679e6 100644 --- a/torba/client/basetransaction.py +++ b/torba/client/basetransaction.py @@ -58,6 +58,10 @@ class TXORef: def id(self): return '{}:{}'.format(self.tx_ref.id, self.position) + @property + def hash(self): + return self.tx_ref.hash + BCDataStream.uint32.pack(self.position) + @property def is_null(self): return self.tx_ref.is_null From 30edd53f3e920cbd5d9ae54f623ff5181561de67 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 24 Apr 2019 00:11:14 -0400 Subject: [PATCH 345/383] 0.5.2 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 8ba93204a..784c5831e 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.5.1' +__version__ = '0.5.2' From e7beb6b1a7533d77da6534f60d32a4459d6198d9 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 29 Apr 2019 14:14:31 -0400 Subject: [PATCH 346/383] fix for adding new account from private_key_string --- torba/client/baseaccount.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index 5864655c2..6b0c60cf6 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -256,7 +256,7 @@ class BaseAccount: if seed: private_key = cls.get_private_key_from_seed(ledger, seed, '') public_key = private_key.public_key - elif private_key: + elif private_key_string: private_key = from_extended_key_string(ledger, private_key_string) public_key = private_key.public_key if public_key is None: From a54a11dca0f1961680cf0db17a32a42e2d5ea0c3 Mon Sep 17 00:00:00 2001 From: hackrush Date: Mon, 6 May 2019 01:15:49 +0530 Subject: [PATCH 347/383] Making tests work on OS X --- torba/rpc/socks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/rpc/socks.py b/torba/rpc/socks.py index 776f86a29..64bfe9866 100644 --- a/torba/rpc/socks.py +++ b/torba/rpc/socks.py @@ -322,7 +322,7 @@ class SOCKSProxy(object): return sock except Exception as e: # Don't close - see https://github.com/kyuupichan/aiorpcX/issues/8 - if sys.platform.startswith('linux'): + if sys.platform.startswith('linux') or sys.platform == "darwin": sock.close() return e From 874b3faf8c094932d6451893f0e9c77c335e39e3 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 9 May 2019 17:53:19 -0400 Subject: [PATCH 348/383] use a cache when loading TXs in db.get_txos() --- torba/client/basedatabase.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index d161c8120..1fe0d1784 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -445,14 +445,18 @@ class BaseDatabase(SQLiteMixin): if 'order_by' not in constraints: constraints['order_by'] = ["tx.height=0 DESC", "tx.height DESC", "tx.position DESC"] rows = await self.select_txos( - "raw, tx.height, tx.position, tx.is_verified, txo.position, chain, account", **constraints + "tx.txid, raw, tx.height, tx.position, tx.is_verified, txo.position, chain, account", **constraints ) txos = [] + txs = {} for row in rows: - tx = self.ledger.transaction_class(row[0], height=row[1], position=row[2], is_verified=row[3]) - txo = tx.outputs[row[4]] - txo.is_change = row[5] == 1 - txo.is_my_account = row[6] == my_account + if row[0] not in txs: + txs[row[0]] = self.ledger.transaction_class( + row[1], height=row[2], position=row[3], is_verified=row[4] + ) + txo = txs[row[0]].outputs[row[5]] + txo.is_change = row[6] == 1 + txo.is_my_account = row[7] == my_account txos.append(txo) return txos From fb2d7cbe28ff482bdf51d4b8f86ee97ca79445de Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 9 May 2019 17:56:08 -0400 Subject: [PATCH 349/383] pylint --- torba/client/basedatabase.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 1fe0d1784..0a91d25cd 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -445,7 +445,8 @@ class BaseDatabase(SQLiteMixin): if 'order_by' not in constraints: constraints['order_by'] = ["tx.height=0 DESC", "tx.height DESC", "tx.position DESC"] rows = await self.select_txos( - "tx.txid, raw, tx.height, tx.position, tx.is_verified, txo.position, chain, account", **constraints + "tx.txid, raw, tx.height, tx.position, tx.is_verified, txo.position, chain, account", + **constraints ) txos = [] txs = {} From 2626a28e6d162f657d569c21af8e56f14abdaf3e Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 9 May 2019 18:10:27 -0400 Subject: [PATCH 350/383] 0.5.3 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 784c5831e..06e603569 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.5.2' +__version__ = '0.5.3' From 397ebe842856a4297bea5281206f9fa40a84699c Mon Sep 17 00:00:00 2001 From: hackrush Date: Wed, 8 May 2019 21:07:18 +0530 Subject: [PATCH 351/383] Added DS_Store to .gitignore --- .gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitignore b/.gitignore index dccab0560..61da1711d 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,7 @@ __pycache__/ .mypy_cache/ _trial_temp/ _trial_temp-*/ + +# OS X DS_Store +*.DS_Store + From cfb051396ab12bfc0669eba25b0d9156094791b2 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sat, 6 Apr 2019 18:08:33 -0400 Subject: [PATCH 352/383] sql __in uses proper escaping instead of putting values directly in SQL --- tests/client_tests/unit/test_database.py | 24 ++++++++++++--- torba/client/basedatabase.py | 39 +++++++++++++++--------- torba/client/basenetwork.py | 18 +++++------ torba/server/cli.py | 4 +-- 4 files changed, 56 insertions(+), 29 deletions(-) diff --git a/tests/client_tests/unit/test_database.py b/tests/client_tests/unit/test_database.py index 29aaa684b..d722f62db 100644 --- a/tests/client_tests/unit/test_database.py +++ b/tests/client_tests/unit/test_database.py @@ -76,11 +76,17 @@ class TestQueryBuilder(unittest.TestCase): def test_in(self): self.assertEqual( constraints_to_sql({'txo.age__in': [18, 38]}), - ('txo.age IN (18, 38)', {}) + ('txo.age IN (:txo_age__in0, :txo_age__in1)', { + 'txo_age__in0': 18, + 'txo_age__in1': 38 + }) ) self.assertEqual( - constraints_to_sql({'txo.age__in': ['abc123', 'def456']}), - ("txo.age IN ('abc123', 'def456')", {}) + constraints_to_sql({'txo.name__in': ('abc123', 'def456')}), + ('txo.name IN (:txo_name__in0, :txo_name__in1)', { + 'txo_name__in0': 'abc123', + 'txo_name__in1': 'def456' + }) ) self.assertEqual( constraints_to_sql({'txo.age__in': 'SELECT age from ages_table'}), @@ -90,7 +96,17 @@ class TestQueryBuilder(unittest.TestCase): def test_not_in(self): self.assertEqual( constraints_to_sql({'txo.age__not_in': [18, 38]}), - ('txo.age NOT IN (18, 38)', {}) + ('txo.age NOT IN (:txo_age__not_in0, :txo_age__not_in1)', { + 'txo_age__not_in0': 18, + 'txo_age__not_in1': 38 + }) + ) + self.assertEqual( + constraints_to_sql({'txo.name__not_in': ('abc123', 'def456')}), + ('txo.name NOT IN (:txo_name__not_in0, :txo_name__not_in1)', { + 'txo_name__not_in0': 'abc123', + 'txo_name__not_in1': 'def456' + }) ) self.assertEqual( constraints_to_sql({'txo.age__not_in': 'SELECT age from ages_table'}), diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 0a91d25cd..8e4b9ccdc 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -93,6 +93,14 @@ def constraints_to_sql(constraints, joiner=' AND ', prepend_key=''): continue elif key.endswith('__not'): col, op = col[:-len('__not')], '!=' + elif key.endswith('__is_null'): + col = col[:-len('__is_null')] + sql.append(f'{col} IS NULL') + continue + elif key.endswith('__is_not_null'): + col = col[:-len('__is_not_null')] + sql.append(f'{col} IS NOT NULL') + continue elif key.endswith('__lt'): col, op = col[:-len('__lt')], '<' elif key.endswith('__lte'): @@ -108,23 +116,24 @@ def constraints_to_sql(constraints, joiner=' AND ', prepend_key=''): col, op = col[:-len('__in')], 'IN' else: col, op = col[:-len('__not_in')], 'NOT IN' - if isinstance(constraint, (list, set)): - items = ', '.join( - "'{}'".format(item) if isinstance(item, str) else str(item) - for item in constraint - ) - elif isinstance(constraint, str): - items = constraint - else: - raise ValueError("{} requires a list, set or string as constraint value.".format(col)) - sql.append('{} {} ({})'.format(col, op, items)) + if constraint: + if isinstance(constraint, (list, set, tuple)): + keys = [] + for i, val in enumerate(constraint): + keys.append(f':{key}{i}') + values[f'{key}{i}'] = val + sql.append(f'{col} {op} ({", ".join(keys)})') + elif isinstance(constraint, str): + sql.append(f'{col} {op} ({constraint})') + else: + raise ValueError(f"{col} requires a list, set or string as constraint value.") continue elif key.endswith('__any'): where, subvalues = constraints_to_sql(constraint, ' OR ', key+'_') - sql.append('({})'.format(where)) + sql.append(f'({where})') values.update(subvalues) continue - sql.append('{} {} :{}'.format(col, op, prepend_key+key)) + sql.append(f'{col} {op} :{prepend_key}{key}') values[prepend_key+key] = constraint return joiner.join(sql) if sql else '', values @@ -382,12 +391,14 @@ class BaseDatabase(SQLiteMixin): if not tx_rows: return [] - txids, txs = [], [] + txids, txs, txi_txoids = [], [], [] for row in tx_rows: txids.append(row[0]) txs.append(self.ledger.transaction_class( raw=row[1], height=row[2], position=row[3], is_verified=bool(row[4]) )) + for txi in txs[-1].inputs: + txi_txoids.append(txi.txo_ref.id) annotated_txos = { txo.id: txo for txo in @@ -401,7 +412,7 @@ class BaseDatabase(SQLiteMixin): txo.id: txo for txo in (await self.get_txos( my_account=my_account, - txoid__in=query("SELECT txoid FROM txi", **{'txid__in': txids})[0] + txoid__in=txi_txoids )) } diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index 0915fb056..d6ef84dc2 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -114,32 +114,32 @@ class BaseNetwork: def is_connected(self): return self.client is not None and not self.client.is_closing() - def rpc(self, list_or_method, *args): + def rpc(self, list_or_method, args): if self.is_connected: return self.client.send_request(list_or_method, args) else: raise ConnectionError("Attempting to send rpc request when connection is not available.") def ensure_server_version(self, required='1.2'): - return self.rpc('server.version', __version__, required) + return self.rpc('server.version', [__version__, required]) def broadcast(self, raw_transaction): - return self.rpc('blockchain.transaction.broadcast', raw_transaction) + return self.rpc('blockchain.transaction.broadcast', [raw_transaction]) def get_history(self, address): - return self.rpc('blockchain.address.get_history', address) + return self.rpc('blockchain.address.get_history', [address]) def get_transaction(self, tx_hash): - return self.rpc('blockchain.transaction.get', tx_hash) + return self.rpc('blockchain.transaction.get', [tx_hash]) def get_merkle(self, tx_hash, height): - return self.rpc('blockchain.transaction.get_merkle', tx_hash, height) + return self.rpc('blockchain.transaction.get_merkle', [tx_hash, height]) def get_headers(self, height, count=10000): - return self.rpc('blockchain.block.headers', height, count) + return self.rpc('blockchain.block.headers', [height, count]) def subscribe_headers(self): - return self.rpc('blockchain.headers.subscribe', True) + return self.rpc('blockchain.headers.subscribe', [True]) def subscribe_address(self, address): - return self.rpc('blockchain.address.subscribe', address) + return self.rpc('blockchain.address.subscribe', [address]) diff --git a/torba/server/cli.py b/torba/server/cli.py index 2409ec52e..bf32bfb6b 100644 --- a/torba/server/cli.py +++ b/torba/server/cli.py @@ -2,8 +2,8 @@ import logging import traceback import argparse import importlib -from .env import Env -from .server import Server +from torba.server.env import Env +from torba.server.server import Server def get_argument_parser(): From ffa9e508e908e707e593f2b825db5943e9a8d170 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 7 Apr 2019 21:51:42 -0400 Subject: [PATCH 353/383] block_processor passes height on to advance_txs --- torba/server/block_processor.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torba/server/block_processor.py b/torba/server/block_processor.py index b575d9123..2501c606f 100644 --- a/torba/server/block_processor.py +++ b/torba/server/block_processor.py @@ -377,7 +377,7 @@ class BlockProcessor: for block in blocks: height += 1 - undo_info = self.advance_txs(block.transactions) + undo_info = self.advance_txs(block.transactions, height) if height >= min_height: self.undo_infos.append((undo_info, height)) self.db.write_raw_block(block.raw, height) @@ -387,7 +387,7 @@ class BlockProcessor: self.headers.extend(headers) self.tip = self.coin.header_hash(headers[-1]) - def advance_txs(self, txs): + def advance_txs(self, txs, height): self.tx_hashes.append(b''.join(tx_hash for tx, tx_hash in txs)) # Use local vars for speed in the loops From 5f1bc016367b3211126b289269652320d96eb3b0 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 7 Apr 2019 23:14:47 -0400 Subject: [PATCH 354/383] swap advance_txs arguments --- torba/server/block_processor.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torba/server/block_processor.py b/torba/server/block_processor.py index 2501c606f..0140ebfab 100644 --- a/torba/server/block_processor.py +++ b/torba/server/block_processor.py @@ -377,7 +377,7 @@ class BlockProcessor: for block in blocks: height += 1 - undo_info = self.advance_txs(block.transactions, height) + undo_info = self.advance_txs(height, block.transactions) if height >= min_height: self.undo_infos.append((undo_info, height)) self.db.write_raw_block(block.raw, height) @@ -387,7 +387,7 @@ class BlockProcessor: self.headers.extend(headers) self.tip = self.coin.header_hash(headers[-1]) - def advance_txs(self, txs, height): + def advance_txs(self, height, txs): self.tx_hashes.append(b''.join(tx_hash for tx, tx_hash in txs)) # Use local vars for speed in the loops From ba8870823c21f05658d8e9f0f9b698278565bdb8 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Sun, 5 May 2019 17:17:36 -0400 Subject: [PATCH 355/383] added network.get_transaction_height --- torba/client/basenetwork.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index d6ef84dc2..e575aa23d 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -132,6 +132,9 @@ class BaseNetwork: def get_transaction(self, tx_hash): return self.rpc('blockchain.transaction.get', [tx_hash]) + def get_transaction_height(self, tx_hash): + return self.rpc('blockchain.transaction.get_height', [tx_hash]) + def get_merkle(self, tx_hash, height): return self.rpc('blockchain.transaction.get_merkle', [tx_hash, height]) From 31983fbb8e41d428a5a098034dfad1d5ea2047d7 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 6 May 2019 17:23:33 -0400 Subject: [PATCH 356/383] support in db for constraints that reference the same column by appending a # followed by some unique string --- tests/client_tests/unit/test_database.py | 44 +++++++++++++----------- torba/client/basedatabase.py | 13 ++++--- 2 files changed, 32 insertions(+), 25 deletions(-) diff --git a/tests/client_tests/unit/test_database.py b/tests/client_tests/unit/test_database.py index d722f62db..268917695 100644 --- a/tests/client_tests/unit/test_database.py +++ b/tests/client_tests/unit/test_database.py @@ -56,7 +56,11 @@ class TestQueryBuilder(unittest.TestCase): def test_dot(self): self.assertEqual( constraints_to_sql({'txo.position': 18}), - ('txo.position = :txo_position', {'txo_position': 18}) + ('txo.position = :txo_position0', {'txo_position0': 18}) + ) + self.assertEqual( + constraints_to_sql({'txo.position#6': 18}), + ('txo.position = :txo_position6', {'txo_position6': 18}) ) def test_any(self): @@ -67,25 +71,25 @@ class TestQueryBuilder(unittest.TestCase): 'txo.age__lt': 38 } }), - ('(txo.age > :ages__any_txo_age__gt OR txo.age < :ages__any_txo_age__lt)', { - 'ages__any_txo_age__gt': 18, - 'ages__any_txo_age__lt': 38 + ('(txo.age > :ages__any0_txo_age__gt0 OR txo.age < :ages__any0_txo_age__lt0)', { + 'ages__any0_txo_age__gt0': 18, + 'ages__any0_txo_age__lt0': 38 }) ) def test_in(self): self.assertEqual( - constraints_to_sql({'txo.age__in': [18, 38]}), - ('txo.age IN (:txo_age__in0, :txo_age__in1)', { - 'txo_age__in0': 18, - 'txo_age__in1': 38 + constraints_to_sql({'txo.age__in#2': [18, 38]}), + ('txo.age IN (:txo_age__in2_0, :txo_age__in2_1)', { + 'txo_age__in2_0': 18, + 'txo_age__in2_1': 38 }) ) self.assertEqual( constraints_to_sql({'txo.name__in': ('abc123', 'def456')}), - ('txo.name IN (:txo_name__in0, :txo_name__in1)', { - 'txo_name__in0': 'abc123', - 'txo_name__in1': 'def456' + ('txo.name IN (:txo_name__in0_0, :txo_name__in0_1)', { + 'txo_name__in0_0': 'abc123', + 'txo_name__in0_1': 'def456' }) ) self.assertEqual( @@ -96,16 +100,16 @@ class TestQueryBuilder(unittest.TestCase): def test_not_in(self): self.assertEqual( constraints_to_sql({'txo.age__not_in': [18, 38]}), - ('txo.age NOT IN (:txo_age__not_in0, :txo_age__not_in1)', { - 'txo_age__not_in0': 18, - 'txo_age__not_in1': 38 + ('txo.age NOT IN (:txo_age__not_in0_0, :txo_age__not_in0_1)', { + 'txo_age__not_in0_0': 18, + 'txo_age__not_in0_1': 38 }) ) self.assertEqual( constraints_to_sql({'txo.name__not_in': ('abc123', 'def456')}), - ('txo.name NOT IN (:txo_name__not_in0, :txo_name__not_in1)', { - 'txo_name__not_in0': 'abc123', - 'txo_name__not_in1': 'def456' + ('txo.name NOT IN (:txo_name__not_in0_0, :txo_name__not_in0_1)', { + 'txo_name__not_in0_0': 'abc123', + 'txo_name__not_in0_1': 'def456' }) ) self.assertEqual( @@ -128,10 +132,10 @@ class TestQueryBuilder(unittest.TestCase): a__not='b', b__in='select * from blah where c=:$c', d__any={'one__like': 'o', 'two': 2}, limit=10, order_by='b', **{'$c': 3}), ( - "select * from foo WHERE a != :a__not AND " + "select * from foo WHERE a != :a__not0 AND " "b IN (select * from blah where c=:$c) AND " - "(one LIKE :d__any_one__like OR two = :d__any_two) ORDER BY b LIMIT 10", - {'a__not': 'b', 'd__any_one__like': 'o', 'd__any_two': 2, '$c': 3} + "(one LIKE :d__any0_one__like0 OR two = :d__any0_two0) ORDER BY b LIMIT 10", + {'a__not0': 'b', 'd__any0_one__like0': 'o', 'd__any0_two0': 2, '$c': 3} ) ) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 8e4b9ccdc..e5c28988d 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -87,6 +87,9 @@ class AIOSQLite: def constraints_to_sql(constraints, joiner=' AND ', prepend_key=''): sql, values = [], {} for key, constraint in constraints.items(): + tag = '0' + if '#' in key: + key, tag = key[:key.index('#')], key[key.index('#')+1:] col, op, key = key, '=', key.replace('.', '_') if key.startswith('$'): values[key] = constraint @@ -120,8 +123,8 @@ def constraints_to_sql(constraints, joiner=' AND ', prepend_key=''): if isinstance(constraint, (list, set, tuple)): keys = [] for i, val in enumerate(constraint): - keys.append(f':{key}{i}') - values[f'{key}{i}'] = val + keys.append(f':{key}{tag}_{i}') + values[f'{key}{tag}_{i}'] = val sql.append(f'{col} {op} ({", ".join(keys)})') elif isinstance(constraint, str): sql.append(f'{col} {op} ({constraint})') @@ -129,12 +132,12 @@ def constraints_to_sql(constraints, joiner=' AND ', prepend_key=''): raise ValueError(f"{col} requires a list, set or string as constraint value.") continue elif key.endswith('__any'): - where, subvalues = constraints_to_sql(constraint, ' OR ', key+'_') + where, subvalues = constraints_to_sql(constraint, ' OR ', key+tag+'_') sql.append(f'({where})') values.update(subvalues) continue - sql.append(f'{col} {op} :{prepend_key}{key}') - values[prepend_key+key] = constraint + sql.append(f'{col} {op} :{prepend_key}{key}{tag}') + values[prepend_key+key+tag] = constraint return joiner.join(sql) if sql else '', values From b3afee2f86bf07be9ce46f768ab99c19d6dd3565 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 6 May 2019 17:34:13 -0400 Subject: [PATCH 357/383] ignore too-many-statements pylint --- setup.cfg | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.cfg b/setup.cfg index b9c236991..606714539 100644 --- a/setup.cfg +++ b/setup.cfg @@ -28,6 +28,7 @@ disable= too-many-locals, too-many-branches, too-many-arguments, + too-many-statements, too-many-public-methods, too-many-instance-attributes, protected-access, From 1d126913e9bda47dd1c5ec95225df134720cb9fa Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 16 May 2019 01:34:54 -0400 Subject: [PATCH 358/383] added __or and __and to sql query generator --- torba/client/basedatabase.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index e5c28988d..91cd8347f 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -131,11 +131,16 @@ def constraints_to_sql(constraints, joiner=' AND ', prepend_key=''): else: raise ValueError(f"{col} requires a list, set or string as constraint value.") continue - elif key.endswith('__any'): + elif key.endswith('__any') or key.endswith('__or'): where, subvalues = constraints_to_sql(constraint, ' OR ', key+tag+'_') sql.append(f'({where})') values.update(subvalues) continue + elif key.endswith('__and'): + where, subvalues = constraints_to_sql(constraint, ' AND ', key+tag+'_') + sql.append(f'({where})') + values.update(subvalues) + continue sql.append(f'{col} {op} :{prepend_key}{key}{tag}') values[prepend_key+key+tag] = constraint return joiner.join(sql) if sql else '', values From bba4c6e4f45c1dcc7498d672e787882afa3c1cd3 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Fri, 17 May 2019 23:52:27 -0400 Subject: [PATCH 359/383] added __gte sql criteria and pass header to wallet server advance_txs --- torba/client/basedatabase.py | 4 +++- torba/server/block_processor.py | 6 ++++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 91cd8347f..7c8e05606 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -110,6 +110,8 @@ def constraints_to_sql(constraints, joiner=' AND ', prepend_key=''): col, op = col[:-len('__lte')], '<=' elif key.endswith('__gt'): col, op = col[:-len('__gt')], '>' + elif key.endswith('__gte'): + col, op = col[:-len('__gte')], '>=' elif key.endswith('__like'): col, op = col[:-len('__like')], 'LIKE' elif key.endswith('__not_like'): @@ -166,7 +168,7 @@ def query(select, **constraints): sql.append('WHERE') sql.append(where) - if order_by is not None: + if order_by: sql.append('ORDER BY') if isinstance(order_by, str): sql.append(order_by) diff --git a/torba/server/block_processor.py b/torba/server/block_processor.py index 0140ebfab..49bb30cda 100644 --- a/torba/server/block_processor.py +++ b/torba/server/block_processor.py @@ -377,7 +377,9 @@ class BlockProcessor: for block in blocks: height += 1 - undo_info = self.advance_txs(height, block.transactions) + undo_info = self.advance_txs( + height, block.transactions, self.coin.electrum_header(block.header, height) + ) if height >= min_height: self.undo_infos.append((undo_info, height)) self.db.write_raw_block(block.raw, height) @@ -387,7 +389,7 @@ class BlockProcessor: self.headers.extend(headers) self.tip = self.coin.header_hash(headers[-1]) - def advance_txs(self, height, txs): + def advance_txs(self, height, txs, header): self.tx_hashes.append(b''.join(tx_hash for tx, tx_hash in txs)) # Use local vars for speed in the loops From ee353ca776c4ac609b21eb754014b371b27ad557 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 22 May 2019 09:35:23 -0400 Subject: [PATCH 360/383] 0.5.4 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 06e603569..92a222cfb 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.5.3' +__version__ = '0.5.4' From d23920cc6132eb7832967b0b626e9736ec6f58c6 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 29 May 2019 01:23:07 -0400 Subject: [PATCH 361/383] added get_public_key methods --- torba/client/baseaccount.py | 12 ++++++++++++ torba/client/baseledger.py | 21 +++++++++++++++++++-- 2 files changed, 31 insertions(+), 2 deletions(-) diff --git a/torba/client/baseaccount.py b/torba/client/baseaccount.py index 6b0c60cf6..391973650 100644 --- a/torba/client/baseaccount.py +++ b/torba/client/baseaccount.py @@ -58,6 +58,9 @@ class AddressManager: def get_private_key(self, index: int) -> PrivateKey: raise NotImplementedError + def get_public_key(self, index: int) -> PubKey: + raise NotImplementedError + async def get_max_gap(self): raise NotImplementedError @@ -108,6 +111,9 @@ class HierarchicalDeterministic(AddressManager): def get_private_key(self, index: int) -> PrivateKey: return self.account.private_key.child(self.chain_number).child(index) + def get_public_key(self, index: int) -> PubKey: + return self.account.public_key.child(self.chain_number).child(index) + async def get_max_gap(self) -> int: addresses = await self._query_addresses(order_by="position ASC") max_gap = 0 @@ -174,6 +180,9 @@ class SingleKey(AddressManager): def get_private_key(self, index: int) -> PrivateKey: return self.account.private_key + def get_public_key(self, index: int) -> PubKey: + return self.account.public_key + async def get_max_gap(self) -> int: return 0 @@ -390,6 +399,9 @@ class BaseAccount: assert not self.encrypted, "Cannot get private key on encrypted wallet account." return self.address_managers[chain].get_private_key(index) + def get_public_key(self, chain: int, index: int) -> PubKey: + return self.address_managers[chain].get_public_key(index) + def get_balance(self, confirmations: int = 0, **constraints): if confirmations > 0: height = self.ledger.headers.height - (confirmations-1) diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index 740f91377..2fb831588 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -173,12 +173,29 @@ class BaseLedger(metaclass=LedgerRegistry): def add_account(self, account: baseaccount.BaseAccount): self.accounts.append(account) - async def get_private_key_for_address(self, address): + async def _get_account_and_address_info_for_address(self, address): match = await self.db.get_address(address=address) if match: for account in self.accounts: if match['account'] == account.public_key.address: - return account.get_private_key(match['chain'], match['position']) + return account, match + + async def get_private_key_for_address(self, address): + match = await self._get_account_and_address_info_for_address(address) + if match: + account, address_info = match + return account.get_private_key(address_info['chain'], address_info['position']) + + async def get_public_key_for_address(self, address): + match = await self._get_account_and_address_info_for_address(address) + if match: + account, address_info = match + return account.get_public_key(address_info['chain'], address_info['position']) + + async def get_account_for_address(self, address): + match = await self._get_account_and_address_info_for_address(address) + if match: + return match[0] async def get_effective_amount_estimators(self, funding_accounts: Iterable[baseaccount.BaseAccount]): estimators = [] From 8911af58cf104887d252c411b9809e1fa9bf9b68 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Mon, 3 Jun 2019 05:21:57 -0300 Subject: [PATCH 362/383] pick fastest server on client start --- .../integration/test_reconnect.py | 16 +++++++++++- torba/client/basenetwork.py | 26 ++++++++++++++++--- 2 files changed, 37 insertions(+), 5 deletions(-) diff --git a/tests/client_tests/integration/test_reconnect.py b/tests/client_tests/integration/test_reconnect.py index a2b7b71d1..8a8153475 100644 --- a/tests/client_tests/integration/test_reconnect.py +++ b/tests/client_tests/integration/test_reconnect.py @@ -1,6 +1,7 @@ import logging import asyncio +from torba.rpc import RPCSession from torba.testcase import IntegrationTestCase @@ -38,4 +39,17 @@ class ReconnectTests(IntegrationTestCase): self.ledger.config['connect_timeout'] = 1 self.ledger.config['default_servers'] = [('10.0.0.1', 12)] + list(conf['default_servers']) await self.ledger.start() - self.assertTrue(self.ledger.network.is_connected) \ No newline at end of file + self.assertTrue(self.ledger.network.is_connected) + + async def test_pick_fastest(self): + # local server that is listening but wont reply + proto = RPCSession() + proto.handle_request = lambda _: asyncio.sleep(10) + server = await self.loop.create_server(lambda: proto, host='127.0.0.1', port=1337) + await self.ledger.stop() + conf = self.ledger.config + self.ledger.config['default_servers'] = [('127.0.0.1', 1337)] + list(conf['default_servers']) + self.ledger.config['connect_timeout'] = 30 + await asyncio.wait_for(self.ledger.start(), timeout=1) + self.assertTrue(self.ledger.network.is_connected) + self.assertEqual(self.ledger.network.client.server, conf['default_servers'][-1]) diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index e575aa23d..9fb1891c3 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -1,7 +1,6 @@ import logging import asyncio from asyncio import CancelledError -from itertools import cycle from time import time from torba.rpc import RPCSession as BaseClientSession, Connector, RPCError @@ -75,13 +74,32 @@ class BaseNetwork: 'blockchain.address.subscribe': self._on_status_controller, } + async def pick_fastest_server(self, timeout): + async def __probe(server): + client = ClientSession(network=self, server=server) + try: + await client.create_connection(timeout) + await client.send_request('server.banner') + return client + except (asyncio.TimeoutError, asyncio.CancelledError) as error: + client.connection_lost(error) + raise error + futures = [] + for server in self.config['default_servers']: + futures.append(__probe(server)) + done, pending = await asyncio.wait(futures, return_when='FIRST_COMPLETED') + for task in pending: + task.cancel() + for client in done: + return await client + async def start(self): self.running = True delay = 0.0 connect_timeout = self.config.get('connect_timeout', 6) - for server in cycle(self.config['default_servers']): - self.client = ClientSession(network=self, server=server) - connection_string = '{}:{}'.format(*server) + while True: + self.client = await self.pick_fastest_server(connect_timeout) + connection_string = '{}:{}'.format(*self.client.server) try: await self.client.create_connection(connect_timeout) await self.ensure_server_version() From 9d0b9f0dede66e92d7414a5ff9e33a35a00032f7 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Mon, 3 Jun 2019 16:03:20 -0300 Subject: [PATCH 363/383] improve server picking tests --- .../integration/test_reconnect.py | 33 ++++++++++++++----- torba/client/basenetwork.py | 1 - 2 files changed, 24 insertions(+), 10 deletions(-) diff --git a/tests/client_tests/integration/test_reconnect.py b/tests/client_tests/integration/test_reconnect.py index 8a8153475..1bebdc9d3 100644 --- a/tests/client_tests/integration/test_reconnect.py +++ b/tests/client_tests/integration/test_reconnect.py @@ -1,7 +1,9 @@ import logging import asyncio +from torba.client.basenetwork import BaseNetwork from torba.rpc import RPCSession +from torba.stream import StreamController from torba.testcase import IntegrationTestCase @@ -41,15 +43,28 @@ class ReconnectTests(IntegrationTestCase): await self.ledger.start() self.assertTrue(self.ledger.network.is_connected) - async def test_pick_fastest(self): - # local server that is listening but wont reply + async def _make_fake_server(self, latency=1.0, port=1337): + # local fake server with artificial latency proto = RPCSession() - proto.handle_request = lambda _: asyncio.sleep(10) - server = await self.loop.create_server(lambda: proto, host='127.0.0.1', port=1337) + proto.handle_request = lambda _: asyncio.sleep(latency) + server = await self.loop.create_server(lambda: proto, host='127.0.0.1', port=port) + self.addCleanup(server.close) + + async def test_pick_fastest(self): await self.ledger.stop() - conf = self.ledger.config - self.ledger.config['default_servers'] = [('127.0.0.1', 1337)] + list(conf['default_servers']) + original_servers = self.ledger.config['default_servers'] + original_servers.clear() + for index in reversed(range(4)): # reversed so the slowest is the first + port = 1337 + index + await self._make_fake_server(latency=index, port=port) + original_servers.append(('127.0.0.1', port)) + + fastest = ('127.0.0.1', 1337) + self.ledger.config['default_servers'] = original_servers self.ledger.config['connect_timeout'] = 30 - await asyncio.wait_for(self.ledger.start(), timeout=1) - self.assertTrue(self.ledger.network.is_connected) - self.assertEqual(self.ledger.network.client.server, conf['default_servers'][-1]) + + network = BaseNetwork(self.ledger) + asyncio.ensure_future(network.start()) + await asyncio.wait_for(network.on_connected.first, timeout=1) + self.assertTrue(network.is_connected) + self.assertEqual(network.client.server, fastest) diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index 9fb1891c3..692b6b312 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -101,7 +101,6 @@ class BaseNetwork: self.client = await self.pick_fastest_server(connect_timeout) connection_string = '{}:{}'.format(*self.client.server) try: - await self.client.create_connection(connect_timeout) await self.ensure_server_version() log.info("Successfully connected to SPV wallet server: %s", connection_string) self._on_connected_controller.add(True) From ca0a3dbf9ed35a1ad033dcbafc77649c266bf115 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Mon, 3 Jun 2019 16:10:41 -0300 Subject: [PATCH 364/383] minor cleanups on test spurious exceptions --- tests/client_tests/integration/test_reconnect.py | 1 + torba/client/basedatabase.py | 2 ++ torba/client/basenetwork.py | 3 ++- 3 files changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/client_tests/integration/test_reconnect.py b/tests/client_tests/integration/test_reconnect.py index 1bebdc9d3..690ad2690 100644 --- a/tests/client_tests/integration/test_reconnect.py +++ b/tests/client_tests/integration/test_reconnect.py @@ -64,6 +64,7 @@ class ReconnectTests(IntegrationTestCase): self.ledger.config['connect_timeout'] = 30 network = BaseNetwork(self.ledger) + self.addCleanup(network.stop) asyncio.ensure_future(network.start()) await asyncio.wait_for(network.on_connected.first, timeout=1) self.assertTrue(network.is_connected) diff --git a/torba/client/basedatabase.py b/torba/client/basedatabase.py index 7c8e05606..b496c7e88 100644 --- a/torba/client/basedatabase.py +++ b/torba/client/basedatabase.py @@ -31,6 +31,8 @@ class AIOSQLite: self.executor.submit(conn.close) self.executor.shutdown(wait=True) conn = self.connection + if not conn: + return self.connection = None return asyncio.get_event_loop_policy().get_event_loop().call_later(0.01, __close, conn) diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index 692b6b312..35e82974d 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -82,7 +82,8 @@ class BaseNetwork: await client.send_request('server.banner') return client except (asyncio.TimeoutError, asyncio.CancelledError) as error: - client.connection_lost(error) + if not client.is_closing(): + client.abort() raise error futures = [] for server in self.config['default_servers']: From 08609e976071808631984d433d0db07664f006f3 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Mon, 3 Jun 2019 16:23:20 -0300 Subject: [PATCH 365/383] remove unnecessary call to ledger stop on client tests --- tests/client_tests/integration/test_reconnect.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/client_tests/integration/test_reconnect.py b/tests/client_tests/integration/test_reconnect.py index 690ad2690..a592c455c 100644 --- a/tests/client_tests/integration/test_reconnect.py +++ b/tests/client_tests/integration/test_reconnect.py @@ -51,7 +51,6 @@ class ReconnectTests(IntegrationTestCase): self.addCleanup(server.close) async def test_pick_fastest(self): - await self.ledger.stop() original_servers = self.ledger.config['default_servers'] original_servers.clear() for index in reversed(range(4)): # reversed so the slowest is the first From a14b91cddad76e8e79a21e756b25e9ed9eeedcfa Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Mon, 3 Jun 2019 16:47:08 -0300 Subject: [PATCH 366/383] refactor test and make it faster --- .../integration/test_reconnect.py | 31 ++++++++++--------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/tests/client_tests/integration/test_reconnect.py b/tests/client_tests/integration/test_reconnect.py index a592c455c..4a3b36548 100644 --- a/tests/client_tests/integration/test_reconnect.py +++ b/tests/client_tests/integration/test_reconnect.py @@ -1,10 +1,11 @@ import logging import asyncio +from unittest.mock import Mock +from torba.client.baseledger import BaseLedger from torba.client.basenetwork import BaseNetwork from torba.rpc import RPCSession -from torba.stream import StreamController -from torba.testcase import IntegrationTestCase +from torba.testcase import IntegrationTestCase, AsyncioTestCase class ReconnectTests(IntegrationTestCase): @@ -43,28 +44,30 @@ class ReconnectTests(IntegrationTestCase): await self.ledger.start() self.assertTrue(self.ledger.network.is_connected) + +class ServerPickingTestCase(AsyncioTestCase): async def _make_fake_server(self, latency=1.0, port=1337): # local fake server with artificial latency proto = RPCSession() proto.handle_request = lambda _: asyncio.sleep(latency) server = await self.loop.create_server(lambda: proto, host='127.0.0.1', port=port) self.addCleanup(server.close) + return ('127.0.0.1', port) async def test_pick_fastest(self): - original_servers = self.ledger.config['default_servers'] - original_servers.clear() - for index in reversed(range(4)): # reversed so the slowest is the first - port = 1337 + index - await self._make_fake_server(latency=index, port=port) - original_servers.append(('127.0.0.1', port)) + ledger = Mock(config={ + 'default_servers': [ + await self._make_fake_server(latency=1.5, port=1340), + await self._make_fake_server(latency=0.1, port=1337), + await self._make_fake_server(latency=1.0, port=1339), + await self._make_fake_server(latency=0.5, port=1338), + ], + 'connect_timeout': 30 + }) - fastest = ('127.0.0.1', 1337) - self.ledger.config['default_servers'] = original_servers - self.ledger.config['connect_timeout'] = 30 - - network = BaseNetwork(self.ledger) + network = BaseNetwork(ledger) self.addCleanup(network.stop) asyncio.ensure_future(network.start()) await asyncio.wait_for(network.on_connected.first, timeout=1) self.assertTrue(network.is_connected) - self.assertEqual(network.client.server, fastest) + self.assertEqual(network.client.server, ('127.0.0.1', 1337)) From 8e43e408107bfdcc14eda8b3b00c29f8f33647f5 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Tue, 4 Jun 2019 02:34:58 -0300 Subject: [PATCH 367/383] fix reconnect and improve test --- .../integration/test_reconnect.py | 9 +++---- torba/client/basenetwork.py | 26 ++++++++++--------- 2 files changed, 18 insertions(+), 17 deletions(-) diff --git a/tests/client_tests/integration/test_reconnect.py b/tests/client_tests/integration/test_reconnect.py index 4a3b36548..0442cd4cd 100644 --- a/tests/client_tests/integration/test_reconnect.py +++ b/tests/client_tests/integration/test_reconnect.py @@ -37,11 +37,10 @@ class ReconnectTests(IntegrationTestCase): await self.ledger.network.get_transaction(sendtxid) async def test_timeout_then_reconnect(self): - await self.ledger.stop() - conf = self.ledger.config - self.ledger.config['connect_timeout'] = 1 - self.ledger.config['default_servers'] = [('10.0.0.1', 12)] + list(conf['default_servers']) - await self.ledger.start() + await self.conductor.spv_node.stop() + self.assertFalse(self.ledger.network.is_connected) + await self.conductor.spv_node.start(self.conductor.blockchain_node) + await self.ledger.network.on_connected.first self.assertTrue(self.ledger.network.is_connected) diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index 35e82974d..6d0f6a9ca 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -84,7 +84,9 @@ class BaseNetwork: except (asyncio.TimeoutError, asyncio.CancelledError) as error: if not client.is_closing(): client.abort() - raise error + raise + except Exception: # pylint: disable=broad-except + log.exception("Connecting to %s:%d raised an exception:", *server) futures = [] for server in self.config['default_servers']: futures.append(__probe(server)) @@ -99,27 +101,27 @@ class BaseNetwork: delay = 0.0 connect_timeout = self.config.get('connect_timeout', 6) while True: - self.client = await self.pick_fastest_server(connect_timeout) - connection_string = '{}:{}'.format(*self.client.server) try: - await self.ensure_server_version() - log.info("Successfully connected to SPV wallet server: %s", connection_string) - self._on_connected_controller.add(True) - delay = 0.0 - await self.client.on_disconnected.first + self.client = await self.pick_fastest_server(connect_timeout) + if self.is_connected: + await self.ensure_server_version() + log.info("Successfully connected to SPV wallet server: %s:%d", *self.client.server) + self._on_connected_controller.add(True) + delay = 0.0 + await self.client.on_disconnected.first except CancelledError: self.running = False except asyncio.TimeoutError: - log.warning("Timed out connecting to: %s", connection_string) + log.warning("Timed out while trying to find a server!") except Exception: # pylint: disable=broad-except - log.exception("Connecting to %s raised an exception:", connection_string) + log.exception("Exception while trying to find a server!") if not self.running: return elif self.client: await self.client.close() self.client.connection.cancel_pending_requests() - await asyncio.sleep(delay) - delay = min(delay + 1.0, 10.0) + await asyncio.sleep(delay) + delay = min(delay + 1.0, 10.0) async def stop(self): self.running = False From 3ea92c0d6e26f8b8ee654848796d6d1f1ec4eef5 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Tue, 4 Jun 2019 11:09:40 -0300 Subject: [PATCH 368/383] pylint --- torba/client/basenetwork.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index 6d0f6a9ca..fa1f934c3 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -81,7 +81,7 @@ class BaseNetwork: await client.create_connection(timeout) await client.send_request('server.banner') return client - except (asyncio.TimeoutError, asyncio.CancelledError) as error: + except (asyncio.TimeoutError, asyncio.CancelledError): if not client.is_closing(): client.abort() raise From 03e48c0968eca0eb92ab539044e15f8ed3a4e763 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 3 Jun 2019 16:34:37 -0400 Subject: [PATCH 369/383] 0.5.5 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index 92a222cfb..fc4738826 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.5.4' +__version__ = '0.5.5' From 35cd42bfeaab25bd23f0d2e4e31c9fff75b66d79 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 10 Jun 2019 01:28:51 -0400 Subject: [PATCH 370/383] ledger.wait() accept timeout argument --- torba/client/baseledger.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index 2fb831588..fb51ef95d 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -502,7 +502,7 @@ class BaseLedger(metaclass=LedgerRegistry): def broadcast(self, tx): return self.network.broadcast(hexlify(tx.raw).decode()) - async def wait(self, tx: basetransaction.BaseTransaction, height=-1): + async def wait(self, tx: basetransaction.BaseTransaction, height=-1, timeout=None): addresses = set() for txi in tx.inputs: if txi.txo_ref.txo is not None: @@ -514,9 +514,11 @@ class BaseLedger(metaclass=LedgerRegistry): self.hash160_to_address(txo.script.values['pubkey_hash']) ) records = await self.db.get_addresses(cols=('address',), address__in=addresses) - await asyncio.wait([ + done, pending = await asyncio.wait([ self.on_transaction.where(partial( lambda a, e: a == e.address and e.tx.height >= height and e.tx.id == tx.id, address_record['address'] )) for address_record in records - ]) + ], timeout=timeout) + if pending: + raise TimeoutError('Timed out waiting for transaction.') From be15601a6717ecd516824b52fc75d7b995beaa4a Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 10 Jun 2019 01:32:07 -0400 Subject: [PATCH 371/383] pylint --- torba/client/baseledger.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index fb51ef95d..8775d6f24 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -514,7 +514,7 @@ class BaseLedger(metaclass=LedgerRegistry): self.hash160_to_address(txo.script.values['pubkey_hash']) ) records = await self.db.get_addresses(cols=('address',), address__in=addresses) - done, pending = await asyncio.wait([ + _, pending = await asyncio.wait([ self.on_transaction.where(partial( lambda a, e: a == e.address and e.tx.height >= height and e.tx.id == tx.id, address_record['address'] From 1b5281c23e9767ca06ee83ba2052f4c3ef471370 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Sun, 9 Jun 2019 20:29:12 -0300 Subject: [PATCH 372/383] connect to multiple servers --- .../integration/test_reconnect.py | 4 +- torba/client/basenetwork.py | 114 +++++++++++++----- 2 files changed, 90 insertions(+), 28 deletions(-) diff --git a/tests/client_tests/integration/test_reconnect.py b/tests/client_tests/integration/test_reconnect.py index 0442cd4cd..0be16e012 100644 --- a/tests/client_tests/integration/test_reconnect.py +++ b/tests/client_tests/integration/test_reconnect.py @@ -2,7 +2,6 @@ import logging import asyncio from unittest.mock import Mock -from torba.client.baseledger import BaseLedger from torba.client.basenetwork import BaseNetwork from torba.rpc import RPCSession from torba.testcase import IntegrationTestCase, AsyncioTestCase @@ -70,3 +69,6 @@ class ServerPickingTestCase(AsyncioTestCase): await asyncio.wait_for(network.on_connected.first, timeout=1) self.assertTrue(network.is_connected) self.assertEqual(network.client.server, ('127.0.0.1', 1337)) + # ensure we are connected to all of them + self.assertEqual(len(network.session_pool.sessions), 4) + self.assertTrue(all([not session.is_closing() for session in network.session_pool.sessions])) diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index fa1f934c3..5b4a1203a 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -58,6 +58,7 @@ class BaseNetwork: def __init__(self, ledger): self.config = ledger.config self.client: ClientSession = None + self.session_pool: SessionPool = None self.running = False self._on_connected_controller = StreamController() @@ -74,40 +75,18 @@ class BaseNetwork: 'blockchain.address.subscribe': self._on_status_controller, } - async def pick_fastest_server(self, timeout): - async def __probe(server): - client = ClientSession(network=self, server=server) - try: - await client.create_connection(timeout) - await client.send_request('server.banner') - return client - except (asyncio.TimeoutError, asyncio.CancelledError): - if not client.is_closing(): - client.abort() - raise - except Exception: # pylint: disable=broad-except - log.exception("Connecting to %s:%d raised an exception:", *server) - futures = [] - for server in self.config['default_servers']: - futures.append(__probe(server)) - done, pending = await asyncio.wait(futures, return_when='FIRST_COMPLETED') - for task in pending: - task.cancel() - for client in done: - return await client - async def start(self): self.running = True - delay = 0.0 connect_timeout = self.config.get('connect_timeout', 6) + self.session_pool = SessionPool(network=self, timeout=connect_timeout) + self.session_pool.start(self.config['default_servers']) while True: try: - self.client = await self.pick_fastest_server(connect_timeout) + self.client = await self.session_pool.pick_fastest_server() if self.is_connected: await self.ensure_server_version() log.info("Successfully connected to SPV wallet server: %s:%d", *self.client.server) self._on_connected_controller.add(True) - delay = 0.0 await self.client.on_disconnected.first except CancelledError: self.running = False @@ -120,11 +99,11 @@ class BaseNetwork: elif self.client: await self.client.close() self.client.connection.cancel_pending_requests() - await asyncio.sleep(delay) - delay = min(delay + 1.0, 10.0) async def stop(self): self.running = False + if self.session_pool: + self.session_pool.stop() if self.is_connected: disconnected = self.client.on_disconnected.first await self.client.close() @@ -166,3 +145,84 @@ class BaseNetwork: def subscribe_address(self, address): return self.rpc('blockchain.address.subscribe', [address]) + + +class SessionPool: + + def __init__(self, network: BaseNetwork, timeout: float): + self.network = network + self.sessions = [] + self._dead_servers = [] + self.maintain_connections_task = None + self.timeout = timeout + # triggered when the master server is out, to speed up reconnect + self._lost_master = asyncio.Event() + + @property + def online(self): + for session in self.sessions: + if not session.is_closing(): + return True + return False + + def start(self, default_servers): + self.sessions = [ + ClientSession(network=self.network, server=server) + for server in default_servers + ] + self.maintain_connections_task = asyncio.create_task(self.ensure_connections()) + + def stop(self): + if self.maintain_connections_task: + self.maintain_connections_task.cancel() + for session in self.sessions: + if not session.is_closing(): + session.abort() + self.sessions, self._dead_servers, self.maintain_connections_task = [], [], None + + async def ensure_connections(self): + while True: + await asyncio.gather(*[ + self.ensure_connection(session) + for session in self.sessions + ], return_exceptions=True) + await asyncio.wait([asyncio.sleep(3), self._lost_master.wait()], return_when='FIRST_COMPLETED') + self._lost_master.clear() + if not self.sessions: + self.sessions.extend(self._dead_servers) + self._dead_servers = [] + + async def ensure_connection(self, session): + if not session.is_closing(): + return + try: + return await session.create_connection(self.timeout) + except asyncio.TimeoutError: + log.warning("Timeout connecting to %s:%d", *session.server) + except asyncio.CancelledError: # pylint: disable=try-except-raise + raise + except Exception as err: # pylint: disable=broad-except + if 'Connect call failed' in str(err): + log.warning("Could not connect to %s:%d", *session.server) + else: + log.exception("Connecting to %s:%d raised an exception:", *session.server) + self._dead_servers.append(session) + self.sessions.remove(session) + + async def pick_fastest_server(self): + self._lost_master.set() + while not self.online: + await asyncio.sleep(0.1) + + async def _probe(session): + await session.send_request('server.banner') + return session + + done, pending = await asyncio.wait([ + _probe(session) + for session in self.sessions if not session.is_closing() + ], return_when='FIRST_COMPLETED') + for task in pending: + task.cancel() + for session in done: + return await session From 9e24f4ca54ba345861a0c4a0ac5f65981e8a9e08 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Sun, 9 Jun 2019 20:33:18 -0300 Subject: [PATCH 373/383] fix mypy, add types --- torba/client/basenetwork.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index 5b4a1203a..7435350d1 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -2,6 +2,7 @@ import logging import asyncio from asyncio import CancelledError from time import time +from typing import Iterable from torba.rpc import RPCSession as BaseClientSession, Connector, RPCError @@ -151,8 +152,8 @@ class SessionPool: def __init__(self, network: BaseNetwork, timeout: float): self.network = network - self.sessions = [] - self._dead_servers = [] + self.sessions: Iterable[ClientSession] = [] + self._dead_servers: Iterable[ClientSession] = [] self.maintain_connections_task = None self.timeout = timeout # triggered when the master server is out, to speed up reconnect From b75139662b4f4518d45ba75f0d95e3c26fdc2419 Mon Sep 17 00:00:00 2001 From: Victor Shyba Date: Mon, 10 Jun 2019 14:53:47 -0300 Subject: [PATCH 374/383] refactor pick_fastest_session --- torba/client/basenetwork.py | 39 ++++++++++++++++++++----------------- 1 file changed, 21 insertions(+), 18 deletions(-) diff --git a/torba/client/basenetwork.py b/torba/client/basenetwork.py index 7435350d1..0b3c8aeca 100644 --- a/torba/client/basenetwork.py +++ b/torba/client/basenetwork.py @@ -2,7 +2,7 @@ import logging import asyncio from asyncio import CancelledError from time import time -from typing import Iterable +from typing import List from torba.rpc import RPCSession as BaseClientSession, Connector, RPCError @@ -83,7 +83,7 @@ class BaseNetwork: self.session_pool.start(self.config['default_servers']) while True: try: - self.client = await self.session_pool.pick_fastest_server() + self.client = await self.pick_fastest_session() if self.is_connected: await self.ensure_server_version() log.info("Successfully connected to SPV wallet server: %s:%d", *self.client.server) @@ -120,6 +120,21 @@ class BaseNetwork: else: raise ConnectionError("Attempting to send rpc request when connection is not available.") + async def pick_fastest_session(self): + sessions = await self.session_pool.get_online_sessions() + done, pending = await asyncio.wait([ + self.probe_session(session) + for session in sessions if not session.is_closing() + ], return_when='FIRST_COMPLETED') + for task in pending: + task.cancel() + for session in done: + return await session + + async def probe_session(self, session: ClientSession): + await session.send_request('server.banner') + return session + def ensure_server_version(self, required='1.2'): return self.rpc('server.version', [__version__, required]) @@ -152,8 +167,8 @@ class SessionPool: def __init__(self, network: BaseNetwork, timeout: float): self.network = network - self.sessions: Iterable[ClientSession] = [] - self._dead_servers: Iterable[ClientSession] = [] + self.sessions: List[ClientSession] = [] + self._dead_servers: List[ClientSession] = [] self.maintain_connections_task = None self.timeout = timeout # triggered when the master server is out, to speed up reconnect @@ -210,20 +225,8 @@ class SessionPool: self._dead_servers.append(session) self.sessions.remove(session) - async def pick_fastest_server(self): + async def get_online_sessions(self): self._lost_master.set() while not self.online: await asyncio.sleep(0.1) - - async def _probe(session): - await session.send_request('server.banner') - return session - - done, pending = await asyncio.wait([ - _probe(session) - for session in self.sessions if not session.is_closing() - ], return_when='FIRST_COMPLETED') - for task in pending: - task.cancel() - for session in done: - return await session + return self.sessions From 794eac05194ca297ec8cbe2463dd8f90b00e6e02 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Mon, 10 Jun 2019 23:49:04 -0400 Subject: [PATCH 375/383] 0.5.6 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index fc4738826..f5e246d62 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.5.5' +__version__ = '0.5.6' From ecebbc86c65a11c165c7ac440078f94eeb95a6cb Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 18 Jun 2019 17:50:41 -0400 Subject: [PATCH 376/383] fixed reorg issue with headers --- .../test_blockchain_reorganization.py | 42 ++++++++----------- torba/client/baseheader.py | 7 +++- torba/orchstr8/node.py | 5 ++- torba/server/block_processor.py | 4 +- 4 files changed, 28 insertions(+), 30 deletions(-) diff --git a/tests/client_tests/integration/test_blockchain_reorganization.py b/tests/client_tests/integration/test_blockchain_reorganization.py index 6f6ecbd02..ff85fd29c 100644 --- a/tests/client_tests/integration/test_blockchain_reorganization.py +++ b/tests/client_tests/integration/test_blockchain_reorganization.py @@ -1,5 +1,4 @@ import logging -from unittest import skip from torba.testcase import IntegrationTestCase @@ -8,30 +7,23 @@ class BlockchainReorganizationTests(IntegrationTestCase): VERBOSITY = logging.WARN async def test_reorg(self): + # invalidate current block, move forward 2 self.assertEqual(self.ledger.headers.height, 200) - - await self.blockchain.generate(1) - await self.on_header(201) + self.assertEqual( + self.ledger.headers.hash(200).decode(), + await self.blockchain.get_block_hash(200) + ) + await self.blockchain.invalidate_block(self.ledger.headers.hash(200).decode()) + await self.blockchain.generate(2) + await self.ledger.on_header.where(lambda e: e.height == 201) self.assertEqual(self.ledger.headers.height, 201) - height = 201 + self.assertEqual( + self.ledger.headers.hash(200).decode(), + await self.blockchain.get_block_hash(200) + ) - # simple fork (rewind+advance to immediate best) - height = await self._simulate_reorg(height, 1, 1, 2) - height = await self._simulate_reorg(height, 2, 1, 10) - height = await self._simulate_reorg(height, 4, 1, 3) - # lagged fork (rewind+batch catch up with immediate best) - height = await self._simulate_reorg(height, 4, 2, 3) - await self._simulate_reorg(height, 4, 4, 3) - - async def _simulate_reorg(self, height, rewind, winners, progress): - for i in range(rewind): - await self.blockchain.invalidateblock(self.ledger.headers.hash(height - i).decode()) - await self.blockchain.generate(rewind + winners) - height = height + winners - await self.on_header(height) - for i in range(progress): - await self.blockchain.generate(1) - height += 1 - await self.on_header(height) - self.assertEqual(height, self.ledger.headers.height) - return height + # invalidate current block, move forward 3 + await self.blockchain.invalidate_block(self.ledger.headers.hash(200).decode()) + await self.blockchain.generate(3) + await self.ledger.on_header.where(lambda e: e.height == 202) + self.assertEqual(self.ledger.headers.height, 202) diff --git a/torba/client/baseheader.py b/torba/client/baseheader.py index 1d992654f..21880fb44 100644 --- a/torba/client/baseheader.py +++ b/torba/client/baseheader.py @@ -39,7 +39,10 @@ class BaseHeaders: async def open(self): if self.path != ':memory:': - self.io = open(self.path, 'a+b') + if not os.path.exists(self.path): + self.io = open(self.path, 'w+b') + else: + self.io = open(self.path, 'r+b') async def close(self): self.io.close() @@ -105,7 +108,7 @@ class BaseHeaders: await loop.run_in_executor(None, self.validate_chunk, height, chunk) except InvalidHeader as e: bail = True - chunk = chunk[:(height-e.height+1)*self.header_size] + chunk = chunk[:(height-e.height)*self.header_size] written = 0 if chunk: self.io.seek(height * self.header_size, os.SEEK_SET) diff --git a/torba/orchstr8/node.py b/torba/orchstr8/node.py index 554021961..885e78508 100644 --- a/torba/orchstr8/node.py +++ b/torba/orchstr8/node.py @@ -364,9 +364,12 @@ class BlockchainNode: self._block_expected += blocks return self._cli_cmnd('generate', str(blocks)) - def invalidateblock(self, blockhash): + def invalidate_block(self, blockhash): return self._cli_cmnd('invalidateblock', blockhash) + def get_block_hash(self, block): + return self._cli_cmnd('getblockhash', str(block)) + def get_raw_change_address(self): return self._cli_cmnd('getrawchangeaddress') diff --git a/torba/server/block_processor.py b/torba/server/block_processor.py index 49bb30cda..0d81366d5 100644 --- a/torba/server/block_processor.py +++ b/torba/server/block_processor.py @@ -457,13 +457,13 @@ class BlockProcessor: hash_to_hex_str(self.tip), self.height)) self.tip = coin.header_prevhash(block.header) - self.backup_txs(block.transactions) + self.backup_txs(self.height, block.transactions) self.height -= 1 self.db.tx_counts.pop() self.logger.info('backed up to height {:,d}'.format(self.height)) - def backup_txs(self, txs): + def backup_txs(self, height, txs): # Prevout values, in order down the block (coinbase first if present) # undo_info is in reverse block order undo_info = self.db.read_undo_info(self.height) From f5650c1b1326af8a3d17c1912500f2011878c2ad Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 18 Jun 2019 19:42:18 -0400 Subject: [PATCH 377/383] minor refactor of reorg integration test --- .../test_blockchain_reorganization.py | 20 +++++++++++-------- torba/client/baseheader.py | 4 +--- 2 files changed, 13 insertions(+), 11 deletions(-) diff --git a/tests/client_tests/integration/test_blockchain_reorganization.py b/tests/client_tests/integration/test_blockchain_reorganization.py index ff85fd29c..4f0d1587d 100644 --- a/tests/client_tests/integration/test_blockchain_reorganization.py +++ b/tests/client_tests/integration/test_blockchain_reorganization.py @@ -6,24 +6,28 @@ class BlockchainReorganizationTests(IntegrationTestCase): VERBOSITY = logging.WARN + async def assertBlockHash(self, height): + self.assertEqual( + self.ledger.headers.hash(height).decode(), + await self.blockchain.get_block_hash(height) + ) + async def test_reorg(self): # invalidate current block, move forward 2 self.assertEqual(self.ledger.headers.height, 200) - self.assertEqual( - self.ledger.headers.hash(200).decode(), - await self.blockchain.get_block_hash(200) - ) + await self.assertBlockHash(200) await self.blockchain.invalidate_block(self.ledger.headers.hash(200).decode()) await self.blockchain.generate(2) await self.ledger.on_header.where(lambda e: e.height == 201) self.assertEqual(self.ledger.headers.height, 201) - self.assertEqual( - self.ledger.headers.hash(200).decode(), - await self.blockchain.get_block_hash(200) - ) + await self.assertBlockHash(200) + await self.assertBlockHash(201) # invalidate current block, move forward 3 await self.blockchain.invalidate_block(self.ledger.headers.hash(200).decode()) await self.blockchain.generate(3) await self.ledger.on_header.where(lambda e: e.height == 202) self.assertEqual(self.ledger.headers.height, 202) + await self.assertBlockHash(200) + await self.assertBlockHash(201) + await self.assertBlockHash(202) diff --git a/torba/client/baseheader.py b/torba/client/baseheader.py index 21880fb44..51749bdf8 100644 --- a/torba/client/baseheader.py +++ b/torba/client/baseheader.py @@ -98,9 +98,7 @@ class BaseHeaders: async def connect(self, start: int, headers: bytes) -> int: added = 0 bail = False - # TODO: switch to get_running_loop() after depricating python 3.6 support - #loop = asyncio.get_running_loop() - loop = asyncio.get_event_loop() + loop = asyncio.get_running_loop() async with self._header_connect_lock: for height, chunk in self._iterate_chunks(start, headers): try: From c30e905e1966f5f3fb6953f7e2641b8ff7d2842d Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Tue, 18 Jun 2019 19:44:29 -0400 Subject: [PATCH 378/383] undo backup_txs method signature change --- torba/server/block_processor.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torba/server/block_processor.py b/torba/server/block_processor.py index 0d81366d5..49bb30cda 100644 --- a/torba/server/block_processor.py +++ b/torba/server/block_processor.py @@ -457,13 +457,13 @@ class BlockProcessor: hash_to_hex_str(self.tip), self.height)) self.tip = coin.header_prevhash(block.header) - self.backup_txs(self.height, block.transactions) + self.backup_txs(block.transactions) self.height -= 1 self.db.tx_counts.pop() self.logger.info('backed up to height {:,d}'.format(self.height)) - def backup_txs(self, height, txs): + def backup_txs(self, txs): # Prevout values, in order down the block (coinbase first if present) # undo_info is in reverse block order undo_info = self.db.read_undo_info(self.height) From f2bd0edc5151e2adb8a4a5d2b427eb5187500429 Mon Sep 17 00:00:00 2001 From: Alex Grintsvayg Date: Mon, 17 Jun 2019 18:29:17 -0400 Subject: [PATCH 379/383] add option to only use confirmed utxos --- tests/client_tests/unit/test_coinselection.py | 10 ++++++++ tests/client_tests/unit/test_transaction.py | 4 ++-- torba/client/baseledger.py | 4 +++- torba/client/coinselection.py | 23 ++++++++++++++++++- 4 files changed, 37 insertions(+), 4 deletions(-) diff --git a/tests/client_tests/unit/test_coinselection.py b/tests/client_tests/unit/test_coinselection.py index b74dcc768..8f3d3568a 100644 --- a/tests/client_tests/unit/test_coinselection.py +++ b/tests/client_tests/unit/test_coinselection.py @@ -85,6 +85,16 @@ class TestCoinSelectionTests(BaseSelectionTestCase): match = selector.select() self.assertEqual([5*CENT], [c.txo.amount for c in match]) + def test_prefer_confirmed_strategy(self): + utxo_pool = self.estimates( + utxo(11*CENT, height=5), + utxo(11*CENT, height=0), + utxo(11*CENT, height=-2), + utxo(11*CENT, height=5), + ) + selector = CoinSelector(utxo_pool, 20*CENT, 0) + match = selector.select("confirmed_only") + self.assertEqual([5,5], [c.txo.tx_ref.height for c in match]) class TestOfficialBitcoinCoinSelectionTests(BaseSelectionTestCase): diff --git a/tests/client_tests/unit/test_transaction.py b/tests/client_tests/unit/test_transaction.py index 800c05322..1839aea06 100644 --- a/tests/client_tests/unit/test_transaction.py +++ b/tests/client_tests/unit/test_transaction.py @@ -14,8 +14,8 @@ FEE_PER_BYTE = 50 FEE_PER_CHAR = 200000 -def get_output(amount=CENT, pubkey_hash=NULL_HASH): - return ledger_class.transaction_class() \ +def get_output(amount=CENT, pubkey_hash=NULL_HASH, height=-2): + return ledger_class.transaction_class(height=height) \ .add_outputs([ledger_class.transaction_class.output_class.pay_pubkey_hash(amount, pubkey_hash)]) \ .outputs[0] diff --git a/torba/client/baseledger.py b/torba/client/baseledger.py index 8775d6f24..c6a5f8a68 100644 --- a/torba/client/baseledger.py +++ b/torba/client/baseledger.py @@ -140,6 +140,8 @@ class BaseLedger(metaclass=LedgerRegistry): self._header_processing_lock = asyncio.Lock() self._address_update_locks: Dict[str, asyncio.Lock] = {} + self.coin_selection_strategy = None + @classmethod def get_id(cls): return '{}_{}'.format(cls.symbol.lower(), cls.network_name.lower()) @@ -212,7 +214,7 @@ class BaseLedger(metaclass=LedgerRegistry): txos, amount, self.transaction_class.output_class.pay_pubkey_hash(COIN, NULL_HASH32).get_fee(self) ) - spendables = selector.select() + spendables = selector.select(self.coin_selection_strategy) if spendables: await self.reserve_outputs(s.txo for s in spendables) return spendables diff --git a/torba/client/coinselection.py b/torba/client/coinselection.py index 119a6e11f..e0d0238b6 100644 --- a/torba/client/coinselection.py +++ b/torba/client/coinselection.py @@ -5,6 +5,12 @@ from torba.client import basetransaction MAXIMUM_TRIES = 100000 +STRATEGIES = [] + +def strategy(method): + STRATEGIES.append(method.__name__) + return method + class CoinSelector: @@ -20,17 +26,30 @@ class CoinSelector: if seed is not None: self.random.seed(seed, version=1) - def select(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: + def select(self, strategy: str = None) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: if not self.txos: return [] if self.target > self.available: return [] + if strategy is not None: + return getattr(self, strategy)() return ( self.branch_and_bound() or self.closest_match() or self.random_draw() ) + @strategy + def confirmed_only(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: + self.txos = [t for t in self.txos if t.txo.tx_ref.height > 0] or self.txos + self.available = sum(c.effective_amount for c in self.txos) + return ( + self.branch_and_bound() or + self.closest_match() or + self.random_draw() + ) + + @strategy def branch_and_bound(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: # see bitcoin implementation for more info: # https://github.com/bitcoin/bitcoin/blob/master/src/wallet/coinselection.cpp @@ -89,6 +108,7 @@ class CoinSelector: return [] + @strategy def closest_match(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: """ Pick one UTXOs that is larger than the target but with the smallest change. """ target = self.target + self.cost_of_change @@ -101,6 +121,7 @@ class CoinSelector: smallest_change, best_match = change, txo return [best_match] if best_match else [] + @strategy def random_draw(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: """ Accumulate UTXOs at random until there is enough to cover the target. """ target = self.target + self.cost_of_change From 4a24cc00952f051d12215f3648448fbeb03419f6 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Wed, 19 Jun 2019 06:00:22 -0400 Subject: [PATCH 380/383] pylint & mypint fixes --- tests/client_tests/unit/test_coinselection.py | 3 ++- torba/client/coinselection.py | 14 +++++++------- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/tests/client_tests/unit/test_coinselection.py b/tests/client_tests/unit/test_coinselection.py index 8f3d3568a..5255ef86f 100644 --- a/tests/client_tests/unit/test_coinselection.py +++ b/tests/client_tests/unit/test_coinselection.py @@ -94,7 +94,8 @@ class TestCoinSelectionTests(BaseSelectionTestCase): ) selector = CoinSelector(utxo_pool, 20*CENT, 0) match = selector.select("confirmed_only") - self.assertEqual([5,5], [c.txo.tx_ref.height for c in match]) + self.assertEqual([5, 5], [c.txo.tx_ref.height for c in match]) + class TestOfficialBitcoinCoinSelectionTests(BaseSelectionTestCase): diff --git a/torba/client/coinselection.py b/torba/client/coinselection.py index e0d0238b6..502ab0165 100644 --- a/torba/client/coinselection.py +++ b/torba/client/coinselection.py @@ -26,13 +26,13 @@ class CoinSelector: if seed is not None: self.random.seed(seed, version=1) - def select(self, strategy: str = None) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: + def select(self, strategy_name: str = None) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: if not self.txos: return [] if self.target > self.available: return [] - if strategy is not None: - return getattr(self, strategy)() + if strategy_name is not None: + return getattr(self, strategy_name)() return ( self.branch_and_bound() or self.closest_match() or @@ -41,12 +41,12 @@ class CoinSelector: @strategy def confirmed_only(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: - self.txos = [t for t in self.txos if t.txo.tx_ref.height > 0] or self.txos + self.txos = [t for t in self.txos if t.txo.tx_ref and t.txo.tx_ref.height > 0] or self.txos self.available = sum(c.effective_amount for c in self.txos) return ( - self.branch_and_bound() or - self.closest_match() or - self.random_draw() + self.branch_and_bound() or + self.closest_match() or + self.random_draw() ) @strategy From 24e8a3c62ebb3379a67b534004fc5966f2533055 Mon Sep 17 00:00:00 2001 From: Alex Grintsvayg Date: Wed, 19 Jun 2019 10:39:11 -0400 Subject: [PATCH 381/383] more accurate coin selection strategy name --- tests/client_tests/unit/test_coinselection.py | 2 +- torba/client/coinselection.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/client_tests/unit/test_coinselection.py b/tests/client_tests/unit/test_coinselection.py index 5255ef86f..8a5d38c8f 100644 --- a/tests/client_tests/unit/test_coinselection.py +++ b/tests/client_tests/unit/test_coinselection.py @@ -93,7 +93,7 @@ class TestCoinSelectionTests(BaseSelectionTestCase): utxo(11*CENT, height=5), ) selector = CoinSelector(utxo_pool, 20*CENT, 0) - match = selector.select("confirmed_only") + match = selector.select("prefer_confirmed") self.assertEqual([5, 5], [c.txo.tx_ref.height for c in match]) diff --git a/torba/client/coinselection.py b/torba/client/coinselection.py index 502ab0165..61cff6909 100644 --- a/torba/client/coinselection.py +++ b/torba/client/coinselection.py @@ -40,7 +40,7 @@ class CoinSelector: ) @strategy - def confirmed_only(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: + def prefer_confirmed(self) -> List[basetransaction.BaseOutputEffectiveAmountEstimator]: self.txos = [t for t in self.txos if t.txo.tx_ref and t.txo.tx_ref.height > 0] or self.txos self.available = sum(c.effective_amount for c in self.txos) return ( From 190304344c0ff68f8a24cf50272307a11bf7f62b Mon Sep 17 00:00:00 2001 From: Jack Robison Date: Wed, 19 Jun 2019 10:55:57 -0400 Subject: [PATCH 382/383] v0.5.7 --- torba/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torba/__init__.py b/torba/__init__.py index f5e246d62..4b90c3d19 100644 --- a/torba/__init__.py +++ b/torba/__init__.py @@ -1,2 +1,2 @@ __path__: str = __import__('pkgutil').extend_path(__path__, __name__) -__version__ = '0.5.6' +__version__ = '0.5.7' From 16215d5b96acfd9e01120c2f31ab60f5816f7b37 Mon Sep 17 00:00:00 2001 From: Lex Berezhny Date: Thu, 20 Jun 2019 13:45:46 -0400 Subject: [PATCH 383/383] preparing for moving torba into lbry sdk repo --- .gitignore => torba/.gitignore | 0 .travis.yml => torba/.travis.yml | 0 CHANGELOG.md => torba/CHANGELOG.md | 0 LICENSE => torba/LICENSE | 0 MANIFEST.in => torba/MANIFEST.in | 0 README.md => torba/README.md | 0 setup.cfg => torba/setup.cfg | 0 setup.py => torba/setup.py | 0 {tests => torba/tests}/client_tests/__init__.py | 0 .../tests}/client_tests/integration/__init__.py | 0 .../integration/test_blockchain_reorganization.py | 0 .../client_tests/integration/test_reconnect.py | 0 .../tests}/client_tests/integration/test_sync.py | 0 .../client_tests/integration/test_transactions.py | 0 .../tests}/client_tests/unit/__init__.py | 0 .../tests}/client_tests/unit/key_fixtures.py | 0 .../tests}/client_tests/unit/test_account.py | 0 .../client_tests/unit/test_bcd_data_stream.py | 0 .../tests}/client_tests/unit/test_bip32.py | 0 .../tests}/client_tests/unit/test_coinselection.py | 0 .../tests}/client_tests/unit/test_database.py | 0 .../tests}/client_tests/unit/test_hash.py | 0 .../tests}/client_tests/unit/test_headers.py | 0 .../tests}/client_tests/unit/test_ledger.py | 0 .../tests}/client_tests/unit/test_mnemonic.py | 0 .../tests}/client_tests/unit/test_script.py | 0 .../tests}/client_tests/unit/test_transaction.py | 0 .../tests}/client_tests/unit/test_utils.py | 0 .../tests}/client_tests/unit/test_wallet.py | 0 torba.png => torba/torba.png | Bin torba/{ => torba}/__init__.py | 0 torba/{ => torba}/client/__init__.py | 0 torba/{ => torba}/client/baseaccount.py | 0 torba/{ => torba}/client/basedatabase.py | 0 torba/{ => torba}/client/baseheader.py | 0 torba/{ => torba}/client/baseledger.py | 0 torba/{ => torba}/client/basemanager.py | 0 torba/{ => torba}/client/basenetwork.py | 0 torba/{ => torba}/client/basescript.py | 0 torba/{ => torba}/client/basetransaction.py | 0 torba/{ => torba}/client/bcd_data_stream.py | 0 torba/{ => torba}/client/bip32.py | 0 torba/{ => torba}/client/cli.py | 0 torba/{ => torba}/client/coinselection.py | 0 torba/{ => torba}/client/constants.py | 0 torba/{ => torba}/client/errors.py | 0 torba/{ => torba}/client/hash.py | 0 torba/{ => torba}/client/mnemonic.py | 0 torba/{ => torba}/client/util.py | 0 torba/{ => torba}/client/wallet.py | 0 torba/{ => torba}/client/words/__init__.py | 0 .../{ => torba}/client/words/chinese_simplified.py | 0 torba/{ => torba}/client/words/english.py | 0 torba/{ => torba}/client/words/japanese.py | 0 torba/{ => torba}/client/words/portuguese.py | 0 torba/{ => torba}/client/words/spanish.py | 0 torba/{ => torba}/coin/__init__.py | 0 torba/{ => torba}/coin/bitcoincash.py | 0 torba/{ => torba}/coin/bitcoinsegwit.py | 0 torba/{ => torba}/orchstr8/__init__.py | 0 torba/{ => torba}/orchstr8/cli.py | 0 torba/{ => torba}/orchstr8/node.py | 0 torba/{ => torba}/orchstr8/service.py | 0 torba/{ => torba}/rpc/__init__.py | 0 torba/{ => torba}/rpc/framing.py | 0 torba/{ => torba}/rpc/jsonrpc.py | 0 torba/{ => torba}/rpc/session.py | 0 torba/{ => torba}/rpc/socks.py | 0 torba/{ => torba}/rpc/util.py | 0 torba/{ => torba}/server/__init__.py | 0 torba/{ => torba}/server/block_processor.py | 0 torba/{ => torba}/server/cli.py | 0 torba/{ => torba}/server/coins.py | 0 torba/{ => torba}/server/daemon.py | 0 torba/{ => torba}/server/db.py | 0 torba/{ => torba}/server/enum.py | 0 torba/{ => torba}/server/env.py | 0 torba/{ => torba}/server/hash.py | 0 torba/{ => torba}/server/history.py | 0 torba/{ => torba}/server/mempool.py | 0 torba/{ => torba}/server/merkle.py | 0 torba/{ => torba}/server/peer.py | 0 torba/{ => torba}/server/peers.py | 0 torba/{ => torba}/server/script.py | 0 torba/{ => torba}/server/server.py | 0 torba/{ => torba}/server/session.py | 0 torba/{ => torba}/server/storage.py | 0 torba/{ => torba}/server/text.py | 0 torba/{ => torba}/server/tx.py | 0 torba/{ => torba}/server/util.py | 0 torba/{ => torba}/stream.py | 0 torba/{ => torba}/tasks.py | 0 torba/{ => torba}/testcase.py | 0 torba/{ => torba}/ui/__init__.py | 0 torba/{ => torba}/workbench/Makefile | 0 torba/{ => torba}/workbench/__init__.py | 0 torba/{ => torba}/workbench/_blockchain_dock.py | 0 torba/{ => torba}/workbench/_output_dock.py | 0 torba/{ => torba}/workbench/application.py | 0 torba/{ => torba}/workbench/blockchain_dock.ui | 0 torba/{ => torba}/workbench/output_dock.ui | 0 tox.ini => torba/tox.ini | 0 102 files changed, 0 insertions(+), 0 deletions(-) rename .gitignore => torba/.gitignore (100%) rename .travis.yml => torba/.travis.yml (100%) rename CHANGELOG.md => torba/CHANGELOG.md (100%) rename LICENSE => torba/LICENSE (100%) rename MANIFEST.in => torba/MANIFEST.in (100%) rename README.md => torba/README.md (100%) rename setup.cfg => torba/setup.cfg (100%) rename setup.py => torba/setup.py (100%) rename {tests => torba/tests}/client_tests/__init__.py (100%) rename {tests => torba/tests}/client_tests/integration/__init__.py (100%) rename {tests => torba/tests}/client_tests/integration/test_blockchain_reorganization.py (100%) rename {tests => torba/tests}/client_tests/integration/test_reconnect.py (100%) rename {tests => torba/tests}/client_tests/integration/test_sync.py (100%) rename {tests => torba/tests}/client_tests/integration/test_transactions.py (100%) rename {tests => torba/tests}/client_tests/unit/__init__.py (100%) rename {tests => torba/tests}/client_tests/unit/key_fixtures.py (100%) rename {tests => torba/tests}/client_tests/unit/test_account.py (100%) rename {tests => torba/tests}/client_tests/unit/test_bcd_data_stream.py (100%) rename {tests => torba/tests}/client_tests/unit/test_bip32.py (100%) rename {tests => torba/tests}/client_tests/unit/test_coinselection.py (100%) rename {tests => torba/tests}/client_tests/unit/test_database.py (100%) rename {tests => torba/tests}/client_tests/unit/test_hash.py (100%) rename {tests => torba/tests}/client_tests/unit/test_headers.py (100%) rename {tests => torba/tests}/client_tests/unit/test_ledger.py (100%) rename {tests => torba/tests}/client_tests/unit/test_mnemonic.py (100%) rename {tests => torba/tests}/client_tests/unit/test_script.py (100%) rename {tests => torba/tests}/client_tests/unit/test_transaction.py (100%) rename {tests => torba/tests}/client_tests/unit/test_utils.py (100%) rename {tests => torba/tests}/client_tests/unit/test_wallet.py (100%) rename torba.png => torba/torba.png (100%) rename torba/{ => torba}/__init__.py (100%) rename torba/{ => torba}/client/__init__.py (100%) rename torba/{ => torba}/client/baseaccount.py (100%) rename torba/{ => torba}/client/basedatabase.py (100%) rename torba/{ => torba}/client/baseheader.py (100%) rename torba/{ => torba}/client/baseledger.py (100%) rename torba/{ => torba}/client/basemanager.py (100%) rename torba/{ => torba}/client/basenetwork.py (100%) rename torba/{ => torba}/client/basescript.py (100%) rename torba/{ => torba}/client/basetransaction.py (100%) rename torba/{ => torba}/client/bcd_data_stream.py (100%) rename torba/{ => torba}/client/bip32.py (100%) rename torba/{ => torba}/client/cli.py (100%) rename torba/{ => torba}/client/coinselection.py (100%) rename torba/{ => torba}/client/constants.py (100%) rename torba/{ => torba}/client/errors.py (100%) rename torba/{ => torba}/client/hash.py (100%) rename torba/{ => torba}/client/mnemonic.py (100%) rename torba/{ => torba}/client/util.py (100%) rename torba/{ => torba}/client/wallet.py (100%) rename torba/{ => torba}/client/words/__init__.py (100%) rename torba/{ => torba}/client/words/chinese_simplified.py (100%) rename torba/{ => torba}/client/words/english.py (100%) rename torba/{ => torba}/client/words/japanese.py (100%) rename torba/{ => torba}/client/words/portuguese.py (100%) rename torba/{ => torba}/client/words/spanish.py (100%) rename torba/{ => torba}/coin/__init__.py (100%) rename torba/{ => torba}/coin/bitcoincash.py (100%) rename torba/{ => torba}/coin/bitcoinsegwit.py (100%) rename torba/{ => torba}/orchstr8/__init__.py (100%) rename torba/{ => torba}/orchstr8/cli.py (100%) rename torba/{ => torba}/orchstr8/node.py (100%) rename torba/{ => torba}/orchstr8/service.py (100%) rename torba/{ => torba}/rpc/__init__.py (100%) rename torba/{ => torba}/rpc/framing.py (100%) rename torba/{ => torba}/rpc/jsonrpc.py (100%) rename torba/{ => torba}/rpc/session.py (100%) rename torba/{ => torba}/rpc/socks.py (100%) rename torba/{ => torba}/rpc/util.py (100%) rename torba/{ => torba}/server/__init__.py (100%) rename torba/{ => torba}/server/block_processor.py (100%) rename torba/{ => torba}/server/cli.py (100%) rename torba/{ => torba}/server/coins.py (100%) rename torba/{ => torba}/server/daemon.py (100%) rename torba/{ => torba}/server/db.py (100%) rename torba/{ => torba}/server/enum.py (100%) rename torba/{ => torba}/server/env.py (100%) rename torba/{ => torba}/server/hash.py (100%) rename torba/{ => torba}/server/history.py (100%) rename torba/{ => torba}/server/mempool.py (100%) rename torba/{ => torba}/server/merkle.py (100%) rename torba/{ => torba}/server/peer.py (100%) rename torba/{ => torba}/server/peers.py (100%) rename torba/{ => torba}/server/script.py (100%) rename torba/{ => torba}/server/server.py (100%) rename torba/{ => torba}/server/session.py (100%) rename torba/{ => torba}/server/storage.py (100%) rename torba/{ => torba}/server/text.py (100%) rename torba/{ => torba}/server/tx.py (100%) rename torba/{ => torba}/server/util.py (100%) rename torba/{ => torba}/stream.py (100%) rename torba/{ => torba}/tasks.py (100%) rename torba/{ => torba}/testcase.py (100%) rename torba/{ => torba}/ui/__init__.py (100%) rename torba/{ => torba}/workbench/Makefile (100%) rename torba/{ => torba}/workbench/__init__.py (100%) rename torba/{ => torba}/workbench/_blockchain_dock.py (100%) rename torba/{ => torba}/workbench/_output_dock.py (100%) rename torba/{ => torba}/workbench/application.py (100%) rename torba/{ => torba}/workbench/blockchain_dock.ui (100%) rename torba/{ => torba}/workbench/output_dock.ui (100%) rename tox.ini => torba/tox.ini (100%) diff --git a/.gitignore b/torba/.gitignore similarity index 100% rename from .gitignore rename to torba/.gitignore diff --git a/.travis.yml b/torba/.travis.yml similarity index 100% rename from .travis.yml rename to torba/.travis.yml diff --git a/CHANGELOG.md b/torba/CHANGELOG.md similarity index 100% rename from CHANGELOG.md rename to torba/CHANGELOG.md diff --git a/LICENSE b/torba/LICENSE similarity index 100% rename from LICENSE rename to torba/LICENSE diff --git a/MANIFEST.in b/torba/MANIFEST.in similarity index 100% rename from MANIFEST.in rename to torba/MANIFEST.in diff --git a/README.md b/torba/README.md similarity index 100% rename from README.md rename to torba/README.md diff --git a/setup.cfg b/torba/setup.cfg similarity index 100% rename from setup.cfg rename to torba/setup.cfg diff --git a/setup.py b/torba/setup.py similarity index 100% rename from setup.py rename to torba/setup.py diff --git a/tests/client_tests/__init__.py b/torba/tests/client_tests/__init__.py similarity index 100% rename from tests/client_tests/__init__.py rename to torba/tests/client_tests/__init__.py diff --git a/tests/client_tests/integration/__init__.py b/torba/tests/client_tests/integration/__init__.py similarity index 100% rename from tests/client_tests/integration/__init__.py rename to torba/tests/client_tests/integration/__init__.py diff --git a/tests/client_tests/integration/test_blockchain_reorganization.py b/torba/tests/client_tests/integration/test_blockchain_reorganization.py similarity index 100% rename from tests/client_tests/integration/test_blockchain_reorganization.py rename to torba/tests/client_tests/integration/test_blockchain_reorganization.py diff --git a/tests/client_tests/integration/test_reconnect.py b/torba/tests/client_tests/integration/test_reconnect.py similarity index 100% rename from tests/client_tests/integration/test_reconnect.py rename to torba/tests/client_tests/integration/test_reconnect.py diff --git a/tests/client_tests/integration/test_sync.py b/torba/tests/client_tests/integration/test_sync.py similarity index 100% rename from tests/client_tests/integration/test_sync.py rename to torba/tests/client_tests/integration/test_sync.py diff --git a/tests/client_tests/integration/test_transactions.py b/torba/tests/client_tests/integration/test_transactions.py similarity index 100% rename from tests/client_tests/integration/test_transactions.py rename to torba/tests/client_tests/integration/test_transactions.py diff --git a/tests/client_tests/unit/__init__.py b/torba/tests/client_tests/unit/__init__.py similarity index 100% rename from tests/client_tests/unit/__init__.py rename to torba/tests/client_tests/unit/__init__.py diff --git a/tests/client_tests/unit/key_fixtures.py b/torba/tests/client_tests/unit/key_fixtures.py similarity index 100% rename from tests/client_tests/unit/key_fixtures.py rename to torba/tests/client_tests/unit/key_fixtures.py diff --git a/tests/client_tests/unit/test_account.py b/torba/tests/client_tests/unit/test_account.py similarity index 100% rename from tests/client_tests/unit/test_account.py rename to torba/tests/client_tests/unit/test_account.py diff --git a/tests/client_tests/unit/test_bcd_data_stream.py b/torba/tests/client_tests/unit/test_bcd_data_stream.py similarity index 100% rename from tests/client_tests/unit/test_bcd_data_stream.py rename to torba/tests/client_tests/unit/test_bcd_data_stream.py diff --git a/tests/client_tests/unit/test_bip32.py b/torba/tests/client_tests/unit/test_bip32.py similarity index 100% rename from tests/client_tests/unit/test_bip32.py rename to torba/tests/client_tests/unit/test_bip32.py diff --git a/tests/client_tests/unit/test_coinselection.py b/torba/tests/client_tests/unit/test_coinselection.py similarity index 100% rename from tests/client_tests/unit/test_coinselection.py rename to torba/tests/client_tests/unit/test_coinselection.py diff --git a/tests/client_tests/unit/test_database.py b/torba/tests/client_tests/unit/test_database.py similarity index 100% rename from tests/client_tests/unit/test_database.py rename to torba/tests/client_tests/unit/test_database.py diff --git a/tests/client_tests/unit/test_hash.py b/torba/tests/client_tests/unit/test_hash.py similarity index 100% rename from tests/client_tests/unit/test_hash.py rename to torba/tests/client_tests/unit/test_hash.py diff --git a/tests/client_tests/unit/test_headers.py b/torba/tests/client_tests/unit/test_headers.py similarity index 100% rename from tests/client_tests/unit/test_headers.py rename to torba/tests/client_tests/unit/test_headers.py diff --git a/tests/client_tests/unit/test_ledger.py b/torba/tests/client_tests/unit/test_ledger.py similarity index 100% rename from tests/client_tests/unit/test_ledger.py rename to torba/tests/client_tests/unit/test_ledger.py diff --git a/tests/client_tests/unit/test_mnemonic.py b/torba/tests/client_tests/unit/test_mnemonic.py similarity index 100% rename from tests/client_tests/unit/test_mnemonic.py rename to torba/tests/client_tests/unit/test_mnemonic.py diff --git a/tests/client_tests/unit/test_script.py b/torba/tests/client_tests/unit/test_script.py similarity index 100% rename from tests/client_tests/unit/test_script.py rename to torba/tests/client_tests/unit/test_script.py diff --git a/tests/client_tests/unit/test_transaction.py b/torba/tests/client_tests/unit/test_transaction.py similarity index 100% rename from tests/client_tests/unit/test_transaction.py rename to torba/tests/client_tests/unit/test_transaction.py diff --git a/tests/client_tests/unit/test_utils.py b/torba/tests/client_tests/unit/test_utils.py similarity index 100% rename from tests/client_tests/unit/test_utils.py rename to torba/tests/client_tests/unit/test_utils.py diff --git a/tests/client_tests/unit/test_wallet.py b/torba/tests/client_tests/unit/test_wallet.py similarity index 100% rename from tests/client_tests/unit/test_wallet.py rename to torba/tests/client_tests/unit/test_wallet.py diff --git a/torba.png b/torba/torba.png similarity index 100% rename from torba.png rename to torba/torba.png diff --git a/torba/__init__.py b/torba/torba/__init__.py similarity index 100% rename from torba/__init__.py rename to torba/torba/__init__.py diff --git a/torba/client/__init__.py b/torba/torba/client/__init__.py similarity index 100% rename from torba/client/__init__.py rename to torba/torba/client/__init__.py diff --git a/torba/client/baseaccount.py b/torba/torba/client/baseaccount.py similarity index 100% rename from torba/client/baseaccount.py rename to torba/torba/client/baseaccount.py diff --git a/torba/client/basedatabase.py b/torba/torba/client/basedatabase.py similarity index 100% rename from torba/client/basedatabase.py rename to torba/torba/client/basedatabase.py diff --git a/torba/client/baseheader.py b/torba/torba/client/baseheader.py similarity index 100% rename from torba/client/baseheader.py rename to torba/torba/client/baseheader.py diff --git a/torba/client/baseledger.py b/torba/torba/client/baseledger.py similarity index 100% rename from torba/client/baseledger.py rename to torba/torba/client/baseledger.py diff --git a/torba/client/basemanager.py b/torba/torba/client/basemanager.py similarity index 100% rename from torba/client/basemanager.py rename to torba/torba/client/basemanager.py diff --git a/torba/client/basenetwork.py b/torba/torba/client/basenetwork.py similarity index 100% rename from torba/client/basenetwork.py rename to torba/torba/client/basenetwork.py diff --git a/torba/client/basescript.py b/torba/torba/client/basescript.py similarity index 100% rename from torba/client/basescript.py rename to torba/torba/client/basescript.py diff --git a/torba/client/basetransaction.py b/torba/torba/client/basetransaction.py similarity index 100% rename from torba/client/basetransaction.py rename to torba/torba/client/basetransaction.py diff --git a/torba/client/bcd_data_stream.py b/torba/torba/client/bcd_data_stream.py similarity index 100% rename from torba/client/bcd_data_stream.py rename to torba/torba/client/bcd_data_stream.py diff --git a/torba/client/bip32.py b/torba/torba/client/bip32.py similarity index 100% rename from torba/client/bip32.py rename to torba/torba/client/bip32.py diff --git a/torba/client/cli.py b/torba/torba/client/cli.py similarity index 100% rename from torba/client/cli.py rename to torba/torba/client/cli.py diff --git a/torba/client/coinselection.py b/torba/torba/client/coinselection.py similarity index 100% rename from torba/client/coinselection.py rename to torba/torba/client/coinselection.py diff --git a/torba/client/constants.py b/torba/torba/client/constants.py similarity index 100% rename from torba/client/constants.py rename to torba/torba/client/constants.py diff --git a/torba/client/errors.py b/torba/torba/client/errors.py similarity index 100% rename from torba/client/errors.py rename to torba/torba/client/errors.py diff --git a/torba/client/hash.py b/torba/torba/client/hash.py similarity index 100% rename from torba/client/hash.py rename to torba/torba/client/hash.py diff --git a/torba/client/mnemonic.py b/torba/torba/client/mnemonic.py similarity index 100% rename from torba/client/mnemonic.py rename to torba/torba/client/mnemonic.py diff --git a/torba/client/util.py b/torba/torba/client/util.py similarity index 100% rename from torba/client/util.py rename to torba/torba/client/util.py diff --git a/torba/client/wallet.py b/torba/torba/client/wallet.py similarity index 100% rename from torba/client/wallet.py rename to torba/torba/client/wallet.py diff --git a/torba/client/words/__init__.py b/torba/torba/client/words/__init__.py similarity index 100% rename from torba/client/words/__init__.py rename to torba/torba/client/words/__init__.py diff --git a/torba/client/words/chinese_simplified.py b/torba/torba/client/words/chinese_simplified.py similarity index 100% rename from torba/client/words/chinese_simplified.py rename to torba/torba/client/words/chinese_simplified.py diff --git a/torba/client/words/english.py b/torba/torba/client/words/english.py similarity index 100% rename from torba/client/words/english.py rename to torba/torba/client/words/english.py diff --git a/torba/client/words/japanese.py b/torba/torba/client/words/japanese.py similarity index 100% rename from torba/client/words/japanese.py rename to torba/torba/client/words/japanese.py diff --git a/torba/client/words/portuguese.py b/torba/torba/client/words/portuguese.py similarity index 100% rename from torba/client/words/portuguese.py rename to torba/torba/client/words/portuguese.py diff --git a/torba/client/words/spanish.py b/torba/torba/client/words/spanish.py similarity index 100% rename from torba/client/words/spanish.py rename to torba/torba/client/words/spanish.py diff --git a/torba/coin/__init__.py b/torba/torba/coin/__init__.py similarity index 100% rename from torba/coin/__init__.py rename to torba/torba/coin/__init__.py diff --git a/torba/coin/bitcoincash.py b/torba/torba/coin/bitcoincash.py similarity index 100% rename from torba/coin/bitcoincash.py rename to torba/torba/coin/bitcoincash.py diff --git a/torba/coin/bitcoinsegwit.py b/torba/torba/coin/bitcoinsegwit.py similarity index 100% rename from torba/coin/bitcoinsegwit.py rename to torba/torba/coin/bitcoinsegwit.py diff --git a/torba/orchstr8/__init__.py b/torba/torba/orchstr8/__init__.py similarity index 100% rename from torba/orchstr8/__init__.py rename to torba/torba/orchstr8/__init__.py diff --git a/torba/orchstr8/cli.py b/torba/torba/orchstr8/cli.py similarity index 100% rename from torba/orchstr8/cli.py rename to torba/torba/orchstr8/cli.py diff --git a/torba/orchstr8/node.py b/torba/torba/orchstr8/node.py similarity index 100% rename from torba/orchstr8/node.py rename to torba/torba/orchstr8/node.py diff --git a/torba/orchstr8/service.py b/torba/torba/orchstr8/service.py similarity index 100% rename from torba/orchstr8/service.py rename to torba/torba/orchstr8/service.py diff --git a/torba/rpc/__init__.py b/torba/torba/rpc/__init__.py similarity index 100% rename from torba/rpc/__init__.py rename to torba/torba/rpc/__init__.py diff --git a/torba/rpc/framing.py b/torba/torba/rpc/framing.py similarity index 100% rename from torba/rpc/framing.py rename to torba/torba/rpc/framing.py diff --git a/torba/rpc/jsonrpc.py b/torba/torba/rpc/jsonrpc.py similarity index 100% rename from torba/rpc/jsonrpc.py rename to torba/torba/rpc/jsonrpc.py diff --git a/torba/rpc/session.py b/torba/torba/rpc/session.py similarity index 100% rename from torba/rpc/session.py rename to torba/torba/rpc/session.py diff --git a/torba/rpc/socks.py b/torba/torba/rpc/socks.py similarity index 100% rename from torba/rpc/socks.py rename to torba/torba/rpc/socks.py diff --git a/torba/rpc/util.py b/torba/torba/rpc/util.py similarity index 100% rename from torba/rpc/util.py rename to torba/torba/rpc/util.py diff --git a/torba/server/__init__.py b/torba/torba/server/__init__.py similarity index 100% rename from torba/server/__init__.py rename to torba/torba/server/__init__.py diff --git a/torba/server/block_processor.py b/torba/torba/server/block_processor.py similarity index 100% rename from torba/server/block_processor.py rename to torba/torba/server/block_processor.py diff --git a/torba/server/cli.py b/torba/torba/server/cli.py similarity index 100% rename from torba/server/cli.py rename to torba/torba/server/cli.py diff --git a/torba/server/coins.py b/torba/torba/server/coins.py similarity index 100% rename from torba/server/coins.py rename to torba/torba/server/coins.py diff --git a/torba/server/daemon.py b/torba/torba/server/daemon.py similarity index 100% rename from torba/server/daemon.py rename to torba/torba/server/daemon.py diff --git a/torba/server/db.py b/torba/torba/server/db.py similarity index 100% rename from torba/server/db.py rename to torba/torba/server/db.py diff --git a/torba/server/enum.py b/torba/torba/server/enum.py similarity index 100% rename from torba/server/enum.py rename to torba/torba/server/enum.py diff --git a/torba/server/env.py b/torba/torba/server/env.py similarity index 100% rename from torba/server/env.py rename to torba/torba/server/env.py diff --git a/torba/server/hash.py b/torba/torba/server/hash.py similarity index 100% rename from torba/server/hash.py rename to torba/torba/server/hash.py diff --git a/torba/server/history.py b/torba/torba/server/history.py similarity index 100% rename from torba/server/history.py rename to torba/torba/server/history.py diff --git a/torba/server/mempool.py b/torba/torba/server/mempool.py similarity index 100% rename from torba/server/mempool.py rename to torba/torba/server/mempool.py diff --git a/torba/server/merkle.py b/torba/torba/server/merkle.py similarity index 100% rename from torba/server/merkle.py rename to torba/torba/server/merkle.py diff --git a/torba/server/peer.py b/torba/torba/server/peer.py similarity index 100% rename from torba/server/peer.py rename to torba/torba/server/peer.py diff --git a/torba/server/peers.py b/torba/torba/server/peers.py similarity index 100% rename from torba/server/peers.py rename to torba/torba/server/peers.py diff --git a/torba/server/script.py b/torba/torba/server/script.py similarity index 100% rename from torba/server/script.py rename to torba/torba/server/script.py diff --git a/torba/server/server.py b/torba/torba/server/server.py similarity index 100% rename from torba/server/server.py rename to torba/torba/server/server.py diff --git a/torba/server/session.py b/torba/torba/server/session.py similarity index 100% rename from torba/server/session.py rename to torba/torba/server/session.py diff --git a/torba/server/storage.py b/torba/torba/server/storage.py similarity index 100% rename from torba/server/storage.py rename to torba/torba/server/storage.py diff --git a/torba/server/text.py b/torba/torba/server/text.py similarity index 100% rename from torba/server/text.py rename to torba/torba/server/text.py diff --git a/torba/server/tx.py b/torba/torba/server/tx.py similarity index 100% rename from torba/server/tx.py rename to torba/torba/server/tx.py diff --git a/torba/server/util.py b/torba/torba/server/util.py similarity index 100% rename from torba/server/util.py rename to torba/torba/server/util.py diff --git a/torba/stream.py b/torba/torba/stream.py similarity index 100% rename from torba/stream.py rename to torba/torba/stream.py diff --git a/torba/tasks.py b/torba/torba/tasks.py similarity index 100% rename from torba/tasks.py rename to torba/torba/tasks.py diff --git a/torba/testcase.py b/torba/torba/testcase.py similarity index 100% rename from torba/testcase.py rename to torba/torba/testcase.py diff --git a/torba/ui/__init__.py b/torba/torba/ui/__init__.py similarity index 100% rename from torba/ui/__init__.py rename to torba/torba/ui/__init__.py diff --git a/torba/workbench/Makefile b/torba/torba/workbench/Makefile similarity index 100% rename from torba/workbench/Makefile rename to torba/torba/workbench/Makefile diff --git a/torba/workbench/__init__.py b/torba/torba/workbench/__init__.py similarity index 100% rename from torba/workbench/__init__.py rename to torba/torba/workbench/__init__.py diff --git a/torba/workbench/_blockchain_dock.py b/torba/torba/workbench/_blockchain_dock.py similarity index 100% rename from torba/workbench/_blockchain_dock.py rename to torba/torba/workbench/_blockchain_dock.py diff --git a/torba/workbench/_output_dock.py b/torba/torba/workbench/_output_dock.py similarity index 100% rename from torba/workbench/_output_dock.py rename to torba/torba/workbench/_output_dock.py diff --git a/torba/workbench/application.py b/torba/torba/workbench/application.py similarity index 100% rename from torba/workbench/application.py rename to torba/torba/workbench/application.py diff --git a/torba/workbench/blockchain_dock.ui b/torba/torba/workbench/blockchain_dock.ui similarity index 100% rename from torba/workbench/blockchain_dock.ui rename to torba/torba/workbench/blockchain_dock.ui diff --git a/torba/workbench/output_dock.ui b/torba/torba/workbench/output_dock.ui similarity index 100% rename from torba/workbench/output_dock.ui rename to torba/torba/workbench/output_dock.ui diff --git a/tox.ini b/torba/tox.ini similarity index 100% rename from tox.ini rename to torba/tox.ini

BPf@Vyd+NdQ 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 R4FVt^|NF(H6XUhq-s0&; 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�oa*{_eOyInr`1l`7cOA}G7r+4= z(>*cW-Q6{9Oq*sHn{GC3x~IFF8Kyg@hGB;3?ikbk?%wVl1()C1$`a7Pq|EN)LF0{o$lZ0wr)q!Qb+~VHSCz zEMH`BmATpPS8k&RMIz9;Z9pDpvpP6_kjo`!;rcS5+dLNDnGci~?crtTYJb$}DU3}_gp+;dk2zMRnbC!i zG?(^kFM97t`%B0hb$JbrpVD~wqCWl8G$6xiX1s8K)eP zSblzn`dhsxj-#ojyuorWNnXyV^;(Y22mU3#=?&xw7G}2q`JTwe0Lp{<*4vRk5fk;5AOleh(K@ z=&~uiVpZaIIVW}hrj*Y2#~hQC7qjBng0&R~@|fDbg7dY1w`<6q1k}TV?i}&4Ej*{) zF5q7CFHuRy?K0#6UI1~_#r47>X$xvh%;eBeP4Ku+7(W)7wy?N)Ve-;={5d}4F}L^( z0OcJuK;WbK_7OXKZ&cp@t|G$D%njKKAgTA828$AS5iK5jHGg%IGK zmvo+@Ie4TlZf#>SmNK%`J|7Wh8G^;JW+_A7{~Ek>tfi z2YEbhsUv{*PB6h-t7H-@K<=~yU;F2XODO*m+M7BQQn-AuKcvb!XI#WSDm7JzE=jjY zYKP%OO2f%@>l9*tcpWSp6a9q^@<`78!2Q!H)GS_me{|aNV$F;ZH0RQ<2S30%w^5-j zH9Ri|^8HD+da1AFM(Qf#cM zoH{w5D!BO|k5bnfeEufc@b1_}WeG3Zk1~h(!XLI^ntWbjRV8~A7=Z87c2$9u{Tc12 zRfCd+l%EReepbW3QME~5ic!jSJE|BP)DnX{6mHxQAfMgr>i|EISKns^z9Wt_tt7?; zRy*!W;Dyk!L{$U%G;h$;4_9QYkGCJNHrZ}LRtn9vRH=`aRn7-e#ir1eF5t zeL7^}iJ5bDMvvTAUO~Lvmp5892^^!nncK^px>SHC>0bWcQka0UhwAF~=k}DTfZeOs z0yiCgPhJLroM)s-?b47(;`0e?e-jSO-R{{}?`vD|BE%Xwbba{hZ(PMaK6*(`M*?2n zRq}?*p`d1gVlgF_d~Qitia}5-yN85!xi?ujMnT=G4CLWSzI_XnSMVsAYNl$agf!z< z{fh5e&Ix@>l3PUt>MvViGr*gtcU5}oL5Zk1Cy}j3W2-)l73L?NGJrgF^_Dx~9xvgA zGUPE=d;ovH%qF=BA~74Gu! zr#eyvp&c*Q-BN1Ux^M3Stw3G{@~Axr!0~o8lZ~sVg2JBl?t_gfI=wLeK17iF zyxA;sE>D2*DQhD~UiN0&Bu(nS9YD*46Zl$?7e+pU2zV*^Pa5+b_o%!q(GB{KQl|-g zcUfSPvQy!IZG+FBlJgBZMW0GSeU)nUC&o!X=Kkg34ApEY%2u9*HoM8w3SF`% z?;VV3wXT!}>Vw~d<%Mn6@F2zUPFbwt^I4pkJ0PE%iOp$KN}@2lXX=TO{_c~Qn(64~ zIxjE#y&4dxPVXe~b#F_zO|4?L%^x z_Fr<6@oD{;Atu1zYTm^KpXZ>3=@9z?`-M0m6cRr?>363vwR4gyBcB*y>pD9!RN-_j zAuqpI8|?2|zB98D4EZIzzuKU?)rcn0%m51qt78k7{#45c$S2<4p7^@?oNVBzZb-yj zsv1+wREp)ps+%`f`a0hF+d&t5$Sd}6pajaRlR5UQ^t~d+Pec9>+WzASsaqXS-;lON zp~fW;0p3Y@yfs}0_Ovg%Fzcc|4vjy*r%R-jqTCPrwcXjDcE@r~|Cd*`1MFY%$VJ#Q zOCoiVWJXW_*>JqHE?hccENI2_@J|HaXCkXc)DXXZ-Q#AymhvdLuSKrJybkV;gFJHEw|1=o`!E=Gr8iO!VO*iu7c zpuFkqMXTo9svhupE;*y1qRP}?Y1OWZc0i1LsIHGZd05uU*_(uy-HFe0@AQSd(0^Y{ z0rDY-v(lZ*X)O8O1f}&jthC@gOk-(@;wrvQZ_EYq4GZ1Jon`JD={rvD7e{t1Y^tMI zu{?7lpp{CI+GC1yr}KxryX0oD{`;V6_)AToH^HtYl+mfdpUIV!!kyt2=g@i4}1ahJf|O?<3?<`t<7o`RMQ&1Dak3Iy3w` z?&W7vK&GHcYW^op%~_2q_aMOgZD#@(nw(5~ZoU`gjjUOij^pEjC_fuUkNQD8H&iBK zBN+1Vf^fn9E_ukkIPP(yaU{%cf80jzq06@P#Dwm^IoZCr zBy6Syz|#qPJ`H$0HinAM00h?str=B*8$ru zDWTA>BTV}t6`94fr^Q6WO7P>?wgmwr&dC4Ed$QUE+z&xHv!C>C&xZYDa>>PC%<8Pr z;y#ev8pGF`YJlrsEJK@kcnHSF2deLzi^U_p8`uSUdTu%SWh$Up*p_+aiU05II3a-J zVN)^|Zr0YT_t7T!PZY+QqGDvow0o$`rQc6zNdfs5-<}Bwb9G9aT0E$CGoDhhIII>G z2(oQtr|`coPFo$Tjfe96phwXn^xL9Ytpd!V4Zw0g#URo;bEpH>TH$={RtvU_RwrW z8su?TVjcmW>c26o0tEqc4LO$f%@fkggK~}A+VJa~nl*ZG{ycb@Sx$W>Gd~~e$`1Ak z97{m>Uq0!d!`4}9h-j2a6imI@kVl+%39i>8)N_$&&(qBLz7(eYsjZ;o%nh?GZ(~v+ z3<(1q{~Ky(YjO}=6T>$4^e3QiOp_}=)0aF`#GFrIpZkpi(=?R}c?kE-;PtD0<)=Lr ztjeQ8NLD%%o<-N1-rOGq zB?l+$eexmiT0|eL?}db9e%m~YU`^ZRC2^gHEl~A-zNB?-NW%~N*ABRT!>$@_AI7C4 z8?%3<>b&E}^S-*lELi`p^w}0Wm<7Y-t8+2rDfNhf^|RA9vA2sCN3w%~2OOg<%R~hQ z{siucJ7&71eF)&imhc%RpavdUpJ1cVl1BYD>aXBH7u+ml_ePECye#!fDuX<{c3wi@ zegvNmRd*z>E5;=dI5@!Xdo8NgKHkKqG-7feR{&nS#z>-j99kpG5=PU_g_5;h>lDr; zEjvndU9mr%EIYzQ1>_yPg9Y>b`JVXm3TeAhd+0HN-=P^b{9!w;|BFiPbj2r6z$06= zJcX;4E_}-8zGSLM`o@1nGVqJvj>O#`n#};Ka`nA0kVi-2{SL@Czc!unm=#38KxQE* zgK*y3i3Hc#=MrhW()rOXu=@;Ytm1!f!X6c@PmQYeN!@L~ z(mKJK=^&6?yf_%s)7#VRN_G;Q1IKr73_Er17DRNvJGg9VM)YL~=@yTBrjN@k9V&g_ zvkZ7X{J(ePs|40BHr{sxBEGM<J?0_*P_4vHmW{W_X#I)(u0RphYpb ze%DK>t&pRng-z9^@a;gTT&+57(@CHGMKphZ7&sqlK#^DY{HPis#4A;jm+g7t-H8zw zVW6~LP&v^zB#jVxoe{`md@l~Rzn+xk;$u#|tNt$>YwRAEG_vfBS7idZEi?Ai!TC2# ztys>0Y~$D-|1%eZr^XEa_estfSeZU?2W_YLI!8j$aG3n4$}Huq)K&U4B7ObW3ygKXJfCjzbgE2B=NwGzqcE09N$`qv)tQcN=Z zC-2DIME(_KNWVNY@G!6I^qBHk>J4g`FdR=CX>qmBy%=f~t1z5G z%;go%2hlaii>Av2@5kGiIP4x*M=Lk1XT&5v{6hu|lS>GAd$~xjavdzbWAAYUb_+@K_WA-dbaxyQ?>SAJo~ zDi$P;%Z;H=v5f%_Tee@uqm~0~2Ejt{E-vXZ3#OEPjjd}eU7Z-H*{QAPgyZ9en zC`Ft+3BM;SiLp6s&LD4lR~BrKmIgy`uG)frIH*=qeX51`MK;G=#o%dw;aiXg)(4Rk zJjhh?lLDwQr*<{({+%}ylh@r|jbNla zArBF=9bA8<;%{sp0?n8H{!FH zoN(rBIrJ!ac+YIpHB7w=nq5g^g#`t^SAgdjilOy(F1Od>nE-u~rCV6TMKKBCupJ`V z)Ll>HN9_DYRLEoKW~T!3<+mLNdyg}av^rm@yyvTwdt%=d=e34%=aD-J?#EHg%Zyzs zm&B^L8hc%JPiB^4nkh(>jiWDg#gZiM&ZXRs19>b?PdNb3h*W4`1J4HSk43o^oC)<6 zZXs;9^Xe~x3|F*9AYVx+Y>3hB8x}PF5!9hTh3K_}G5;-Qg`+Fdxv3F9&fG3s$m8qd z0{gpONe^>h?S~r}2GDSxcF!GnZs*~JBJaXy)%^nJ-%v0%e)j}1SJ;v0^fDtoh(8OR zy1Dy3yn-A#A$Y0R=EQ=$CJURtLa6WXRJ0ai6|sRDpt>fd8@lO6W%vHSxOVwNmKiM-4upS}}tb;<$KZdk7bP2aT(`ndc|HOtj)N9$Ekan!;Jt9ZM3wb;| zgsVV#5s&0JHHZdidF9FN#SWkPJfzoio5c1G{rS5Kl- z)zjXO$_afvm*rNZ{^RG62;_0gQ-J-e(|*cC6cpi0VohygyO~ z%li<#h0Fr0YDFw)e?mkjIW$_#4PaAl*glb$2aA zB534&W(||QC;6m--nvgUQ(7NvKTbn4ejo5&C&jm$U(23y8BP-u?*XJr{mToEI}qpkcVVc4DR;}MXC;eYPVn^_I@LTP{54;CauMv zFbacv+lZY2@ETZ58P_>QTrS$Bf=nj|kiy=@mbk8+aNg8WHPvJAq$4Ur9{~Wa>OJ=pJ>+)rqxFQnvvg8Z`kApz zuzz6Tuj@fgnjR8!p?Jbs6F#XY){pRd>Fir#gP*c;VGTvL734i(vIXmxOO62QEZzoF z*i`|d;vkLZ!rQ~2>O1~sG;#eF1M;;V{yVdkK7)pF^p`i@=kN(xO0|J%V%bsNMbFR4 ze=@BI93YQOszV>hr(jiVQ;i}@|Nkl%cz>%O5TlMnmkJ>=1IM`{4x!(LAxS-0QWMq(%GeB)(xiU?)b z-RUGwDx)Gbknfp|dQVfIW6I$s$5F|JPA8==}RY?sbS9(6K9{Y;HrhbSFzD~ z<&9Dv8pa1J#tA-<2gmCGzW=V7CBHDXryqVwxtxMo-8uoEM}^IgoW9w&9|S(nHMv1H zGF;*)iZgE1i~l}PMCFN?So&fpkbWKJ7zh1PIVlA4;I9{#fPB^I)M%a(jrBna-};Q! z52LXO^zZFo5*GDs)q>v#euMCaJD)w35zgqk&XI8S#a|^Kx%JQ@MYT-~De>7Im-hcX zK_q+d{pfBL?W<^>vY_3jmVC8C22%+Ua_b4J+nfVwDIZW?O7Sim_GM#Lu0pNWsPK#I z#8Jl#T{_EwbllFrn+X3#s$!sg{Mw`+fP5Y?>L07Q;IpJL%TrT+@`Ud7U##FbPP|km z9jpgD4+&~_mh&!ciJt~`6m^Jc+O(@oLdCtYx%B%*unwJ+NQsa~ON=ZJc<)wG;mOwl*%I#pKiZlP-#E-Vis#m9;AR6 zQ)ME^k^*_S*O^Ix2U|VAX(IrOn(KRxd-a)%hWk3;d25etFZv+5t*zKzdl3sU38G*(vrAo|U^{UGcA@>WVn0^U`WnPSih--HnLHPwBp$*E>V zU-JIZiDaqtUvRwLP7_@se1YP%$}Gifol`*tZWO6d)3P|G8pe|Rco{eGX%6J^#NvYQ z(>s1;#~qEd14|y)RXB_Lh%=Rve9N|Q(qFi2!Sxmsd2R`;n495fzkYwZoD+Cv+Rpyi z+*p-+PMuEg@Ysu?QwVwNPsTlge5JPsDX}?os6ug_$4eg^GdnQtM=}Tm>eWt8M1b;A zPYK3W&K#J(jNiRX6R(-^>0%aRFUNuvxKE^H{kXOD>NDg$!(sXcct4C_qI-P5>oTd1 zwhnm26`4He88gMqs-qKjSpmFlj0mx|Z>}$g75aN(C=g=5x+I5&F#MF~sfuSj)A0#$ zsQ%wec|Qqwds@taaJ`bFN$sN{PBLDiHIJ8xk%|ft#%Z zUv|Oyt^R`tf)D1}ySJ;x+z!LOQu@hH^tGmpC^;9$cH_8z5h>p_6=s z5WS*mX$6}i>%G5q`Nm9evlK$q`U)?QFO7^Ht9Jx;SmN9(kosiXDS)a|JB{%nZCnHI zGzUpnd!q~T=%R$W0Z)kc%k^ts?;@(y!t7A~0bhyfxW4`Gg`0un_XWw_^J5Yyfh8mzv1|iIFU9n= zsY;6S;4;!m`duBePJ9hZU z0%HGmTdY=`RyyO^j6og;vQ-b@4cp%R?a~-4LcCk&bSIDc`vy5|Z%- z%p5$G2=e%49J`XYj2=)Uczze5rLH_x;csTei0|$^4tWcd9AN*?Y(7+YgOapKHY)uH zp#@{E=NXsxFYV706mL=0fqaQ>V)vF@cBge6m!woOFUWH8bUtTK=ZkfeKQAhllfF%! zfIJrS0dT*8XA40%>LWTvVRO^FWB=56OAGbznk{!qoyAfWz}wi)JiNe)UyNaSRHS05 z3^-t}WhVL=cjZ#V90X4lD|0vrdHgQ?VEcjpoU_>=vGoc*NE%2huO1txNtR@|e?|1bpIC7`uU(_)}KZ(lbM<4(9P`(_d0@ts(fa=yl z;^LWa@sakA!102Dota76#xm4rj;Y}M8`Xu)PJfS1*la{;wE-^es?af;-!DE!G5O7m zGWr6a{E0azpKLHJ1>iBAFgzh>zlhisYx#EqoU+x-LP)6T!OFMM6sB7sAAJP3O^$Rf z87qo-l!&+10LoK!VpSrky|>#rq{F5`7C+}9k9Tet9Is0zXKdQMQm2BS8(ft}TG@?J zfa~~7!@5E$#Uc)PT*OQTS@Wo`P;mK)MdF$1mJ$%%3d;Vr&y?$2SXkyI#4kY}A6^sK zA9oo166=k!VO8%+QVrZ&kp;pBAFZexBQ(B|*x3FKhRd>)@tg_U+jZ}MH zw&dOtMX)}dEXy}EkJbVL@5pz&9PhRg9RBxq{&mNI>-X7obZPI(2NO%= z>_}{T^UH^FL9DEH^(T=ws$l<_nqMbo@yjPamu1NwvMCaKW;41UI|W%K9Hs)%>%M=+ z?$@Av9L##LfTygbAcR;Z665BK7fwK6Sn@ZtTO#RDOUZ%BSQNIutfK2u_}ISkM3 zb>Yy4Fk$tJo{@*NScI1S4{Y{M#XFE!BtZ+-e}dedrz*oK;lGtAO0Z4k1G*>M^s-P9 z9G644wE^!}^9_@*(%Gp}RlXAg%B&ym%>+8{u+LMGk-65Esm^yy`;do+NeqrhNFBTR zO!Sz?|Kxh}i{c&HmyMQ5C;ASPCn81rV1L6*Erl-q8Q)eet$#yWSrYoO?v`cL$S_sg z518K^6uRtd$B@Uc@V*=<@2BN9)nhip_-me6krI@Qe7W_Q(DG+0y&~lW89=^VLyYm~ zZo;!_8&Yv4Eq5n#aI|@Ac}Wbfc$bJ|k0kp-FCmX{Fd!N5WXU|?>zMJId$&JG{RoQ+ zuZ}os&cKMOc36z@1ia6|qB%FUjp9Xh-=$2_d6qMIt#JB zo4!Nd>_$Si;nIu7^Jmr#8DGEDzsR;}7U6d7c>ob6-TU)aff#-CyEqQu_W0gYM^3CswQf$r&-|G&- zw177w>Hm9lriU$nCmPgrSXn>F3P(EZUd)O9fKDeXe_89ElSV2DzVG8ZWVgFlrr>D! z|829)W%_Hkikqs(Dkm&S=_Slq+#c}^9?C~>tC0(Mf>Zce-$tA~FJo1{urXLY6w>fx z()VclX69C|{QEP^XIEpb&o5E?5HO3S5d?~T@*64V%6>8%Q`Dd>6+ie$as2PqrwD+* zH(IJ`^i)yHlyj<^zi5u5>?JtZW}?p+*WAcm zx7%qlco%)Ml{_AR4CTwNwE_3D&)gjqvnKgZ&+@k|x6mM>(83-VynC;R6!dimtWSH) zxnv5*V=0gZQbUSbFej@0tB_O(CEDIA%}dA|eh;ofg*=kn(Q}}@Ck;q-ai>UGEXk9X z+d~E35se7M4NpwCo4$A{0{K!KI+wfFQHHSJK6_HFo>EbUG|j@sh|KuG)-2a4BcE#l z4f3eaK7s8UW!g#ZI{A!c%-fx-W$rTiy8WOr6S$dex8s@{k`F!QU@&_O37W z=EX7{UoOG@XK#zw8Xm@o+Z4GpoT@=Rx+k`c;PC&+yh=F3`IPUqOYCzCV=x zkt|THE|v`P7`QRffa_PZwxV`j+W^04dE)Qu_E}@D4qh&Yy+m-#rF9DM@=RRu>Vr` zf{*!q&?~lJnerKh&=(JRlWck)DYk}LV4kCxQ!u*f^-W+1^zo1-O18D_atV(xis$`?bE;Dz8ywt>{PWU@mtQZY6}&=OvK~ zc_ELs@nbaLReJ@lVs1AmjS0k-2=%OWEZI+A9O8|``)O^Z1Kyu}`=P=4Pd{D^))2N9 zCYgP&pC{*~9<(hkV6bs3F`;k}ggi^W7979}{Vu|SEE=NmgX`!ONqOMJ9b$P{m`t&? zKr=Jge$17~f3`F~MP2oMp0SzO784+>H@DL4^Ss`&hISzze(i|}a_;m# z48)Lqkq_<)7@NxDuJ6N4EV%6Y!_`xPe9IJxTP-LUx7vqeyW8S|qkX+;GL_R;6c;M$ z`K$32NF?HrCmtt*1$ZrDf`^``3ra16Cc^NsD#B+TCD@6=Ynpbr$ijeEyXRzlez!z} z{o*Vqyl63OU_EanZS;t)%<0D`7Oa^tWC_S)8J=_pyfsEvf}m)|VKwPDFvl)Z4Ts6U zynI@Il=beUf%S{;m~4JyI)3SS8l78zmG-m^j$$x{!6MxfO-08GevY6bNytl`IRSqk z$}!L9=UJIl@N`R~_Y9YwI4jM#nI{##WYZYN2J#hrww=6=vTP1jm|{Ml-VgRSv!B3P zgL{&>Bxt4i^33>!6y!a7y#*U2!`*^M9BCUY7lIr{cR5Aag3 zv9ilc7mF!As846~!fw+{W*olN+7^}6P>v)RQyvmjfV_hnHn2W@w>5AN`|l8Vk~e8H zH~I+Qhc2VE!(R2Abx2^>pdb7q6@?Qb5lUP{Q7iEx0aw&+w{PhS zai%Mh|m3j>qCWeey0{ z(H^FQT$;-NJ>oADV1L(Tr*bCckPi*J`i$uOtjLufk(Iq-s8mqDhzH!?gMRo;$w@Nz+&Nm8mc&a%pX>FbQtOXhx6TaCE zw=RaW?6k=B)B-Lq48Fmu8?gqq<;#}FFRs&vX719=-`^U*;XD*3uyn@h+MvFIJZ^Ox zaQ_GXhLbMpv?!D7z#7wbSTD9?AO6wM^Ah~bgPFI0M~269Bp9(1+*8SNGC7Vr&+r$9 zmU~zWyEvLbZk|PV_DBcvp0whf0s%0>>g6d5&o{CtjvQEMuN7{0;|FZ5wkwQ|bT|R; z{;@5G`H*ErI=2L?SCEf}ToAG&Uv|p|~v9xFGd3UYX@t1qdtB?+@YeClr^0c(k!Tv$v3U99_ z@=yAg#w1AgHbkjo#P4$-ZmT{&j%{uOp52R?7iBtsx;rcPXjAlMKhNCQ!^Pzmrb@Cc zRV6O)_nFy39y=Cv{$+{g%)l#hO92{MN^Oa|2iT-cJg%Rb=i2c8M#g}L_T$zmCnR{D zRE~Cf$fAJ(SJ50kCH!{c{zk{j`^Q_ydI!jZePwS5ls5x$TU=TtxYUCvke9s_U48+3 z;iy)0@tazpt2f}uPQ8u(EqGUj$$g7y@_chdR?yh;lYr;D;#Vog5g4y4$ebZhgJb}# z|K#5*kt~>UaG@e<7>tbW>C4**0wr}B5G)(u zC^Lka2|SN!m2fecT_6vBb<-cnr-UdSN5^%Pw@kxE!8Q6VV4QlL7_-XkI~!sU72xUA zADOPZMTtvxS|rK-MfnA1X;7RKk8RLrfW=X*lj?MbiHxSt5-;yy}Qi z)I|Zj&NGT*Bl$Uh;*3X03k)M_wu_h6&%}o@FQ=wvh8@ucZDSx$I|&b5-$d?La==6G zzPvV}{7r4!*W>^;&lBDlPCNHHp$qV$9OXw-%G!%M;9X)y{Ohka2Vf@*oAAAI1T1$e za;G{}6Csbyod|3{_5cy4qLA%YRuUO-#@BX#)=BdmaGXe zNe$uhj$=t)R%LR05Xaz1eNTJTHz16e40-%djmm)XqA6^YR2U9^ZdDmuw#%}&ZB4er z-0kPX-atn<0rJ^ikfXl4@r+dU;Lc2;4qMqA9aS(5ia$f?rV5mGv@JHuhCJGRL|MQ~ zoo(7KLM^J4+kWjVIAwPvq4u*y28D9Wp6%l~;2|IFzwegU?$ED#N{ohyQ@k2l+B49FLRLm(8AhxM037A<*> zI65E)nXTtt-S1y`jeo;|d~rTy$jI$S)HW)$+c+ZHZ$9)}igynljYlXnH)|)s6y#S! zo?tF?ev}tRxc9Ii`Fs6!?Zf&~areT9e#b71)$)p3JFxy!Utj1leBXb?C$65ydsIJ9!MN;h+p2s0LGwsHYl1xL3=Hu5tZ@GCstEA^ z9ARk8stWKd_*pht9cf+8&ilIa@&R6N?XXvdqj}{AHGg|P2J``DTCuzz+*N{ zh7S?)tEj+DQ83-V^i+;aaQID8*vHkSpXq4MkFYlac}%wlF+jcmdWD@l!eX5ew4#K7 zHC8XA{AwOr9|k>lgema-Xv6?pZ=Ep$P3OD(>m}UF3;Lpnv%404jJJmJ0_=tk#R}t) zCm5+U4tN(l@J1>w_CNjI!f&x~FRR)|65Yni=yy|yJ;D0EZ0qrMcRfyOV_}au|6F^! z%R@wDyj|V8{1|g(d18+Ed2^s)qT-*MmXZU0#I$UdVoQ9BPS zm@oJX)5|_LXA4nsNuO8CDU4IJHt}x+@YfEnw_Kd&ug7v0Adi{k7w9Puy)9$n;nGyu zoi(i)4d&mkMEf0FEi8<^;{%?Dv4qqsRqB6X9Pnllt#$DGvj?-uKNCM-HJ#~*a-P3? z4u`M-d6W!7JIP=(pV^|FSK46%g?~k%wU7 z6?sY``=@vzam*KoP(ESm32=XpY$hIYNr%FlOH8+Ag}ID9Yu>fTlhPL7-R@0tz;nu{ z!N+t_VYB$?sP7+Uusi(-@(AomUjf%I;wh?Z&CeP8pKw2M z>Zm{4%A6E?+Z?5&kB;A%1D^5GEMk`VxS3Uff##$x<$S}D30?mA%4|X(Jh~lbS_a-3 z?F}OGwko6jD_>V5&6z;a^&h%QSwnXk(rQJOYZC^teD>fqZI@%2&Vg z)SjBxKJq!U>mu`#U{QF6KgeA|UWMK~SihLab8hO{cj~tOHdK*FUrN~BlusN;NX^-A zy(|Gd;``(N@_037RO0Oh=b8jM>dpCZG+Od>!l)9}- zPNbD0dRS3t{n~z5A#nY49@Gk#8cyoNYZ_NP{~|~uUxzWh?4^F6 zO6ZPDvltbd{VxTMt-pV)?oI_AwbgVsq7f?KAP*JU2b}+)N}m1KwNJ}i*UUpwMvc;Z zn7}WiJtE_sjy?YGj$@!+l^oxEb(pP6w|ht_E>U0gYU_qnx zko<~q;;QGzSsUg&6S|Mq2l9O_F-_b3L0J%YSEIxGk}*~}L$)Hnfyw=hSE2Z8;N6(n zzawxSA7RMojDLiH`Q{B!eEYteCHmC2GPN%j9k>$;%9qa=_qe9n10J@Z??S=)GRZqe z{K2|avm+_})Z=d_V>-!U?m<=kru%Ii*46v-^c60xUWhYdF)-qG?QA?vppsj zu?MZRFHhJXOwFnOzaL`;&jC+8)j1>S+ra#N^w9EZV{1s<4=tMexu76@I2Leze^UWX z)d%s%xDZ&!OMWzcatV6K6Q=!Y3wUEE*QOQ(i15URNHH=3 z*X2a&YMBGr<(xk%B=Y|K8Rq%im@sjS`T*@~W+lg^FNvt*iUjrdGhJG)31R}!l;lLFp$_{K;$f=~Iu5-e_-kNRP_Vh(Z;_Q!y+A|{&J zemx8V0m!4G+5*dK>>XaWJDw4=s+BME14%a9JRmsTQ2=(Wa@?FA@D%NkP(Sj?boUk2 zzQPJ4Oc9k(;=}4HejPu@bepNtX?H9PdCy=_ae?cXwebTHx4h&!3{+0Z#+=};^0*(-U*&H5@&cOm4&j~b}xh=q`S6i!Dz57B|w=flPq0Jqj zoMYxXsVKgHLct>rd4h)vK7cnkTs&C<7ja!y#jn?_K&dFk$^FV>Dl_K>w|y7L*TX#V zUL@IT`@OZ=L21)6Ip2<3dx9=kE$_bDk@1U*dlqTPW1tNI$BQkcf|dM(+kG$Odfd`RaFUFA!kr{X+-7y7Pvf+HUf?wsFoogrIk zML&wzk4Vq~b>HlZ&hb7`Jia>QS-*@0=ks0*{KP*Onh{FpP$9g;h>bLzis}9Q3ntH+ zWbqO3A~8C=KayH|q=_=yVSi=9VGUg0t|f5sD4dxRk!p6{uG56P$-kB;!1d#M;P%5m zm5(kk;FUiuMtNY@bL}VAt&zo%k_PXG_Y)yfF9*CPn=U1$EBHE&WCnq6GPiCmmB-K6 zf)QT*{P7C%xL-tq{g*i7ldRFJ5{1%)EfosCsh9H{SE5XsBZ+{G?E7)YnGil&PTS2avDj z?A2J-u+XyPw^7Z;Ry9M!btMKk_$BKyr*+Oo`k_-fYsjN-XD0($8%@Xy#nH{rmbOE~@P}&Vo{R zJIEub-T}Sj_fL8p7^h8AL`aQDj zRTu`~MMUXKh-E~R`F=dC@{^b@hMyF07HT8tDQ%XJS!z=!a6~CP%0kI3kcK|Gb{~fdQ_M{gzw0{tTg+bUk=2RdI?Pb#k4AOrGE;oVe{9 z3I^I&LqndB2Om!guCEIUccMI<-={OMR}wle8VYySAi)2(ZuA!?4=cEykej&Mlo(a@ zwaYs(o0Ek+nZg|0+N7rzPs}Lx(4Pr?s6X_DJQ~t5@cBc)%!>3GsLLh8aNP*J6qO;_ z4Gb{pdwN|qI@S!7S30+miSDm|nW44kNg~Z)%dHZOro!VVWBrrugZN9X%I*NjL*kNa z1E0U{J3|%u5>|`__~(Uc#|<2Vw^I${>u3jS8DRZPlDBxW)R}Ex{aDZU*pYi?-ddb^ zA-$WOs)HUjD4h9@A?$xo*%zFzRaXrvHZ6j8*9mJJ5M;Ay+II+{>gN6OZKhN01(5HO z%*N7%JCKuHNhBqB$sxtBhkHsk>%cW`_d+@W(`K|a67q=4&%yDM3_sf!+>NCh3;_`u zrUc`AV^K9Jd^QNmo6S1ufcITnLnB8pPskoul?KU&9p;JmM758kXp!!ypYL_!$2P=I zkoP=J9~^I|)hjxlE+mRtXxu^6QV$AOd(K4AzCsn|fb8T3cv5`iJM7rVR;qdad@nyg zkT@yjl#ix{J=Jax{P%lBk+6^bzr5c~e*xEz_Rq=IZM)d42%Jhg!5``qqrlCV(p~Wy zjQ*V9`|rP91h^!RhMQ`~Wj{))7U3UQD9LV_-#HaA zMFqE`6WW>o5~}H|Ws)y&G9ceYI93nof0F{``+@Kh^eP?*S>S|mSW-rb8p{?7+Ivw5 z#D1{x@-(~4fb9oahW+;!P9s+a?s+aYCabM1DD0x*9}dNCinxZpDefxRr$JsWl@Pez z47bEXIkVdMb2M33eXi+tAA3c$H;+xfk3OU3B#^J#%@FTX#@v?JQMX=Y@@wx2%HIh{ zj+z2yf9AB-4~V|E|2vrq=xE>Yf%@G8?207EZZVr6Tsu zfcp`%FK6EPx!*8e73<|}(!}gFgpErD5ZaQf>D;i`aNuWt$bvkQcakpvuT9rE=S%nd zNpWXsN;~}G`*CbhJ-r4+hCd>~;QA(&;ClUidp)+NGT3&i#AuX`h_Qq6o<}sFiY6>5 zqi3z-@*t1u3vD;xrMhmN6OCEO>QdmR8tu}?p*sD5+ktOpnD8e6=evvNsb7`ue{xq) z3&$j+4x#@-D7fA?uYFFF8LrddIQI8-3FJ{TNQeTSrksK=OVqKscwvU~;;1`y-kb*+ z0p(FNa~CqWAE%A*%imNsyc9e&{4}L87 zkP_+c?vQRo1Zj|t>z=*8k3PIJyJyeLH?zCu)RuY;NdNvERLjJn`IlHbCa%kZ)hvyf zzL&RFh&5qgbmUpaDo?zy<-Tg>N_S_Pn&EvnSr@>|bC)m;XGJ%& zI20@%)_u{`IMAFuwu#(vefSfm6y1(Apc(W;q%F9M?knuNrvNX8r(!?pneo{28ApgU@R}IwL*K!VIC-I%0QQ{0Ux%H2EueQaO$V88 z^-0KBb=fHmbf>BGR(OBlMxMpIZkG+zp^xf>tcS8$EgME1J_LAGz--5!6XA>H8eoW_ z!izVB>t}u+iJke<@qc?yd?52*mPbv?>{qzhe;n$wIJvN$BhBAOVU^44XP0tA_QM5r zZs>$h(Rovh_%5fCloL20zJf{r6ZvK)HOws5Sftrg z&Lx*IE}q!Tb7(Lu%CUtG?=SEMK<@=63S@lRE71U(*N2sI_lEZO zebDGvz=M0EeduDC-SYdlaE_Kchdjfj;9*{hmf`g_G_8uM5{I6; zf8BhRT`EUFkDECv3FyCt_QSLYI3_W%5&w@m#BtLk>C&SGaM%JJUT`yjm#1AJCS(1Y z_%s;jRp)g)zI0kX3lwd0!-q%tpTncu1I;s_M>FjW*)Kp2*U*AzDO7R9hTN>Tj%{~G z3m>bBvyP$?r2|>-;r&n>*6fNjL5zzl;1M6Qq_?wfrdL`iu8*MDLP4akJG=yX6fY?u z_1N!@eooP9eej>>u@5!lo|TNPr`wV%yMP2*699zUm@!$ zCph!g67o66a~|widPr${MKAv{+gvb0??&)jeQ`p24*m^#_|I~X`V|Yb`(ZIrpC#3< z#Yy_lVls|zhW8B<9|tRy7a;q&+%lyN5=t?Dy)%b1R&^>^p19h~c-HIq$YuIHN5kT0 zSNJjLambwd0r`BQ^<-A*1?%gF$n28h?rVZ z95l`~R6!%Jwh!v-LSreCCg)tuh|o*WgF;2_0KAl@WSB696C24~j9ICoRZmprdIGjp z%#)%H*-F665n7d|DP`6k^q&@lSsS-VmG(K(A+dgA9?a(@#3{e$cnx~gNcE6*T#-#u;Gj%&rtd& z3A{SxBJU-cN6=$VvtZs@WN7gyJVJ>GkxZB}5W&OyM1J}-0(gmChfiky zT57@xKG5&I%7_B~y?2b->lS4u#SYfs{#4%$P5|=z`;w^#vLCpgiwgHa!{9#5qRZmy zfbIKo7+Z_(h(d3HNO1$;^-k7>N$SZ++Tr>kNM>f!dr`Qb61WVdCn-_nZnNy~q9TLd z3wHuNAYZ{!CP$Y|qWq`%6YpQ+HN#zOOcI|zL|1Z*J2e5`n(`K+|7eiXk%-kybZ6*m z*}5CoCUhUT72yEYO{?QMnE$=ci?xvPONmL$&=i@Rv5+*sp_Owy&+WWGW&p+?;dt4E zX}~kC{8^md$67>ruEh3+k9qoJX=ubwmmSfYou9)cWV9m^1SNR1V)zE@*gju#hd@AR^2RnC*zu(<;5q$9`;TFh;Or=O$Qt#o> zi+UZdP&NFR-Sl}2%ipWb{I&YsEtEm~<^P_f6e~R78CCkk(G6tV#w|HLr}w37RU_QlVOG4m5ul-YC-HkeO0bQ@B? z-y}PP$`*T*Iv{k$pWyj$V}(h&`A*`yBEyv9I*_j|%?pY0N-E}|9l@OuG5Z#IhzFVY z7j9a6x}pT%;K5cUG3aq%N%#Z#rt6`1vYdw{G)i+R2~)3^@Ht%*>7oC=Vlgp<>`$D& z7xG*FZ8FqL`Ss#$U?45yX^IlU9yNlbNp0zOH0N??QqX$|H4Ld2U(ikl21*&8&J>1V zPg^s1qj6y=mq+X7i-|hh0Qt7)RMS-?ls>tT(%hk}&Dr#9&~uvV(k6;^T3%oJ;x+S8 zf*#wl06ipM;_o;vM($P*OU(^i9Rem%4%mGG+zgB5T)GDz}NV)ruPQj?$q~0k0ra$1bG;H~f*Q& ztPqP1^r$kcA^Rh?IdWfM7Vqum)wIug%N(MaFKbXL1(Rf9CCn zo2Jq$1{2A-d|gq{L)(j^0FDQg$=^ieV8V!_prmk-HKKnLo9z{zGCPJ+ttH6*@edg~ z`?gTG94eia0H5(tY zPvk2fvg2U06va5zJR-KZ!fmi2F9!Fh*QE?~?#Y7>> z#W^K41U>HbwtT>2=lf-4qc$Kn`zY&shEl)z9Z6Ac5yQVn6Du_vXs?&;F4t&jZ4$g4 zW%K-2axCc?+M%JbA?1q!&4~gkV#5Qk* z(!7#9K=ZQ$yjQa)2?Yn5AM9k<Ge_{o>eU=4WWzFV` z(R>)>to>3`PwhdESRJ|o@SuiTm3|Y=-#u*em-2pgiiQVM>i2{c$KCkWgOvcRoS+L6EqTDKD|J&J*;G z1ydpQXTI|sPN(Zp&jiWqwx-K!V*m8}GG-y^c?&#x$o zlYsV~jQzyZD4eS<$jCdkDW!Rrmg-UdJ{1A^aCMe(?Gy8mWGLw2MeIV}N9vg}dJat` zyQxDlaUVkQ*6#NWZ~U!>m)y6JOvri}+Ab9-dJViJ9;aEZrNTQ{b3yj@gQFUynjF3< zhp*nL7vZ2MmirAdzNbp&C2Y)}MMi$p-aoN0YDhcLKJrmva8S_Zju6Plat=QjG)zw_ zDcVXILgHHaE1*6v;5d)7%rS2wMQpIZHwyHy+j<~g?oZ0qsVd7qb%dj?HZ4+8Uej

BPf@Vyd+NdQ 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 R4FVt^|NF(H6XUhq-s0&; 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�oa*{_eOyInr`1l`7cOA}G7r+4= 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