コード例 #1
0
ファイル: validate_wallet.py プロジェクト: F483/btctxstore
 def setUp(self):
     self.testnet_api = BtcTxStore(dryrun=True, testnet=True)
     self.mainnet_api = BtcTxStore(dryrun=True, testnet=False)
     self.testnet_wallet = self.testnet_api.create_wallet()
     self.mainnet_wallet = self.mainnet_api.create_wallet()
     self.testnet_key = self.testnet_api.get_key(self.testnet_wallet)
     self.mainnet_key = self.mainnet_api.get_key(self.mainnet_wallet)
コード例 #2
0
    def _setup_data_transfer_client(self, store_config, passive_port,
                                    passive_bind, node_type, nat_type, wan_ip):
        # Setup handlers for callbacks registered via the API.
        handlers = {
            "complete": self._transfer_complete_handlers,
            "accept": self._transfer_request_handlers
        }

        wallet = BtcTxStore(testnet=False, dryrun=True)
        wif = self.get_key()
        node_id = address_to_node_id(wallet.get_address(wif))
        #dht_node = SimDHT(node_id=node_id)
        dht_node = self

        self._data_transfer = FileTransfer(
            net=Net(
                net_type="direct",
                node_type=node_type,
                nat_type=nat_type,
                dht_node=dht_node,
                debug=1,
                passive_port=passive_port,
                passive_bind=passive_bind,
                wan_ip=wan_ip
            ),
            wif=wif,
            store_config=store_config,
            handlers=handlers
        )

        # Setup success callback values.
        self._data_transfer.success_value = (self.sync_get_wan_ip(), self.port)
        self.process_data_transfers()
コード例 #3
0
    def test_together_sender_key_and_btctx_api(self):
        """
        Test of possibility to provide the ``sender_key`` and ``btctx_api``
        only together.
        """
        btctx_api = BtcTxStore(testnet=True, dryrun=True)
        sender_key = btctx_api.create_key()
        self.mock_get.return_value = Response()

        # test only "sender_key" given
        self.assertRaises(
            TypeError,
            core.download,
            *(self.test_url_address, self.file_hash),
            **{'sender_key': sender_key}
        )

        # test only "btctx_api" given
        self.assertRaises(
            TypeError,
            core.download,
            *(self.test_url_address, self.file_hash),
            **{'btctx_api': btctx_api}
        )

        # test of now exception when both args are given
        download_call_result = core.download(
            self.test_url_address,
            self.file_hash,
            sender_key=sender_key,
            btctx_api=btctx_api
        )
        self.assertIsInstance(download_call_result, Response,
                              'Must return a response object')
コード例 #4
0
    def test_core_audit(self):
        """
        Test of providing correct arguments to the ``requests.post()``
        and returning gotten response object.
        """
        test_url_address = 'http://test.url.com'
        file_hash = sha256(b'some test data').hexdigest()
        seed = sha256(b'some test challenge seed').hexdigest()
        btctx_api = BtcTxStore(testnet=True, dryrun=True)
        sender_key = btctx_api.create_key()
        audit_call_result = core.audit(test_url_address, sender_key,
                                       btctx_api, file_hash, seed)

        expected_calls = [call(
                urljoin(test_url_address, '/api/audit/'),
                data={
                    'data_hash': file_hash,
                    'challenge_seed': seed,
                },
                headers={
                    'sender-address': btctx_api.get_address(sender_key),
                    'signature': btctx_api.sign_unicode(sender_key, file_hash),
                }
        )]
        self.assertListEqual(
            self.mock_post.call_args_list,
            expected_calls,
            'In the audit() function requests.post() calls are unexpected'
        )
        self.assertIs(
            self.mock_post.return_value,
            audit_call_result,
            'Returned value must be the object returned by the '
            '``requests.post()``'
        )
コード例 #5
0
ファイル: test_App.py プロジェクト: littleskunk/dataserv
 def setUp(self):
     app.config["SKIP_AUTHENTICATION"] = False  # monkey patch
     self.app = app.test_client()
     
     self.btctxstore = BtcTxStore()
     
     db.create_all()
コード例 #6
0
    def test_authenticate_headers_provide(self):
        """
        Test of preparing and providing credential headers when ``sender_key``
        and ``btctx_api`` are provided.
        """
        btctx_api = BtcTxStore(testnet=True, dryrun=True)
        sender_key = btctx_api.create_key()
        signature = btctx_api.sign_unicode(sender_key, self.file_hash)
        sender_address = btctx_api.get_address(sender_key)
        self.mock_get.return_value = Response()
        self.test_data_for_requests['headers'] = {
                'sender-address': sender_address,
                'signature': signature,
            }
        download_call_result = core.download(
            self.test_url_address,
            self.file_hash,
            sender_key=sender_key,
            btctx_api=btctx_api
        )
        expected_mock_calls = [call(
            urljoin(self.test_url_address, '/api/files/' + self.file_hash),
            **self.test_data_for_requests
        )]

        self.assertListEqual(
            self.mock_get.call_args_list,
            expected_mock_calls,
            'In the download() function requests.get() calls are unexpected'
        )
        self.assertIsInstance(download_call_result, Response,
                              'Must return a response object')
コード例 #7
0
class TestAddInputs(unittest.TestCase):
    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    # TODO test signing

    def test_add_inputs_withchange(self):
        txouts = fixtures["add_inputs"]["withchange"]["txouts"]
        wifs = fixtures["add_inputs"]["withchange"]["wifs"]
        change_address = fixtures["add_inputs"]["withchange"]["change_address"]
        expected = fixtures["add_inputs"]["withchange"]["expected"]
        rawtx = self.api.create_tx(txouts=txouts)
        result = self.api.add_inputs(rawtx,
                                     wifs,
                                     change_address,
                                     dont_sign=True)
        self.assertEqual(expected, result)

    def test_add_inputs_nochange(self):
        txouts = fixtures["add_inputs"]["nochange"]["txouts"]
        wifs = fixtures["add_inputs"]["nochange"]["wifs"]
        expected = fixtures["add_inputs"]["nochange"]["expected"]
        rawtx = self.api.create_tx(txouts=txouts)
        result = self.api.add_inputs(rawtx, wifs, dont_sign=True)
        self.assertEqual(expected, result)
