137 lines
4.6 KiB
Python
137 lines
4.6 KiB
Python
import os
|
|
import time
|
|
from collections import OrderedDict
|
|
from typing import Any, MutableMapping
|
|
|
|
import nacl.signing
|
|
|
|
from rainbowadn.chain.blockchain import BlockChainFactory
|
|
from rainbowadn.chain.chaincollectioninterface import ChainCollectionInterface
|
|
from rainbowadn.chain.reduction.reductionchainmetafactory import ReductionChainMetaFactory
|
|
from rainbowadn.data.atomic.integer import Integer
|
|
from rainbowadn.data.atomic.plain import Plain
|
|
from rainbowadn.data.collection.array.array import Array
|
|
from rainbowadn.data.collection.trees.binary.activebinarytree import ActiveBinaryTree
|
|
from rainbowadn.data.collection.trees.binary.avl import AVLBTBP
|
|
from rainbowadn.data.collection.trees.comparison.comparator import Replace
|
|
from rainbowadn.data.collection.trees.comparison.plaincomparator import PlainComparator
|
|
from rainbowadn.hashing.hashmentionable import HashMentionable
|
|
from rainbowadn.hashing.hashpoint import HashPoint
|
|
from rainbowadn.hashing.hashresolver import HashResolver
|
|
from rainbowadn.hashing.nullability.notnull import NotNull
|
|
from rainbowadn.hashing.recursivementionable import RecursiveMentionable
|
|
from rainbowadn.v13.algo import MINT_CONST
|
|
from rainbowadn.v13.bankchain import BankChain
|
|
from rainbowadn.v13.subject import Subject
|
|
from rainbowadn.v13.transaction import CoinData, Transaction
|
|
from rainbowadn.wrisbt.wrisbtchainprotocol import WrisbtChainProtocol
|
|
from rainbowadn.wrisbt.wrisbtparametres import WrisbtParametres
|
|
from rainbowadn.wrisbt.wrisbtroot import WrisbtRoot
|
|
|
|
|
|
class DumbResolver(HashResolver):
|
|
def __init__(self):
|
|
self.table: MutableMapping[bytes, bytes] = OrderedDict()
|
|
|
|
def _resolve(self, point: bytes) -> bytes:
|
|
assert isinstance(point, bytes)
|
|
return self.table[point]
|
|
|
|
def save(self, hash_point: HashPoint) -> None:
|
|
assert isinstance(hash_point, HashPoint)
|
|
if hash_point.point in self.table:
|
|
pass
|
|
elif isinstance(hash_point.value, NotNull):
|
|
value: HashMentionable = hash_point.value.value
|
|
self.table[hash_point.point] = HashPoint.bytes_of_mentioned(value)
|
|
if isinstance(value, RecursiveMentionable):
|
|
for hash_point in value.points():
|
|
self.save(hash_point)
|
|
else:
|
|
raise TypeError
|
|
|
|
|
|
def main0():
|
|
dr = DumbResolver()
|
|
bank = BankChain.empty(ReductionChainMetaFactory(), dr)
|
|
key_0 = nacl.signing.SigningKey.generate()
|
|
transaction_0 = Transaction.make(
|
|
[],
|
|
[CoinData.of(Subject(key_0.verify_key), 1_000_000)],
|
|
[]
|
|
)
|
|
coin_0, coin_1 = transaction_0.coins(dr, MINT_CONST, NotNull(HashPoint.of(Subject(key_0.verify_key))))
|
|
bank = bank.adds(
|
|
[
|
|
transaction_0,
|
|
Transaction.make(
|
|
[coin_1],
|
|
[CoinData.of(Subject(nacl.signing.SigningKey.generate().verify_key), 10_000)],
|
|
[key_0]
|
|
),
|
|
]
|
|
)
|
|
bank = bank.adds(
|
|
[]
|
|
)
|
|
print(bank)
|
|
print(bank.verify())
|
|
dr.save(HashPoint.of(bank.reference))
|
|
bank = BankChain.from_reference(ReductionChainMetaFactory(), dr.resolve(HashPoint.of(bank.reference).loose()), dr)
|
|
print(bank)
|
|
print(bank.verify())
|
|
# for key, value in dr.table.items():
|
|
# print(key.hex(), value.hex())
|
|
|
|
|
|
def main1():
|
|
stoptime = time.process_time()
|
|
|
|
def measure(message: str):
|
|
nonlocal stoptime
|
|
now = time.process_time()
|
|
print(message, now - stoptime)
|
|
stoptime = now
|
|
|
|
dr = DumbResolver()
|
|
btree = WrisbtRoot.empty(WrisbtParametres(1, 5))
|
|
measure('init')
|
|
for _ in range(10000):
|
|
key = os.urandom(5)
|
|
assert not btree.contains(dr, key)
|
|
btree = btree.add(dr, key)
|
|
assert btree.contains(dr, key)
|
|
measure('add')
|
|
dr.save(HashPoint.of(btree))
|
|
measure('save')
|
|
btree = dr.resolve(HashPoint.of(btree).loose())
|
|
print(btree.height)
|
|
measure('resolve')
|
|
|
|
|
|
def main2():
|
|
dr = DumbResolver()
|
|
chain: ChainCollectionInterface[Any, Plain, Array[WrisbtRoot]] = BlockChainFactory(
|
|
WrisbtChainProtocol(dr, Plain.factory(), 2).loose()
|
|
).loose().empty().loose()
|
|
for _ in range(1000):
|
|
chain = chain.add(HashPoint.of(Plain(os.urandom(16))))
|
|
|
|
assert chain
|
|
# noinspection PyUnresolvedReferences
|
|
print(dr.resolve(chain.actual_state().reference.value).height)
|
|
|
|
|
|
def main():
|
|
dr = DumbResolver()
|
|
tree: ActiveBinaryTree[Plain, Integer] = ActiveBinaryTree.empty(
|
|
AVLBTBP(PlainComparator(dr, Replace())), Plain.factory()
|
|
)
|
|
for i in range(26):
|
|
tree = tree.add(HashPoint.of(Plain(bytes([ord('A') + i]))))
|
|
print(tree.reference.str(dr, 0))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main1()
|