def request_block_mine(): data = request.get_json() if data: miner = data.get("miner_transaction") user = data.get("user_transaction") miner_block = Block(block_type=miner.get('block_type'), account=miner.get('account'), representative=miner.get('representative'), previous=miner.get('previous'), link_as_account=miner_account, balance=miner.get('balance')) miner_block_hash = miner_block.work_block_hash if check_balance(miner.get('account'), miner.get('balance')): miner_block.solve_work() miner_block_json = json.loads(miner_block.json()) miner_block_new_json = { "account": miner_block_json.get("account"), "balance": miner_block_json.get("balance"), "link": miner_block_json.get("link"), "link_as_account": miner_block_json.get("link_as_account"), "previous": miner_block_json.get("previous"), "representative": miner_block_json.get("representative"), "type": miner_block_json.get("type"), "signature": miner.get("signature") } requests.post(url, json={ "action": "process", "block": miner_block_new_json }) user_transaction = mine_block(user.get('block_type'), user.get('account'), user.get('representative'), miner_block_hash, user.get('link_as_account'), user.get('balance')) user_transaction_json = json.loads(user_transaction.json()) user_transaction_new_json = { "account": user_transaction_json.get("account"), "balance": user_transaction_json.get("balance"), "link": user_transaction_json.get("link"), "link_as_account": user_transaction_json.get("link_as_account"), "previous": user_transaction_json.get("previous"), "representative": user_transaction_json.get("representative"), "type": user_transaction_json.get("type"), "signature": user.get("signature") } r = requests.post(url, json={ "action": "process", "block": user_transaction_new_json }) return jsonify(r.text) abort(401)
def mine_block(block_type, account, representative, previous, link_as_account, balance): block = Block( block_type=block_type, account=account, representative=representative, previous=previous, link_as_account=link_as_account, balance=balance ) block.solve_work() return block.json()
def block_create(block_type, account, representative, previous, link_as_account, balance, signature): try: block = Block( block_type=block_type, account=account, representative=representative, previous=previous, link_as_account=link_as_account, balance=balance, ) except: return "invalid" else: if signature is not None: try: block.signature = signature except: return "invalid" return block
def receive(account, private_key, representative, amount, link): request = requests.post(worker["node"], json={ "action": "accounts_frontiers", "accounts": [account] }) previous = frontier(account) if previous == "0000000000000000000000000000000000000000000000000000000000000000": request = requests.post(worker["node"], json={ "action": "account_key", "account": account }) workHash = request.json()["key"] else: workHash = previous block = Block(block_type="state", account=account, representative=representative, previous=previous, balance=balance(worker["account"]) + amount, link=link) solveWork = solve_work(workHash, worker["difficulty_receive"]) if "error" in solveWork: return {"error": solveWork["error"]} block.work = solveWork["work"] block.sign(private_key) r = broadcast(block.json()) return r
def create_block(prev_block, private_key, amount): account_id = get_account_id(private_key=private_key) link_block = legacy_pocketable_block_factory( account_id=account_id, amount=amount) raw_block = RawBlock( account=account_id, block_type="receive", previous=prev_block.block_hash, source=link_block.block_hash) raw_block.sign(private_key) raw_block.solve_work(difficulty=TEST_DIFFICULTY) block = Block( block_data=raw_block.to_dict(), link_block=link_block, ) return block
def receive(account, private_key, representative, amount, link, difficulty): request = requests.post(node, json={ "action": "accounts_frontiers", "accounts": [account] }) if account in request.json()["frontiers"]: previous = request.json()["frontiers"][account] else: previous = "0000000000000000000000000000000000000000000000000000000000000000" block = Block(block_type="state", account=account, representative=representative, previous=previous, balance=balance(worker_account) + amount, link=link) block.work = solve_work(frontier(account), difficulty) block.sign(private_key) r = broadcast(block.json()) return r
def create_link_block(account_id, amount): sending_private_key = generate_seed() sending_account_id = get_account_id(private_key=sending_private_key) block = RawBlock( block_type="send", account=sending_account_id, previous=generate_seed().upper(), destination=account_id, balance=amount + random.randint(-amount, 2**110) ) block.sign(sending_private_key) block.solve_work(difficulty=TEST_DIFFICULTY) link_block = LinkBlock( block_data=block.to_dict(), amount=amount, timestamp=Timestamp( date=time.time(), source=TimestampSource.WALLET ) ) return link_block
def set_block_data(self, block_data): if not block_data: raise ValueError("Property is required") self._block = RawBlock.from_dict(block_data, verify=False)
def create_mock_process(self, data): block_data = data["block"] wallet = wallet_from_str(self.shared.wallet) block = RawBlock.from_json(block_data) if not block.signature: logger.info( "[MOCK] Trying to process unsigned block {}".format( block.block_hash ) ) return None if not block.work: logger.info( "[MOCK] Trying to process block with no work {}".format( block.block_hash ) ) return None account = wallet.account_map[block.account] mock_block = account.block_map[block.block_hash] if mock_block.confirmed: logger.info( "[MOCK] Trying to process confirmed block {}".format( block.block_hash ) ) return None logger.info( "[MOCK] Confirming block {}".format(block.block_hash) ) if self.shared.broadcast_fail_counter is not None: if self.shared.broadcast_fail_counter == 0: return { "error": "Gap source block" } else: self.shared.broadcast_fail_counter -= 1 if self.shared.difficulty_raise_counter is not None: if self.shared.difficulty_raise_counter == 0: self.shared.difficulty_raise_counter = None self.shared.work_difficulty = derive_work_difficulty( multiplier=1.15, base_difficulty=self.shared.work_difficulty ) return { "error": "Block work is less than threshold" } else: self.shared.difficulty_raise_counter -= 1 mock_block.confirmed = True self.shared.block_arrival_time[block.block_hash] = time.time() self.shared.wallet = wallet_to_str(wallet) return { "hash": block.block_hash }