コード例 #8
0
    def setUp(self):
        # Create a temporary that will be used as uploaded file.
        self.testing_dir = os.path.dirname(os.path.abspath(__file__))
        self.test_source_file = tempfile.NamedTemporaryFile(
            prefix='tmp_',
            suffix='.spam',
            mode="w+",
            dir=self.testing_dir,
        )
        self.test_source_file.write('some file content')
        self.test_source_file.flush()

        # Mock the ``requests`` package.
        self.post_patch = patch('requests.post')
        self.mock_post = self.post_patch.start()
        self.mock_post.return_value = Response()

        # Prepare common arguments for the API's ``upload()`` function call.
        btctx_api = BtcTxStore(testnet=True, dryrun=True)
        self.upload_param = dict(
            url_base='http://test.url.com',
            btctx_api=btctx_api,
            sender_key=btctx_api.create_key(),
            file_role='101',
        )
コード例 #9
0
ファイル: test_App.py プロジェクト: pombredanne/dataserv
    def test_fail(self):
        # register without auth headres fails
        rv = self.app.get('/api/register/{0}'.format(addresses["eta"]))
        self.assertEqual(rv.status_code, 401)

        # register first because ping is lazy
        blockchain = BtcTxStore()
        wif = blockchain.create_key()
        address = blockchain.get_address(wif)
        header_date = formatdate(timeval=mktime(datetime.now().timetuple()),
                                 localtime=True,
                                 usegmt=True)
        message = app.config["ADDRESS"] + " " + header_date
        header_authorization = blockchain.sign_unicode(wif, message)
        headers = {"Date": header_date, "Authorization": header_authorization}
        url = '/api/register/{0}'.format(address)
        rv = self.app.get(url, headers=headers)
        self.assertEqual(rv.status_code, 200)

        # ping without auth headres fails
        time.sleep(app.config["MAX_PING"])
        rv = self.app.get('/api/ping/{0}'.format(address))
        self.assertEqual(rv.status_code, 401)

        # set height without auth headres fails
        rv = self.app.get('/api/height/{0}/10'.format(addresses["eta"]))
        self.assertEqual(rv.status_code, 401)
コード例 #10
0
    def __init__(self, url=common.DEFAULT_URL, debug=False,
                 max_size=common.DEFAULT_MAX_SIZE,
                 store_path=common.DEFAULT_STORE_PATH,
                 config_path=common.DEFAULT_CONFIG_PATH,
                 set_master_secret=None, set_payout_address=None,
                 connection_retry_limit=common.DEFAULT_CONNECTION_RETRY_LIMIT,
                 connection_retry_delay=common.DEFAULT_CONNECTION_RETRY_DELAY):

        # FIXME validate master_secret

        self.url = url
        self.config = None  # lazy
        self.messanger = None  # lazy
        self.debug = debug  # TODO validate
        self.retry_limit = deserialize.positive_integer(connection_retry_limit)
        self.retry_delay = deserialize.positive_integer(connection_retry_delay)
        self.max_size = deserialize.byte_count(max_size)

        # paths
        self.config_path = os.path.realpath(config_path)  # TODO validate
        self._ensure_path_exists(os.path.dirname(self.config_path))
        self.store_path = os.path.realpath(store_path)
        self._ensure_path_exists(self.store_path)

        # validate payout address
        self.btctxstore = BtcTxStore()
        if set_payout_address and (not self.btctxstore.validate_address(set_payout_address)):
            raise exceptions.InvalidAddress(set_payout_address)

        self._initialize_config(set_master_secret, set_payout_address)
コード例 #11
0
    def __init__(self, url=common.DEFAULT_URL, debug=False, quiet=False,
                 use_folder_tree=False, max_size=common.DEFAULT_MAX_SIZE,
                 store_path=common.DEFAULT_STORE_PATH,
                 config_path=common.DEFAULT_CONFIG_PATH,
                 connection_retry_limit=common.DEFAULT_CONNECTION_RETRY_LIMIT,
                 connection_retry_delay=common.DEFAULT_CONNECTION_RETRY_DELAY):

        debug = deserialize.flag(debug)
        quiet = deserialize.flag(quiet)

        self.url = deserialize.url(url)
        self.use_folder_tree = deserialize.flag(use_folder_tree)
        self.max_size = deserialize.byte_count(max_size)

        self.messenger = None  # lazy
        self.btctxstore = BtcTxStore()
        self.retry_limit = deserialize.positive_integer(connection_retry_limit)
        self.retry_delay = deserialize.positive_integer(connection_retry_delay)

        # paths
        self.cfg_path = os.path.realpath(config_path)
        control.util.ensure_path_exists(os.path.dirname(self.cfg_path))
        self.store_path = os.path.realpath(store_path)
        control.util.ensure_path_exists(self.store_path)

        # check for vfat partions
        fstype = control.util.get_fs_type(self.store_path)
        if fstype == "vfat":
            logger.info("Detected vfat partition, using folder tree.")
            self.use_folder_tree = True
        if fstype is None:
            msg = "Couldn't detected partition type for '{0}'"
            logger.warning(msg.format(self.store_path))

        self.cfg = control.config.get(self.btctxstore, self.cfg_path)
