def from_bytes(cls, bytes_frontier: bytes):
front_dict = decode_raw(bytes_frontier)
return cls(
front_dict.get(b"t"),
front_dict.get(b"h"),
front_dict.get(b"i"),
)
def process_spend(self, spend_block: BamiBlock) -> None:
# Store spend in the database
spend_tx = decode_raw(spend_block.transaction)
spender = spend_block.public_key
self.verify_spend(spender, spend_tx)
chain_id = spend_block.com_id
spend_dot = spend_block.com_dot
pers_links = spend_block.links
prev_spend_links = spend_tx.get(b"prev_pairwise_link")
value = Decimal(spend_tx.get(b"value"), self.context)
to_peer = spend_tx.get(b"to_peer")
seq_num = spend_dot[0]
self.state_db.apply_spend(
chain_id,
prev_spend_links,
pers_links,
spend_dot,
spender,
to_peer,
value,
self.should_store_store_update(chain_id, seq_num),
)
# Is this block related to my peer?
if to_peer == self.my_pub_key_bin:
self.add_block_to_response_processing(spend_block)
def test_decimal():
new_con = getcontext()
new_con.prec = 4
t = Decimal(2.191, new_con)
t2 = Decimal(2.11, new_con)
l = encode_raw({b"value": float(t2)})
p = decode_raw(l)
assert p.get(b"value") == float(t2)
def test_val(self):
val = Decimal(10, self.con)
l = encode_raw({b"123": float(val)})
d = decode_raw(l)
print(d)
l = cachetools.LRUCache(10)
l[1] = "v"
int_max = 9999
k = 4
try:
v = min(l.keys(), key=lambda x: abs(x - k) if x >= k else int_max)
if v < k:
# No data yet:
pass
except ValueError:
print("No data for the chain")
def process_mint(self, mint_blk: BamiBlock) -> None:
"""Process received mint transaction"""
minter = mint_blk.public_key
mint_tx = decode_raw(mint_blk.transaction)
chain_id = mint_blk.com_id
mint_dot = mint_blk.com_dot
prev_links = mint_blk.links
self.verify_mint(chain_id, minter, mint_tx)
seq_num = mint_dot[0]
self.state_db.apply_mint(
chain_id,
mint_dot,
prev_links,
minter,
Decimal(mint_tx.get(b"value"), self.context),
self.should_store_store_update(chain_id, seq_num),
)
def process_counter_signing_block(
self, block: BamiBlock, time_passed: float = None, num_block_passed: int = None,
) -> bool:
"""
Process block that should be counter-signed and return True if the block should be delayed more.
Args:
block: Processed block
time_passed: time passed since first added
num_block_passed: number of blocks passed since first added
Returns:
Should add to queue again.
"""
res = self.block_response(block, time_passed, num_block_passed)
if res == BlockResponse.CONFIRM:
self.confirm(
block,
extra_data={b"value": decode_raw(block.transaction).get(b"value")},
)
return False
elif res == BlockResponse.REJECT:
self.reject(block)
return False
return True
def test_encode_decode_bytelist():
vals = {b"1", b"2", b"3", b"4", b"100", b"10", b"21", b"5"}
assert set(decode_raw(encode_raw(list(vals)))) == vals
def test_encode_decode_raw():
vals = {b"id": 42}
assert decode_raw(encode_raw(vals))[b"id"] == 42
def from_bytes(cls, bytes_frontier: bytes):
val_dict = decode_raw(bytes_frontier)
return cls(val_dict.get(b"m"), val_dict.get(b"c"))
def unpack_audit_blob(self, audit_blob: bytes) -> Any:
"""
Returns:
decoded audit transaction
"""
return decode_raw(audit_blob)
def process_reject(self, block: BamiBlock) -> None:
reject_tx = decode_raw(block.transaction)
self.verify_reject_tx(block.public_key, reject_tx)
self.apply_reject_tx(block, reject_tx)
def process_confirm(self, block: BamiBlock) -> None:
confirm_tx = decode_raw(block.transaction)
self.verify_confirm_tx(block.public_key, confirm_tx)
self.apply_confirm_tx(block, confirm_tx)
def unpack_witness_blob(self, witness_blob: bytes) -> Any:
"""
Returns:
decoded witness transaction
"""
return decode_raw(witness_blob)
def received_peer_subs(self, peer: Peer, payload: SubscriptionsPayload) -> None:
subcoms = decode_raw(payload.subcoms)
self.process_peer_subscriptions(peer, subcoms)
def introduction_request_callback(self, peer, dist, payload):
subcoms = decode_raw(payload.extra_bytes)
self.process_peer_subscriptions(peer, subcoms)
# TODO: add subscription strategy
if self.settings.track_neighbours_chains:
self.subscribe_to_subcom(peer.public_key.key_to_bin())
def received_block_in_order(self, block: BamiBlock) -> None:
print(block.transaction)
decoded_tx = decode_raw(block.transaction)
if decoded_tx.get(b"to_peer",
None) == self.my_peer.public_key.key_to_bin():
self.add_block_to_response_processing(block)
def confirm_tx_extra_data(self, block: BamiBlock) -> Dict:
return {b"value": decode_raw(block.transaction).get(b"value")}