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
}