コード例 #12
0
ファイル: DataBlock.py プロジェクト: djandreski/hashserv
    def generate_block(self):
        """Close the current block, and generate a new one."""

        try:
            last_block = latest_block(self.conn)
            last_hash = latest_hash(self.conn)

            # Get Merkle Root
            self.find_leaves()
            self.close()
            merkle_root = self.merkle_root()

            # Get TXID
            blockchain = BtcTxStore()
            hexdata = merkle_root
            privatekeys = app.config["PRIVATE_KEYS"]
            changeaddress = app.config["CHANGE_ADDRESS"]
            tx_id = blockchain.store(hexdata, privatekeys, changeaddress)

            # Close current block
            c = self.conn.cursor()
            query1 = "UPDATE block_table SET end_hash=?, closed=?, merkle_root=?, tx_id=? WHERE id=?"
            c.execute(query1, (last_hash, True, merkle_root, tx_id, last_block))

            # Start new block
            query2 = "INSERT INTO block_table (start_hash) VALUES (?)"
            c.execute(query2, (last_hash,))

            self.conn.commit()
            self.conn.close()
            return 'Block {0} Built.'.format(last_block)
        except LookupError:
            return 'Block Empty.'
コード例 #13
0
ファイル: test_App.py プロジェクト: StorjOld/dataserv
    def test_fail(self):
        # register without auth headres fails
        rv = self.app.get('/api/register/{0}'.format(addresses["eta"]))
        self.assertEqual(rv.status_code, 401)

        # register first because ping is lazy
        blockchain = BtcTxStore()
        wif = blockchain.create_key()
        address = blockchain.get_address(wif)
        header_date = formatdate(timeval=mktime(datetime.now().timetuple()),
                                 localtime=True, usegmt=True)
        message = app.config["ADDRESS"] + " " + header_date
        header_authorization = blockchain.sign_unicode(wif, message)
        headers = {"Date": header_date, "Authorization": header_authorization}
        url = '/api/register/{0}'.format(address)
        rv = self.app.get(url, headers=headers)
        self.assertEqual(rv.status_code, 200)

        # ping without auth headres fails
        time.sleep(app.config["MAX_PING"])
        rv = self.app.get('/api/ping/{0}'.format(address))
        self.assertEqual(rv.status_code, 401)

        # set height without auth headres fails
        rv = self.app.get('/api/height/{0}/10'.format(addresses["eta"]))
        self.assertEqual(rv.status_code, 401)
コード例 #14
0
ファイル: cli.py プロジェクト: StorjOld/metatool
def args_prepare(required_args, parsed_args):
    """
    Filling all missed, but required by the core API function arguments.
    Return dictionary that will be passed to the API function.

    :param required_args: list of required argument's names for
        the API function
    :type required_args: list of stings
    :param parsed_args: can be any object with appropriate names of attributes
        required by the core API function
    :type parsed_args: argparse.Namespace

    :returns: dictionary that will be used like the ``**kwargs`` argument
    :rtype: dictionary
    """
    prepared_args = {}
    if 'sender_key' in required_args and 'btctx_api' in required_args:
        btctx_api = BtcTxStore(testnet=True, dryrun=True)
        args_base = dict(
            sender_key=btctx_api.create_key(),
            btctx_api=btctx_api,
        )
    for required_arg in required_args:
        try:
            prepared_args[required_arg] = getattr(parsed_args, required_arg)
        except AttributeError:
            prepared_args[required_arg] = args_base[required_arg]
    return prepared_args
コード例 #15
0
    def setUp(self):
        app.config["SKIP_AUTHENTICATION"] = True  # monkey patch
        app.config["DISABLE_CACHING"] = True

        self.btctxstore = BtcTxStore()

        db.create_all()
コード例 #16
0
ファイル: test_Farmer.py プロジェクト: jorgebonilla/dataserv
        def callback():
            blockchain = BtcTxStore()
            wif = blockchain.create_key()
            address = blockchain.get_address(wif)
            farmer = Farmer(address)

            header_date = formatdate(timeval=mktime(datetime.now().timetuple()),
                                     localtime=True, usegmt=True)
            header_authorization = blockchain.sign_unicode(wif, "lalala-wrong")
            farmer.authenticate(header_authorization, header_date)
コード例 #17
0
ファイル: test_Farmer.py プロジェクト: F483/dataserv
    def test_authentication_success(self):
        blockchain = BtcTxStore()
        wif = blockchain.create_key()
        address = blockchain.get_address(wif)
        farmer = Farmer(address)

        header_date = formatdate(timeval=mktime(datetime.now().timetuple()),
                                 localtime=True, usegmt=True)
        message = farmer.get_server_address() + " " + header_date
        header_authorization = blockchain.sign_unicode(wif, message)
        self.assertTrue(farmer.authenticate(header_authorization, header_date))
コード例 #18
0
    def __init__(self, net, wif=None, store_config=None, handlers=None):
        # Accept direct connections.
        self.net = net

        # Returned by callbacks.
        self.success_value = ("127.0.0.1", 7777)

        # Used for signing messages.
        self.wallet = BtcTxStore(testnet=False, dryrun=True)
        self.wif = wif or self.wallet.create_key()

        # Where will the data be stored?
        self.store_config = store_config
        assert(len(list(store_config)))

        # Handlers for certain events.
        self.handlers = handlers
        if self.handlers is None:
            self.handlers = {}
        if "complete" not in self.handlers:
            self.handlers["complete"] = []
        if "accept" not in self.handlers:
            self.handlers["accept"] = []

        # Start networking.
        if not self.net.is_net_started:
            self.net.start()

        # Dict of data requests: [contract_id] > contract
        self.contracts = {}

        # List of Sock objects returned from UNL.connect.
        self.cons = []

        # Dict of defers for contracts: [contract_id] > defer
        self.defers = {}

        # Three-way handshake status for contracts: [contract_id] > state
        self.handshake = {}

        # All contracts associated with this connection.
        # [con] > [contract_id] > con_info
        self.con_info = {}

        # File transfer currently active on connection.
        # [con] > contract_id
        self.con_transfer = {}

        # List of active downloads.
        # (Never try to download multiple copies of the same thing at once.)
        self.downloading = {}

        # Lock threads.
        self.mutex = Lock()
コード例 #19
0
ファイル: test_Farmer.py プロジェクト: F483/dataserv
    def test_authentication_success(self):
        blockchain = BtcTxStore()
        wif = blockchain.create_key()
        address = blockchain.get_address(wif)
        farmer = Farmer(address)

        header_date = formatdate(timeval=mktime(datetime.now().timetuple()),
                                 localtime=True,
                                 usegmt=True)
        message = farmer.get_server_address() + " " + header_date
        header_authorization = blockchain.sign_unicode(wif, message)
        self.assertTrue(farmer.authenticate(header_authorization, header_date))
コード例 #20
0
ファイル: test_Farmer.py プロジェクト: StorjOld/dataserv
        def callback():
            blockchain = BtcTxStore()
            wif = blockchain.create_key()
            address = blockchain.get_address(wif)
            farmer = Farmer(address)

            header_date = formatdate(timeval=mktime(datetime.now().timetuple())
                                     , localtime=True, usegmt=True)
            message = farmer.get_server_address() + " " + header_date
            header_authorization = blockchain.sign_unicode(wif, message)
            headers = {"Date": None, "Authorization": header_authorization}
            farmer.authenticate(headers)
コード例 #21
0
    def __init__(self,
                 url=common.DEFAULT_URL,
                 debug=False,
                 quiet=False,
                 use_folder_tree=False,
                 max_size=common.DEFAULT_MAX_SIZE,
                 min_free_size=common.DEFAULT_MIN_FREE_SIZE,
                 store_path=common.DEFAULT_STORE_PATH,
                 config_path=common.DEFAULT_CONFIG_PATH,
                 connection_retry_limit=common.DEFAULT_CONNECTION_RETRY_LIMIT,
                 connection_retry_delay=common.DEFAULT_CONNECTION_RETRY_DELAY,
                 nop2p=True):

        debug = deserialize.flag(debug)
        quiet = deserialize.flag(quiet)

        self.storjnode = None
        self.nop2p = nop2p
        self.url = deserialize.url(url)
        self.use_folder_tree = deserialize.flag(use_folder_tree)
        self.max_size = deserialize.byte_count(max_size)
        self.min_free_size = deserialize.byte_count(min_free_size)

        self.messenger = None  # lazy
        self.btctxstore = BtcTxStore()
        self.retry_limit = deserialize.positive_integer(connection_retry_limit)
        self.retry_delay = deserialize.positive_integer(connection_retry_delay)

        # paths
        self.cfg_path = os.path.realpath(config_path)
        storjnode.util.ensure_path_exists(os.path.dirname(self.cfg_path))
        self.store_path = os.path.realpath(store_path)
        storjnode.util.ensure_path_exists(self.store_path)

        # check for vfat partions
        try:
            fstype = storjnode.util.get_fs_type(self.store_path)

        # FileNotFoundError: [Errno 2] No such file or directory: '/etc/mtab'
        # psutil: https://code.google.com/p/psutil/issues/detail?id=434
        except EnvironmentError as e:
            logger.warning(e)
            fstype = None

        if fstype == "vfat":
            logger.info("Detected vfat partition, using folder tree.")
            self.use_folder_tree = True
        if fstype is None:
            msg = "Couldn't detected partition type for '{0}'"
            logger.warning(msg.format(self.store_path))

        self.cfg = storjnode.config.get(self.btctxstore, self.cfg_path)
コード例 #22
0
class TestSignTx(unittest.TestCase):
    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_sign_tx(self):
        txins = fixtures["sign_tx"]["txins"]
        txouts = fixtures["sign_tx"]["txouts"]
        wifs = fixtures["sign_tx"]["wifs"]
        expected = fixtures["sign_tx"]["expected"]
        rawtx = self.api.create_tx(txins, txouts)
        rawtx = self.api.add_nulldata(rawtx, "f483")
        result = self.api.sign_tx(rawtx, wifs)
        self.assertEqual(result, expected)
コード例 #23
0
class TestConfirms(unittest.TestCase):
    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=False)

    def test_confirmed(self):
        confirms = self.api.confirms(CONFIRMED)
        self.assertGreater(confirms, 0)

    def test_unconfirmed(self):
        pass  # TODO find always unconfirmed tx and test

    def test_unpublished(self):
        confirms = self.api.confirms(UNPUBLISHED)
        self.assertIsNone(confirms)
コード例 #24
0
ファイル: test_Farmer.py プロジェクト: F483/dataserv
        def callback():
            blockchain = BtcTxStore()
            wif = blockchain.create_key()
            address = blockchain.get_address(wif)
            farmer = Farmer(address)

            timeout = farmer.get_server_authentication_timeout()

            date = datetime.now() - timedelta(seconds=timeout)
            header_date = formatdate(timeval=mktime(date.timetuple()),
                                     localtime=True, usegmt=True)
            message = farmer.get_server_address() + " " + header_date
            header_authorization = blockchain.sign_unicode(wif, message)
            farmer.authenticate(header_authorization, header_date)
コード例 #25
0
        def callback():
            blockchain = BtcTxStore()
            wif = blockchain.create_key()
            address = blockchain.get_address(wif)
            farmer = Farmer(address)

            header_date = formatdate(timeval=mktime(
                datetime.now().timetuple()),
                                     localtime=True,
                                     usegmt=True)
            message = farmer.get_server_address() + " " + header_date
            header_authorization = blockchain.sign_unicode(wif, message)
            headers = {"Date": None, "Authorization": header_authorization}
            farmer.authenticate(headers)
コード例 #26
0
ファイル: api.py プロジェクト: NinjaDevelper/btctxstore
class TestSignTx(unittest.TestCase):

    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_signtx(self):
        txins = fixtures["signtx"]["txins"]
        txouts = fixtures["signtx"]["txouts"]
        wifs = fixtures["signtx"]["wifs"]
        expected = fixtures["signtx"]["expected"]
        rawtx = self.api.createtx(txins, txouts)
        rawtx = self.api.addnulldata(rawtx, "f483")
        result = self.api.signtx(rawtx, wifs)
        self.assertEqual(result, expected)
コード例 #27
0
ファイル: test_Farmer.py プロジェクト: F483/dataserv
        def callback():
            blockchain = BtcTxStore()
            wif = blockchain.create_key()
            address = blockchain.get_address(wif)
            farmer = Farmer(address)

            timeout = farmer.get_server_authentication_timeout()

            date = datetime.now() - timedelta(seconds=timeout)
            header_date = formatdate(timeval=mktime(date.timetuple()),
                                     localtime=True,
                                     usegmt=True)
            message = farmer.get_server_address() + " " + header_date
            header_authorization = blockchain.sign_unicode(wif, message)
            farmer.authenticate(header_authorization, header_date)
コード例 #28
0
class TestSplitUtxos(unittest.TestCase):
    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_singleinput(self):
        wif = "cNHPbjVpkv4oqqKimBNp1UfQ2dhjETtRZw4KkHWtPgnU36SBtXub"
        # address n4RHA7mxH8EYV7wMS8evtYRYwCpQYz6KuE
        txids = self.api.split_utxos(wif, 10000000)  # 100mBTC
        self.assertEqual(len(txids), 1)

    def test_manyinputs(self):
        wif = "cRoboMG5KM19VP8ZcVCDXGCfi1JJraKpw58ofe8v57j7vqDxaQ5m"
        # address mqox6abLAiado9kFvX3EsHaVFbYVimSMCK
        txids = self.api.split_utxos(wif, 100000)  # 1mBTC
        self.assertEqual(len(txids), 6)
コード例 #29
0
class TestRetrieve(unittest.TestCase):
    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_retrieve(self):
        txid = fixtures["retrieve"]["nulldata_txid"]
        result = self.api.retrieve_nulldata(txid)
        self.assertEqual(result, "f483")

    def test_retrieve_nothing(self):
        def callback():
            txid = fixtures["retrieve"]["nonulldata_txid"]
            result = self.api.retrieve_nulldata(txid)

        self.assertRaises(exceptions.NoNulldataOutput, callback)
コード例 #30
0
ファイル: confirms.py プロジェクト: F483/btctxstore
class TestConfirms(unittest.TestCase):

    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=False)

    def test_confirmed(self):
        confirms = self.api.confirms(CONFIRMED)
        self.assertGreater(confirms, 0)

    def test_unconfirmed(self):
        pass  # TODO find always unconfirmed tx and test

    def test_unpublished(self):
        confirms = self.api.confirms(UNPUBLISHED)
        self.assertIsNone(confirms)
コード例 #31
0
ファイル: test_Farmer.py プロジェクト: StorjOld/dataserv
    def test_authentication_timeout_future_success(self):
        blockchain = BtcTxStore()
        wif = blockchain.create_key()
        address = blockchain.get_address(wif)
        farmer = Farmer(address)

        timeout = farmer.get_server_authentication_timeout() - 5

        date = datetime.now() + timedelta(seconds=timeout)
        header_date = formatdate(timeval=mktime(date.timetuple()),
                                 localtime=True, usegmt=True)
        message = farmer.get_server_address() + " " + header_date
        header_authorization = blockchain.sign_unicode(wif, message)
        headers = {"Date": header_date, "Authorization": header_authorization}
        self.assertTrue(farmer.authenticate(headers))
コード例 #32
0
ファイル: api.py プロジェクト: NinjaDevelper/btctxstore
class TestRetrieve(unittest.TestCase):

    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_retrieve(self):
        txid = fixtures["retrieve"]["nulldata_txid"]
        result = self.api.retrievenulldata(txid)
        self.assertEqual(result, "f483")

    def test_retrieve_nothing(self):
        def callback():
            txid = fixtures["retrieve"]["nonulldata_txid"]
            result = self.api.retrievenulldata(txid)
        self.assertRaises(exceptions.NoNulldataOutput, callback)
コード例 #33
0
    def __init__(self, net, bandwidth, wif=None,
                 store_config=None, handlers=None):
        # Accept direct connections.
        self.net = net

        # Control bandwidth.
        self.bandwidth = bandwidth

        # Returned by callbacks.
        self.success_value = ("127.0.0.1", 7777)

        # Used for signing messages.
        self.wallet = BtcTxStore(testnet=False, dryrun=True)
        self.wif = wif or self.wallet.create_key()

        # Where will the data be stored?
        self.store_config = store_config
        assert(len(list(store_config)))

        # Handlers for certain events.
        self.handlers = handlers
        if self.handlers is None:
            self.handlers = {}
        if "complete" not in self.handlers:
            self.handlers["complete"] = set()
        if "accept" not in self.handlers:
            self.handlers["accept"] = set()
        if "start" not in self.handlers:
            self.handlers["start"] = set()

        # Start networking.
        if not self.net.is_net_started:
            self.net.start()

        # Dict of data requests: [contract_id] > contract
        self.contracts = {}

        # List of Sock objects returned from UNL.connect.
        self.cons = []

        # Dict of defers for contracts: [contract_id] > defer
        self.defers = {}

        # Three-way handshake status for contracts: [contract_id] > state
        self.handshake = {}

        # All contracts associated with this connection.
        # [con] > [contract_id] > con_info
        self.con_info = {}

        # File transfer currently active on connection.
        # [con] > contract_id
        self.con_transfer = {}

        # List of active downloads.
        # (Never try to download multiple copies of the same thing at once.)
        self.downloading = {}

        # Lock threads.
        self.mutex = Lock()
コード例 #34
0
    def _setup_data_transfer_client(self, store_config, passive_port,
                                    passive_bind, node_type, nat_type, wan_ip):
        # Setup handlers for callbacks registered via the API.
        handlers = {
            "complete": self._transfer_complete_handlers,
            "request": self._transfer_request_handlers
        }

        self._data_transfer = FileTransfer(
            net=Net(
                net_type="direct",
                node_type=node_type,
                nat_type=nat_type,
                dht_node=SimDHT(),  # Replace with self.server later on.
                debug=1,
                passive_port=passive_port,
                passive_bind=passive_bind,
                wan_ip=wan_ip
            ),
            # FIXME use same key as dht
            wif=BtcTxStore(testnet=True, dryrun=True).create_key(),
            store_config=store_config,
            handlers=handlers
        )

        # Setup success callback values.
        self._data_transfer.success_value = (self.sync_get_wan_ip(), self.port)
        self.process_data_transfers()
コード例 #35
0
ファイル: test_App.py プロジェクト: StorjOld/dataserv
    def test_success(self):

        # create header date and authorization signature
        blockchain = BtcTxStore()
        wif = blockchain.create_key()
        address = blockchain.get_address(wif)
        header_date = formatdate(timeval=mktime(datetime.now().timetuple()),
                                 localtime=True, usegmt=True)
        message = app.config["ADDRESS"] + " " + header_date
        header_authorization = blockchain.sign_unicode(wif, message)
        headers = {"Date": header_date, "Authorization": header_authorization}
        url = '/api/register/{0}'.format(address)
        rv = self.app.get(url, headers=headers)
        data = json.loads(rv.data.decode("utf-8"))
        self.assertEqual(address, data["btc_addr"])
        self.assertEqual(rv.status_code, 200)
コード例 #36
0
    def test_authentication_timeout_future_success(self):
        blockchain = BtcTxStore()
        wif = blockchain.create_key()
        address = blockchain.get_address(wif)
        farmer = Farmer(address)

        timeout = farmer.get_server_authentication_timeout() - 5

        date = datetime.now() + timedelta(seconds=timeout)
        header_date = formatdate(timeval=mktime(date.timetuple()),
                                 localtime=True,
                                 usegmt=True)
        message = farmer.get_server_address() + " " + header_date
        header_authorization = blockchain.sign_unicode(wif, message)
        headers = {"Date": header_date, "Authorization": header_authorization}
        self.assertTrue(farmer.authenticate(headers))
コード例 #37
0
ファイル: other.py プロジェクト: F483/btctxstore
class TestSplitUtxos(unittest.TestCase):

    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_singleinput(self):
        wif = "cNHPbjVpkv4oqqKimBNp1UfQ2dhjETtRZw4KkHWtPgnU36SBtXub"
        # address n4RHA7mxH8EYV7wMS8evtYRYwCpQYz6KuE
        txids = self.api.split_utxos(wif, 10000000)  # 100mBTC
        self.assertEqual(len(txids), 1)

    def test_manyinputs(self):
        wif = "cRoboMG5KM19VP8ZcVCDXGCfi1JJraKpw58ofe8v57j7vqDxaQ5m"
        # address mqox6abLAiado9kFvX3EsHaVFbYVimSMCK
        txids = self.api.split_utxos(wif, 100000)  # 1mBTC
        self.assertEqual(len(txids), 6)
コード例 #38
0
ファイル: api.py プロジェクト: pombredanne/dataserv-client
    def __init__(self, url=common.DEFAULT_URL, debug=False, quiet=False,
                 use_folder_tree=False, max_size=common.DEFAULT_MAX_SIZE,
                 store_path=common.DEFAULT_STORE_PATH,
                 config_path=common.DEFAULT_CONFIG_PATH,
                 connection_retry_limit=common.DEFAULT_CONNECTION_RETRY_LIMIT,
                 connection_retry_delay=common.DEFAULT_CONNECTION_RETRY_DELAY):

        debug = deserialize.flag(debug)
        quiet = deserialize.flag(quiet)

        self.url = deserialize.url(url)
        self.use_folder_tree = deserialize.flag(use_folder_tree)
        self.max_size = deserialize.byte_count(max_size)

        self.messenger = None  # lazy
        self.btctxstore = BtcTxStore()
        self.retry_limit = deserialize.positive_integer(connection_retry_limit)
        self.retry_delay = deserialize.positive_integer(connection_retry_delay)

        # paths
        self.cfg_path = os.path.realpath(config_path)
        control.util.ensure_path_exists(os.path.dirname(self.cfg_path))
        self.store_path = os.path.realpath(store_path)
        control.util.ensure_path_exists(self.store_path)

        # check for vfat partions
        if control.util.get_fs_type(self.store_path) == "vfat":
            self.use_folder_tree = True

        self.cfg = control.config.get(self.btctxstore, self.cfg_path)
コード例 #39
0
class TestGetTransactions(unittest.TestCase):
    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_used(self):
        address = "2MwYLBKhvqezurTWsyzFRbA3BG2fYLmTTDK"
        transactions = self.api.get_transactions(address)
        self.assertEqual(transactions, [
            "5599b00529a82dd5957be87681fb9da07ef54665ca8621f636a2a6ccd949a8c6",
            "64754ea8ab2b42cedb95a1548d83e166b03c350fe21044be411b07a36ec66ebd"
        ])

    def test_unused(self):
        address = "mwacg9L7raork91AP6wiZpA291bATguX47"
        transactions = self.api.get_transactions(address)
        self.assertEqual(transactions, [])
コード例 #40
0
ファイル: api.py プロジェクト: NinjaDevelper/btctxstore
class TestCreateKey(unittest.TestCase):

    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_createkey(self):
        wif = self.api.createkey()
        self.assertTrue(validate.is_wif_valid(wif, allowable_netcodes=['XTN']))
コード例 #41
0
ファイル: test_App.py プロジェクト: pombredanne/dataserv
    def test_success(self):

        # create header date and authorization signature
        blockchain = BtcTxStore()
        wif = blockchain.create_key()
        address = blockchain.get_address(wif)
        header_date = formatdate(timeval=mktime(datetime.now().timetuple()),
                                 localtime=True,
                                 usegmt=True)
        message = app.config["ADDRESS"] + " " + header_date
        header_authorization = blockchain.sign_unicode(wif, message)
        headers = {"Date": header_date, "Authorization": header_authorization}
        url = '/api/register/{0}'.format(address)
        rv = self.app.get(url, headers=headers)
        data = json.loads(rv.data.decode("utf-8"))
        self.assertEqual(address, data["btc_addr"])
        self.assertEqual(rv.status_code, 200)
コード例 #42
0
ファイル: get_transactions.py プロジェクト: F483/btctxstore
class TestGetTransactions(unittest.TestCase):

    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_used(self):
        address = "2MwYLBKhvqezurTWsyzFRbA3BG2fYLmTTDK"
        transactions = self.api.get_transactions(address)
        self.assertEqual(transactions, [
            "5599b00529a82dd5957be87681fb9da07ef54665ca8621f636a2a6ccd949a8c6",
            "64754ea8ab2b42cedb95a1548d83e166b03c350fe21044be411b07a36ec66ebd"
        ])

    def test_unused(self):
        address = "mwacg9L7raork91AP6wiZpA291bATguX47"
        transactions = self.api.get_transactions(address)
        self.assertEqual(transactions, [])
コード例 #43
0
class TestGetUtxos(unittest.TestCase):
    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_getutxos(self):
        address = fixtures["wallet"]["address"]
        expected = fixtures["getutxos"]["expected"]
        result = self.api.retrieve_utxos([address])
        self.assertEqual(result, expected)
コード例 #44
0
ファイル: test_App.py プロジェクト: littleskunk/dataserv
    def setUp(self):
        app.config["SKIP_AUTHENTICATION"] = True  # monkey patch
        app.config["DISABLE_CACHING"] = True

        self.btctxstore = BtcTxStore()
        self.bad_addr = 'notvalidaddress'

        self.app = app.test_client()
        db.create_all()
コード例 #45
0
ファイル: api.py プロジェクト: NinjaDevelper/btctxstore
class TestGetAddress(unittest.TestCase):

    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_getaddress(self):
        wif = fixtures["wallet"]["wif"]
        result = self.api.getaddress(wif)
        expected = fixtures["wallet"]["address"]
        self.assertEqual(result, expected)
コード例 #46
0
ファイル: api.py プロジェクト: NinjaDevelper/btctxstore
class TestGetUtxos(unittest.TestCase):

    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_getutxos(self):
        address = fixtures["wallet"]["address"]
        expected = fixtures["getutxos"]["expected"]
        result = self.api.retrieveutxos([address])
        self.assertEqual(result, expected)
コード例 #47
0
ファイル: test_auth.py プロジェクト: cloud-school/storjcore
class TestAuth(unittest.TestCase):

    def setUp(self):
        self.btctxstore = BtcTxStore()
        self.sender_wif = self.btctxstore.create_key()
        self.sender = self.btctxstore.get_address(self.sender_wif)
        recipient_wif = self.btctxstore.create_key()
        self.recipient = self.btctxstore.get_address(recipient_wif)

    def test_self_validates(self):
        headers = storjcore.auth.create_headers(self.btctxstore,
                                                self.recipient,
                                                self.sender_wif)

        self.assertTrue(storjcore.auth.verify_headers(self.btctxstore,
                                                      headers,
                                                      5, self.sender,
                                                      self.recipient))

    def test_invalid_signature(self):
        def callback():
            headers = storjcore.auth.create_headers(self.btctxstore,
                                                    self.recipient,
                                                    self.sender_wif)
            headers["Authorization"] = base64.b64encode(65 * b"x")
            storjcore.auth.verify_headers(self.btctxstore, headers,
                                          5, self.sender, self.recipient)
        self.assertRaises(storjcore.auth.AuthError, callback)

    def test_timeout_to_old(self):
        def callback():
            headers = storjcore.auth.create_headers(self.btctxstore,
                                                    self.recipient,
                                                    self.sender_wif)
            time.sleep(5)
            storjcore.auth.verify_headers(self.btctxstore, headers,
                                          5, self.sender, self.recipient)
        self.assertRaises(storjcore.auth.AuthError, callback)

    @unittest.skip("TODO implement")
    def test_timeout_to_young(self):
        pass  # FIXME how to test this?
コード例 #48
0
class TestCreateTx(unittest.TestCase):
    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_create_tx(self):
        lock_time = 0
        txins = fixtures["create_tx"]["txins"]
        txouts = fixtures["create_tx"]["txouts"]
        expected = fixtures["create_tx"]["expected"]
        result = self.api.create_tx(txins, txouts, lock_time)
        self.assertEqual(result, expected)
コード例 #49
0
ファイル: api.py プロジェクト: thontron/picopayments-hub
def mph_status(assets=None):
    with etc.database_lock:
        verify.status_input(assets)
        btctxstore = BtcTxStore(testnet=etc.testnet)
        wif = lib.load_wif()
        address = btctxstore.get_address(wif)
        message = util.b2h(os.urandom(32))
        signature = btctxstore.sign_unicode(wif, message)
        if isinstance(signature, bytes):  # XXX update btctxstore instead !!!
            signature = signature.decode("utf-8")
        return {
            "funds": {
                "address": address,
                "message": message,
                "signature": signature,
                "liquidity": lib.get_hub_liquidity(assets=assets),
            },
            "current_terms": lib.get_terms(assets=assets),
            "connections": lib.get_connections_status(assets=assets)
        }
コード例 #50
0
ファイル: control.py プロジェクト: super3/picopayments
    def __init__(self,
                 asset,
                 user=DEFAULT_COUNTERPARTY_RPC_USER,
                 password=DEFAULT_COUNTERPARTY_RPC_PASSWORD,
                 api_url=None,
                 testnet=DEFAULT_TESTNET,
                 dryrun=False,
                 fee=DEFAULT_TXFEE,
                 dust_size=DEFAULT_DUSTSIZE):
        """Initialize payment channel controler.

        Args:
            asset (str): Counterparty asset name.
            user (str): Counterparty API username.
            password (str): Counterparty API password.
            api_url (str): Counterparty API url.
            testnet (bool): True if running on testnet, otherwise mainnet.
            dryrun (bool): If True nothing will be published to the blockchain.
            fee (int): The transaction fee to use.
            dust_size (int): The default dust size for counterparty outputs.
        """

        if testnet:
            default_url = DEFAULT_COUNTERPARTY_RPC_TESTNET_URL
        else:
            default_url = DEFAULT_COUNTERPARTY_RPC_MAINNET_URL

        self.dryrun = dryrun
        self.fee = fee
        self.dust_size = dust_size
        self.api_url = api_url or default_url
        self.testnet = testnet
        self.user = user
        self.password = password
        self.asset = asset
        self.netcode = "BTC" if not self.testnet else "XTN"
        self.btctxstore = BtcTxStore(testnet=self.testnet,
                                     dryrun=dryrun,
                                     service="insight")
        self.bitcoind_rpc = AuthServiceProxy(  # XXX to publish
            "http://*****:*****@127.0.0.1:18332")
コード例 #51
0
ファイル: api.py プロジェクト: NinjaDevelper/btctxstore
class TestCreateTx(unittest.TestCase):

    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_createtx(self):
        locktime = 0
        txins = fixtures["createtx"]["txins"]
        txouts = fixtures["createtx"]["txouts"]
        expected = fixtures["createtx"]["expected"]
        result = self.api.createtx(txins, txouts, locktime)
        self.assertEqual(result, expected)
コード例 #52
0
class TestGetAddress(unittest.TestCase):
    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_standard(self):
        wif = self.api.create_key()
        address = self.api.get_address(wif)
        self.assertTrue(
            validate.is_address_valid(address, allowable_netcodes=['XTN']))

    def test_input_validation(self):

        # test correct types
        a = self.api.get_address(S_WIF)
        b = self.api.get_address(B_WIF)
        c = self.api.get_address(U_WIF)
        self.assertEqual(a, b, c)

        # TODO invalid types
        # TODO invalid input data

    def test_standards_compliant(self):
        wif = self.api.create_key()
        address = self.api.get_address(S_WIF)
        self.assertEqual(address, EXPECTED)
コード例 #53
0
ファイル: get_address.py プロジェクト: F483/btctxstore
class TestGetAddress(unittest.TestCase):

    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_standard(self):
        wif = self.api.create_key()
        address = self.api.get_address(wif)
        self.assertTrue(validate.is_address_valid(address, allowable_netcodes=['XTN']))

    def test_input_validation(self):

        # test correct types
        a = self.api.get_address(S_WIF)
        b = self.api.get_address(B_WIF)
        c = self.api.get_address(U_WIF)
        self.assertEqual(a, b, c)

        # TODO invalid types
        # TODO invalid input data

    def test_standards_compliant(self):
        wif = self.api.create_key()
        address = self.api.get_address(S_WIF)
        self.assertEqual(address, EXPECTED)
コード例 #54
0
    def generate_block(self):
        """Close the current block, and generate a new one."""

        try:
            last_block = latest_block(self.conn)
            last_hash = latest_hash(self.conn)

            # Get Merkle Root
            self.find_leaves()
            self.close()
            merkle_root = self.merkle_root()

            # Get TXID
            hexdata = merkle_root
            privatekeys = app.config["PRIVATE_KEYS"]
            changeaddress = app.config["CHANGE_ADDRESS"]
            fee = app.config["FEE"]
            testnet = app.config["TESTNET"]
            blockchain = BtcTxStore(testnet=testnet)
            tx_id = blockchain.storenulldata(hexdata,
                                             privatekeys,
                                             changeaddress=changeaddress,
                                             fee=fee)

            # Close current block
            c = self.conn.cursor()
            query1 = "UPDATE block_table SET end_hash=?, closed=?, merkle_root=?, tx_id=? WHERE id=?"
            c.execute(query1,
                      (last_hash, True, merkle_root, tx_id, last_block))

            # Start new block
            query2 = "INSERT INTO block_table (start_hash) VALUES (?)"
            c.execute(query2, (last_hash, ))

            self.conn.commit()
            self.conn.close()
            return 'Block {0} Built.'.format(last_block)
        except LookupError:
            return 'Block Empty.'
コード例 #55
0
class TestGetWalletKey(unittest.TestCase):
    def setUp(self):
        self.api = BtcTxStore(dryrun=True, testnet=True)

    def test_standard(self):
        hwif = self.api.create_wallet()
        wif = self.api.get_key(hwif)
        self.assertTrue(validate.is_wif_valid(wif, allowable_netcodes=['XTN']))

    def test_input_validation(self):

        # test correct types
        a = self.api.get_key(S_HWIF)
        b = self.api.get_key(B_HWIF)
        c = self.api.get_key(U_HWIF)
        self.assertEqual(a, b, c)

        # TODO invalid types
        # TODO invalid input data

    def test_standards_compliant(self):
        pass  # FIXME check generated against expected output from 3rd parties
コード例 #56
0
def send_to_bitcoin(wif,
                    change_address,
                    payload: bytes,
                    is_testnet=True,
                    is_dryrun=True,
                    fee=10000):
    if is_dryrun:
        print("*** DRY RUN ***")
    else:
        print("*** LIVE ***")
    if is_testnet:
        print("*** TEST NET ***")
    else:
        print("*** MAIN NET ***")

    api = BtcTxStore(testnet=is_testnet, dryrun=is_dryrun)
    data = hexlify(payload)
    transaction_id = api.store_nulldata(hexdata=data,
                                        wifs=[wif],
                                        change_address=change_address,
                                        fee=fee)
    return transaction_id