PTV/rainbowadn
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

test_all + better state protocol + different nullability interface

Browse Source
This commit is contained in:
AF 2022-05-21 00:54:50 +03:00
parent 3cf10ed8d4
commit 0ab101ecdc
24 changed files with 337 additions and 343 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

173
main.py
View File

@ -1,173 +1,4 @@
import os import unittest
import string
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.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.encryption.encrypted import Encrypted
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.hashing.resolvermetaorigin import ResolverMetaOrigin
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) -> tuple[bytes, 'HashResolver']:
assert isinstance(point, bytes)
return self.table[point], self
def save(self, hash_point: HashPoint) -> None:
assert isinstance(hash_point, HashPoint)
if hash_point.point in self.table:
pass
else:
value: HashMentionable = hash_point.resolve()
assert isinstance(value, HashMentionable)
self.table[hash_point.point] = HashPoint.bytes_of_mentioned(value)
if isinstance(value, RecursiveMentionable):
for hash_point in value.points():
self.save(hash_point)
def main0():
dr = DumbResolver()
bank = BankChain.empty(ReductionChainMetaFactory())
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(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(), ResolverMetaOrigin(dr).migrate(HashPoint.of(bank.reference)).resolve()
)
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) -> float:
nonlocal stoptime
now = time.process_time()
delta = now - stoptime
print(message, delta)
stoptime = now
return delta
dr = DumbResolver()
btree = WrisbtRoot.empty(WrisbtParametres(1, 5))
n = 10000
measure('init')
for _ in range(n):
key = os.urandom(5)
assert not btree.contains(key)
btree = btree.add(key)
assert btree.contains(key)
measure('add')
dr.save(HashPoint.of(btree))
measure('save')
btree = ResolverMetaOrigin(dr).migrate(HashPoint.of(btree)).resolve()
assert len(btree.keys()) == n
print(btree.height)
measure('resolve and iterate')
for _ in range(n):
key = os.urandom(5)
assert not btree.contains(key)
btree = btree.add(key)
assert btree.contains(key)
measure('resolve and add')
def main2():
chain: ChainCollectionInterface[Any, Plain, WrisbtRoot] = BlockChainFactory(
WrisbtChainProtocol(Plain.factory(), 2).loose()
).empty().loose()
for _ in range(1000):
chain = chain.add(HashPoint.of(Plain(os.urandom(16))))
assert chain
# noinspection PyUnresolvedReferences
print(chain.actual_state().reference.value.resolve().height)
def main3():
tree: ActiveBinaryTree[Plain, Integer] = ActiveBinaryTree.empty(
AVLBTBP(PlainComparator(Replace())), Plain.factory()
)
for i in range(26):
tree = tree.add(HashPoint.of(Plain(bytes([ord('A') + i]))))
print(tree.reference.str(0))
def main():
key = b'a' * 32
dr = DumbResolver()
tree: ActiveBinaryTree[Plain, Integer] = ActiveBinaryTree.empty(
AVLBTBP(PlainComparator(Replace())), Plain.factory()
)
for char in string.ascii_uppercase:
tree = tree.add(HashPoint.of(Plain(char.encode())))
print(tree.reference.str(0))
target = tree.reference
target = Encrypted.encrypt(target, key).decrypted
print(Encrypted.ecc)
tree = tree.create(target)
print(tree.reference.str(0))
tree = tree.add(HashPoint.of(Plain(b'NEWKEY')))
tree = tree.remove(HashPoint.of(Plain(b'Q')))
print(tree.reference.str(0))
target = tree.reference
eeed = Encrypted.encrypt(target, key)
print(Encrypted.ecc)
dr.save(HashPoint.of(eeed))
# for key, value in dr.table.items():
# print(key.hex(), value.hex())
print(ResolverMetaOrigin(dr).migrate(HashPoint.of(eeed)).resolve().decrypted.str(0))
if __name__ == '__main__': if __name__ == '__main__':
main() unittest.main('rainbowadn.testing.test_all')

19
rainbowadn/chain/blockchain.py
View File

@ -5,7 +5,6 @@ from rainbowadn.chain.blockchainprotocol import BlockChainProtocol
from rainbowadn.chain.chaincollectionfactory import ChainCollectionFactory from rainbowadn.chain.chaincollectionfactory import ChainCollectionFactory
from rainbowadn.chain.chaincollectioninterface import ChainCollectionInterface from rainbowadn.chain.chaincollectioninterface import ChainCollectionInterface
from rainbowadn.hashing.hashpoint import HashPoint from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.nullability.notnull import NotNull
from rainbowadn.hashing.nullability.null import Null from rainbowadn.hashing.nullability.null import Null
from rainbowadn.hashing.nullability.nullablereference import NullableReference from rainbowadn.hashing.nullability.nullablereference import NullableReference
from rainbowadn.hashing.rainbow_factory import RainbowFactory from rainbowadn.hashing.rainbow_factory import RainbowFactory
@ -76,20 +75,18 @@ class BlockChain(
) -> NullableReference[ ) -> NullableReference[
StateType StateType
]: ]:
if isinstance(self.reference.reference, Null): if self.reference.reference.null():
return NullableReference( return NullableReference(
Null(), Null(),
self.protocol.state_factory self.protocol.state_factory
) )
elif isinstance(self.reference.reference, NotNull): else:
block: Block[ block: Block[
HeaderType, HeaderType,
StateType StateType
] = self.reference.reference.value.resolve() ] = self.reference.reference.resolve().resolve()
assert isinstance(block, Block) assert isinstance(block, Block)
return NullableReference.of(block.state) return NullableReference.of(block.state)
else:
raise TypeError
def _add( def _add(
self, self,
@ -118,23 +115,21 @@ class BlockChain(
HeaderType, HeaderType,
ActualStateType ActualStateType
]: ]:
assert isinstance(self.reference.reference, NotNull) assert not self.reference.reference.null()
block: Block[ block: Block[
HeaderType, HeaderType,
StateType StateType
] = self.reference.reference.value.resolve() ] = self.reference.reference.resolve().resolve()
assert isinstance(block, Block) assert isinstance(block, Block)
return self.factory().from_reference(block.previous) return self.factory().from_reference(block.previous)
def verify(self) -> bool: def verify(self) -> bool:
if isinstance(self.reference.reference, Null): if self.reference.reference.null():
return True return True
elif isinstance(self.reference.reference, NotNull): else:
return self.verify_link( return self.verify_link(
self.previous().reference self.previous().reference
) and self.previous().verify() ) and self.previous().verify()
else:
raise TypeError
def _verify_link( def _verify_link(
self, self,

15
rainbowadn/chain/blockcollectioninterface.py
View File

@ -2,7 +2,6 @@ from typing import Generic, TypeVar
from rainbowadn.data.collection.collection_interface.collectioninterface import CollectionInterface from rainbowadn.data.collection.collection_interface.collectioninterface import CollectionInterface
from rainbowadn.hashing.hashpoint import HashPoint from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.nullability.notnull import NotNull
from rainbowadn.hashing.nullability.null import Null from rainbowadn.hashing.nullability.null import Null
from rainbowadn.hashing.nullability.nullablereference import NullableReference from rainbowadn.hashing.nullability.nullablereference import NullableReference
from rainbowadn.hashing.rainbow_factory import RainbowFactory from rainbowadn.hashing.rainbow_factory import RainbowFactory
@ -39,15 +38,13 @@ class BlockCollectionInterface(
previous: NullableReference[BlockType] previous: NullableReference[BlockType]
) -> bool: ) -> bool:
assert isinstance(previous, NullableReference) assert isinstance(previous, NullableReference)
if isinstance(self.reference.reference, Null): if self.reference.reference.null():
return True return True
elif isinstance(self.reference.reference, NotNull): else:
return self._verify_link( return self._verify_link(
self.reference.reference.value.resolve(), self.reference.reference.resolve().resolve(),
previous previous
) )
else:
raise TypeError
def _actual_state_factory(self) -> RainbowFactory[ActualStateType]: def _actual_state_factory(self) -> RainbowFactory[ActualStateType]:
raise NotImplementedError raise NotImplementedError
@ -56,12 +53,10 @@ class BlockCollectionInterface(
raise NotImplementedError raise NotImplementedError
def actual_state(self) -> NullableReference[ActualStateType]: def actual_state(self) -> NullableReference[ActualStateType]:
if isinstance(self.reference.reference, Null): if self.reference.reference.null():
return NullableReference(Null(), self._actual_state_factory()) return NullableReference(Null(), self._actual_state_factory())
elif isinstance(self.reference.reference, NotNull):
return NullableReference.of(self._actual_state(self.reference.reference.value.resolve()))
else: else:
raise TypeError return NullableReference.of(self._actual_state(self.reference.reference.resolve().resolve()))
def add( def add(
self, self,

8
rainbowadn/chain/reduction/reductionstageprotocol.py
View File

@ -9,8 +9,6 @@ from rainbowadn.chain.stages.derivation.derived import Derived
from rainbowadn.chain.stages.derivation.derivedstage import DerivedStage from rainbowadn.chain.stages.derivation.derivedstage import DerivedStage
from rainbowadn.chain.stages.derivation.derivedstate import DerivedState from rainbowadn.chain.stages.derivation.derivedstate import DerivedState
from rainbowadn.hashing.hashpoint import HashPoint from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.nullability.notnull import NotNull
from rainbowadn.hashing.nullability.null import Null
from rainbowadn.hashing.nullability.nullablereference import NullableReference from rainbowadn.hashing.nullability.nullablereference import NullableReference
__all__ = ('ReductionStageProtocol',) __all__ = ('ReductionStageProtocol',)
@ -33,12 +31,10 @@ class ReductionStageProtocol(
previous: NullableReference[AccumulatorType], previous: NullableReference[AccumulatorType],
) -> HashPoint[AccumulatorType]: ) -> HashPoint[AccumulatorType]:
assert isinstance(previous, NullableReference) assert isinstance(previous, NullableReference)
if isinstance(previous.reference, Null): if previous.reference.null():
return self.protocol.initial(previous.factory) return self.protocol.initial(previous.factory)
elif isinstance(previous.reference, NotNull):
return previous.reference.value
else: else:
raise TypeError return previous.reference.resolve()
def derive_header( def derive_header(
self, self,

9
rainbowadn/chain/stages/derivation/activestageprotocol.py
View File

@ -6,7 +6,6 @@ from rainbowadn.chain.stages.derivation.derivedstate import DerivedState
from rainbowadn.chain.stages.stage import StageStage, StageStageFactory, StateStage from rainbowadn.chain.stages.stage import StageStage, StageStageFactory, StateStage
from rainbowadn.chain.stages.stageprotocol import StageProtocol from rainbowadn.chain.stages.stageprotocol import StageProtocol
from rainbowadn.hashing.hashpoint import HashPoint from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.nullability.notnull import NotNull
from rainbowadn.hashing.nullability.null import Null from rainbowadn.hashing.nullability.null import Null
from rainbowadn.hashing.nullability.nullablereference import NullableReference from rainbowadn.hashing.nullability.nullablereference import NullableReference
from rainbowadn.hashing.rainbow_factory import RainbowFactory from rainbowadn.hashing.rainbow_factory import RainbowFactory
@ -43,16 +42,14 @@ class ActiveStageProtocol(
) -> NullableReference[BaseStateType]: ) -> NullableReference[BaseStateType]:
assert isinstance(previous_reference, NullableReference) assert isinstance(previous_reference, NullableReference)
assert isinstance(base_state_factory, RainbowFactory) assert isinstance(base_state_factory, RainbowFactory)
if isinstance(previous_reference.reference, Null): if previous_reference.reference.null():
return NullableReference(Null(), base_state_factory) return NullableReference(Null(), base_state_factory)
elif isinstance(previous_reference.reference, NotNull): else:
previous_state_stage: StateStage[HeaderType, BaseStateType, StageType] = ( previous_state_stage: StateStage[HeaderType, BaseStateType, StageType] = (
previous_reference.reference.value.resolve() previous_reference.reference.resolve().resolve()
) )
assert isinstance(previous_state_stage, StateStage) assert isinstance(previous_state_stage, StateStage)
return NullableReference.of(previous_state_stage.state) return NullableReference.of(previous_state_stage.state)
else:
raise TypeError
def _derive_cycle( def _derive_cycle(
self, self,

26
rainbowadn/chain/stages/derivation/activestagestateprotocol.py
View File

@ -37,32 +37,6 @@ class ActiveStageStateProtocol(
self.stage_factory = stage_factory self.stage_factory = stage_factory
self.base_state_factory = base_state_factory self.base_state_factory = base_state_factory
def _initial_state(self) -> HashPoint[
StateStage[
HeaderType,
BaseStateType,
StageType
]
]:
raise TypeError('use .derive()')
def _derive(
self,
previous: HashPoint[StateStage[
HeaderType,
BaseStateType,
StageType
]],
header: HashPoint[HeaderType]
) -> HashPoint[
StateStage[
HeaderType,
BaseStateType,
StageType
]
]:
raise TypeError('use .derive()')
def derive( def derive(
self, self,
previous: NullableReference[ previous: NullableReference[

19
rainbowadn/chain/stages/stage.py
View File

@ -4,7 +4,6 @@ from rainbowadn.chain.stages.stageprotocol import StageProtocol
from rainbowadn.hashing.hash_point_format import hash_point_format, tabulate from rainbowadn.hashing.hash_point_format import hash_point_format, tabulate
from rainbowadn.hashing.hashpoint import HashPoint from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.hashresolver import HashResolver from rainbowadn.hashing.hashresolver import HashResolver
from rainbowadn.hashing.nullability.notnull import NotNull
from rainbowadn.hashing.nullability.null import Null from rainbowadn.hashing.nullability.null import Null
from rainbowadn.hashing.nullability.nullablereference import NullableReference, NullableReferenceFactory from rainbowadn.hashing.nullability.nullablereference import NullableReference, NullableReferenceFactory
from rainbowadn.hashing.rainbow_factory import RainbowFactory from rainbowadn.hashing.rainbow_factory import RainbowFactory
@ -55,14 +54,12 @@ class StageStage(
) -> NullableReference[BaseStateType]: ) -> NullableReference[BaseStateType]:
assert isinstance(previous, NullableReference) assert isinstance(previous, NullableReference)
assert isinstance(base_factory, RainbowFactory) assert isinstance(base_factory, RainbowFactory)
if isinstance(previous.reference, Null): if previous.reference.null():
return NullableReference(Null(), base_factory) return NullableReference(Null(), base_factory)
elif isinstance(previous.reference, NotNull): else:
state_stage: StateStage[HeaderType, BaseStateType, StageType] = previous.reference.value.resolve() state_stage: StateStage[HeaderType, BaseStateType, StageType] = previous.reference.resolve().resolve()
assert isinstance(state_stage, StateStage) assert isinstance(state_stage, StateStage)
return NullableReference.of(state_stage.state) return NullableReference.of(state_stage.state)
else:
raise TypeError
def verify( def verify(
self, self,
@ -73,14 +70,16 @@ class StageStage(
assert isinstance(previous, NullableReference) assert isinstance(previous, NullableReference)
assert isinstance(header, HashPoint) assert isinstance(header, HashPoint)
assert isinstance(base_factory, RainbowFactory) assert isinstance(base_factory, RainbowFactory)
if isinstance(self.previous.reference, Null): if self.previous.reference.null():
return self.protocol.verify_header( return self.protocol.verify_header(
self._previous_state(previous, base_factory), self._previous_state(previous, base_factory),
header, header,
self.stage self.stage
) )
elif isinstance(self.previous.reference, NotNull): else:
previous_stage: StageStage[HeaderType, BaseStateType, StageType] = self.previous.reference.value.resolve() previous_stage: StageStage[HeaderType, BaseStateType, StageType] = (
self.previous.reference.resolve().resolve()
)
assert isinstance(previous_stage, StageStage) assert isinstance(previous_stage, StageStage)
return self.protocol.verify_stage( return self.protocol.verify_stage(
previous_stage.stage, previous_stage.stage,
@ -90,8 +89,6 @@ class StageStage(
header, header,
base_factory base_factory
) )
else:
raise TypeError
def points(self) -> Iterable[HashPoint]: def points(self) -> Iterable[HashPoint]:
return [*self.previous.points(), self.stage] return [*self.previous.points(), self.stage]

23
rainbowadn/chain/states/activestateprotocol.py
View File

@ -2,8 +2,6 @@ from typing import TypeVar
from rainbowadn.chain.states.stateprotocol import StateProtocol from rainbowadn.chain.states.stateprotocol import StateProtocol
from rainbowadn.hashing.hashpoint import HashPoint from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.nullability.notnull import NotNull
from rainbowadn.hashing.nullability.null import Null
from rainbowadn.hashing.nullability.nullablereference import NullableReference from rainbowadn.hashing.nullability.nullablereference import NullableReference
__all__ = ('ActiveStateProtocol',) __all__ = ('ActiveStateProtocol',)
@ -25,28 +23,9 @@ class ActiveStateProtocol(StateProtocol[HeaderType, StateType]):
assert state == self.derive(previous, header) assert state == self.derive(previous, header)
return True return True
def _initial_state(self) -> HashPoint[StateType]:
raise NotImplementedError
def _derive(
self,
previous: HashPoint[StateType],
header: HashPoint[HeaderType],
) -> HashPoint[StateType]:
raise NotImplementedError
def derive( def derive(
self, self,
previous: NullableReference[StateType], previous: NullableReference[StateType],
header: HashPoint[HeaderType], header: HashPoint[HeaderType],
) -> HashPoint[StateType]: ) -> HashPoint[StateType]:
assert isinstance(previous, NullableReference) raise NotImplementedError
assert isinstance(header, HashPoint)
if isinstance(previous.reference, Null):
previous_state: HashPoint[StateType] = self._initial_state()
elif isinstance(previous.reference, NotNull):
previous_state: HashPoint[StateType] = previous.reference.value
else:
raise TypeError
assert isinstance(previous_state, HashPoint)
return self._derive(previous_state, header)

48
rainbowadn/chain/states/metareductionstateprotocol.py Normal file
View File

@ -0,0 +1,48 @@
from typing import TypeVar
from rainbowadn.chain.states.activestateprotocol import ActiveStateProtocol
from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.nullability.nullablereference import NullableReference
__all__ = ('MetaReductionStateProtocol',)
HeaderType = TypeVar('HeaderType')
StateType = TypeVar('StateType')
class MetaReductionStateProtocol(ActiveStateProtocol[HeaderType, StateType]):
def verify(
self,
previous: NullableReference[StateType],
header: HashPoint[HeaderType],
state: HashPoint[StateType]
) -> bool:
assert isinstance(previous, NullableReference)
assert isinstance(header, HashPoint)
assert isinstance(state, HashPoint)
assert state == self.derive(previous, header)
return True
def _initial_state(self) -> HashPoint[StateType]:
raise NotImplementedError
def _derive(
self,
previous: HashPoint[StateType],
header: HashPoint[HeaderType],
) -> HashPoint[StateType]:
raise NotImplementedError
def derive(
self,
previous: NullableReference[StateType],
header: HashPoint[HeaderType],
) -> HashPoint[StateType]:
assert isinstance(previous, NullableReference)
assert isinstance(header, HashPoint)
if previous.reference.null():
previous_state: HashPoint[StateType] = self._initial_state()
else:
previous_state: HashPoint[StateType] = previous.reference.resolve()
assert isinstance(previous_state, HashPoint)
return self._derive(previous_state, header)

8
rainbowadn/data/collection/keymetadataquerycollection.py
View File

@ -30,11 +30,7 @@ class KeyMetadataQueryCollection(QueryCollectionInterface[ActiveKeyType], Generi
HashPoint[KeyMetadata[ActiveKeyType, MetaDataType]] HashPoint[KeyMetadata[ActiveKeyType, MetaDataType]]
] = self.collection.query(HashPoint.of(KeyMetadata(key, self.metadata))) ] = self.collection.query(HashPoint.of(KeyMetadata(key, self.metadata)))
assert isinstance(result, Nullable) assert isinstance(result, Nullable)
if isinstance(result, Null): if result.null():
return Null() return Null()
elif isinstance(result, NotNull):
hash_point: HashPoint[KeyMetadata[ActiveKeyType, MetaDataType]] = result.value
assert isinstance(hash_point, HashPoint)
return NotNull(hash_point.resolve().key)
else: else:
raise TypeError return NotNull(result.resolve().resolve().key)

8
rainbowadn/data/collection/mapping/querymapping.py
View File

@ -30,11 +30,9 @@ class QueryMapping(Generic[KVKeyType, KVValueType]):
HashPoint[KeyValue[KVKeyType, KVValueType]] HashPoint[KeyValue[KVKeyType, KVValueType]]
] = self.collection.query(HashPoint.of(KeyValue(key, self.empty_value))) ] = self.collection.query(HashPoint.of(KeyValue(key, self.empty_value)))
assert isinstance(query_result, Nullable) assert isinstance(query_result, Nullable)
if isinstance(query_result, Null): if query_result.null():
return Null() return Null()
elif isinstance(query_result, NotNull): else:
key_value: KeyValue[KVKeyType, KVValueType] = query_result.value.resolve() key_value: KeyValue[KVKeyType, KVValueType] = query_result.resolve().resolve()
assert isinstance(key_value, KeyValue) assert isinstance(key_value, KeyValue)
return NotNull(key_value.value) return NotNull(key_value.value)
else:
raise TypeError

6
rainbowadn/data/collection/trees/binary/activebinarytree.py
View File

@ -12,7 +12,6 @@ from rainbowadn.data.collection.trees.binary.querybinarytree import QueryBinaryT
from rainbowadn.data.collection.trees.comparison.comparator import (Comparator, Comparison, Equal, Left, Replace, Right) from rainbowadn.data.collection.trees.comparison.comparator import (Comparator, Comparison, Equal, Left, Replace, Right)
from rainbowadn.data.collection.trees.comparison.keyedcomparator import KeyedComparator from rainbowadn.data.collection.trees.comparison.keyedcomparator import KeyedComparator
from rainbowadn.hashing.hashpoint import HashPoint from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.nullability.notnull import NotNull
from rainbowadn.hashing.nullability.null import Null from rainbowadn.hashing.nullability.null import Null
from rainbowadn.hashing.nullability.nullablereference import NullableReference from rainbowadn.hashing.nullability.nullablereference import NullableReference
from rainbowadn.hashing.rainbow_factory import RainbowFactory from rainbowadn.hashing.rainbow_factory import RainbowFactory
@ -142,7 +141,7 @@ class ActiveBinaryTree(
class ActiveCreationProtocol(BalancedTreeCreationProtocol[ActiveKeyType, MetaDataType, ActiveBinaryTree]): class ActiveCreationProtocol(BalancedTreeCreationProtocol[ActiveKeyType, MetaDataType, ActiveBinaryTree]):
def splittable(self, tree: ActiveBinaryTree[ActiveKeyType, MetaDataType]) -> bool: def splittable(self, tree: ActiveBinaryTree[ActiveKeyType, MetaDataType]) -> bool:
assert isinstance(tree, ActiveBinaryTree) assert isinstance(tree, ActiveBinaryTree)
return isinstance(tree.reference.reference, NotNull) return not tree.reference.reference.null()
def split( def split(
self, self,
@ -154,8 +153,7 @@ class ActiveCreationProtocol(BalancedTreeCreationProtocol[ActiveKeyType, MetaDat
ActiveBinaryTree[ActiveKeyType, MetaDataType] ActiveBinaryTree[ActiveKeyType, MetaDataType]
]: ]:
assert isinstance(tree, ActiveBinaryTree) assert isinstance(tree, ActiveBinaryTree)
assert isinstance(tree.reference.reference, NotNull) hash_point: HashPoint[BinaryTree[KeyMetadata[ActiveKeyType, MetaDataType]]] = tree.reference.reference.resolve()
hash_point: HashPoint[BinaryTree[KeyMetadata[ActiveKeyType, MetaDataType]]] = tree.reference.reference.value
assert isinstance(hash_point, HashPoint) assert isinstance(hash_point, HashPoint)
resolved: BinaryTree[KeyMetadata[ActiveKeyType, MetaDataType]] = hash_point.resolve() resolved: BinaryTree[KeyMetadata[ActiveKeyType, MetaDataType]] = hash_point.resolve()
assert isinstance(resolved, BinaryTree) assert isinstance(resolved, BinaryTree)

8
rainbowadn/data/collection/trees/binary/querybinarytree.py
View File

@ -27,10 +27,10 @@ class QueryBinaryTree(QueryCollectionInterface[KeyType], Generic[KeyType]):
assert isinstance(key, HashPoint) assert isinstance(key, HashPoint)
reference: Nullable[HashPoint[BinaryTree[KeyType]]] = self.reference.reference reference: Nullable[HashPoint[BinaryTree[KeyType]]] = self.reference.reference
assert isinstance(reference, Nullable) assert isinstance(reference, Nullable)
if isinstance(reference, Null): if reference.null():
return Null() return Null()
elif isinstance(reference, NotNull): else:
hash_point: HashPoint[BinaryTree[KeyType]] = reference.value hash_point: HashPoint[BinaryTree[KeyType]] = reference.resolve()
assert isinstance(hash_point, HashPoint) assert isinstance(hash_point, HashPoint)
tree: BinaryTree[KeyType] = hash_point.resolve() tree: BinaryTree[KeyType] = hash_point.resolve()
assert isinstance(tree, BinaryTree) assert isinstance(tree, BinaryTree)
@ -44,5 +44,3 @@ class QueryBinaryTree(QueryCollectionInterface[KeyType], Generic[KeyType]):
return QueryBinaryTree(self.comparator, tree.treer).query(key) return QueryBinaryTree(self.comparator, tree.treer).query(key)
else: else:
raise TypeError raise TypeError
else:
raise TypeError

10
rainbowadn/hashing/nullability/notnull.py
View File

@ -8,11 +8,17 @@ NullableType = TypeVar('NullableType')
class NotNull(Nullable[NullableType], Generic[NullableType]): class NotNull(Nullable[NullableType], Generic[NullableType]):
def null(self) -> bool:
return False
def _resolve(self) -> NullableType:
return self._value
def __init__(self, value: NullableType): def __init__(self, value: NullableType):
self.value = value self._value = value
def __eq__(self, other): def __eq__(self, other):
if isinstance(other, NotNull): if isinstance(other, NotNull):
return self.value == other.value return self._value == other._value
else: else:
return NotImplemented return NotImplemented

6
rainbowadn/hashing/nullability/null.py
View File

@ -8,6 +8,12 @@ NullableType = TypeVar('NullableType')
class Null(Nullable[NullableType], Generic[NullableType]): class Null(Nullable[NullableType], Generic[NullableType]):
def null(self) -> bool:
return True
def _resolve(self) -> NullableType:
raise TypeError('null')
def __eq__(self, other): def __eq__(self, other):
if isinstance(other, Null): if isinstance(other, Null):
return True return True

12
rainbowadn/hashing/nullability/nullable.py
View File

@ -7,4 +7,14 @@ NullableType = TypeVar('NullableType')
class Nullable(Generic[NullableType], abc.ABC): class Nullable(Generic[NullableType], abc.ABC):
pass def null(self) -> bool:
"""must never change"""
raise NotImplementedError
def _resolve(self) -> NullableType:
"""if .null(), throw"""
raise NotImplementedError
def resolve(self) -> NullableType:
assert not self.null()
return self._resolve()

20
rainbowadn/hashing/nullability/nullablereference.py
View File

@ -20,22 +20,16 @@ class NullableReference(RecursiveMentionable, Generic[ReferencedType]):
return NullableReferenceFactory(self.factory) return NullableReferenceFactory(self.factory)
def points(self) -> Iterable[HashPoint]: def points(self) -> Iterable[HashPoint]:
if isinstance(self.reference, NotNull): if self.reference.null():
return [self.reference.value]
elif isinstance(self.reference, Null):
return [] return []
else: else:
raise TypeError return [self.reference.resolve()]
def __bytes__(self): def __bytes__(self):
if isinstance(self.reference, NotNull): if self.reference.null():
hash_point: HashPoint[ReferencedType] = self.reference.value
assert isinstance(hash_point, HashPoint)
return hash_point.point
elif isinstance(self.reference, Null):
return HashPoint.NULL_HASH return HashPoint.NULL_HASH
else: else:
raise TypeError return self.reference.resolve().point
def __init__( def __init__(
self, reference: Nullable[HashPoint[ReferencedType]], factory: RainbowFactory[ReferencedType] self, reference: Nullable[HashPoint[ReferencedType]], factory: RainbowFactory[ReferencedType]
@ -55,12 +49,10 @@ class NullableReference(RecursiveMentionable, Generic[ReferencedType]):
return cls.of(HashPoint.of(value)) return cls.of(HashPoint.of(value))
def str(self, tab: int) -> str: def str(self, tab: int) -> str:
if isinstance(self.reference, Null): if self.reference.null():
return f'-' return f'-'
elif isinstance(self.reference, NotNull):
return f'{hash_point_format(self.reference.value, tab)}'
else: else:
raise TypeError return f'{hash_point_format(self.reference.resolve(), tab)}'
def __eq__(self, other): def __eq__(self, other):
if isinstance(other, NullableReference): if isinstance(other, NullableReference):

8
rainbowadn/hashing/reduce_nullable_reference.py
View File

@ -2,8 +2,6 @@ from typing import TypeVar
from rainbowadn.hashing.hashpoint import HashPoint from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.hashresolver import HashResolver from rainbowadn.hashing.hashresolver import HashResolver
from rainbowadn.hashing.nullability.notnull import NotNull
from rainbowadn.hashing.nullability.null import Null
from rainbowadn.hashing.nullability.nullablereference import NullableReference from rainbowadn.hashing.nullability.nullablereference import NullableReference
__all__ = ('reduce_nullable_reference',) __all__ = ('reduce_nullable_reference',)
@ -17,9 +15,7 @@ def reduce_nullable_reference(
) -> NullableReference[ReReferencedType]: ) -> NullableReference[ReReferencedType]:
assert isinstance(reference, NullableReference) assert isinstance(reference, NullableReference)
assert isinstance(resolver, HashResolver) assert isinstance(resolver, HashResolver)
if isinstance(reference.reference, Null): if reference.reference.null():
return reference.factory.from_bytes(HashPoint.NULL_HASH, resolver) return reference.factory.from_bytes(HashPoint.NULL_HASH, resolver)
elif isinstance(reference.reference, NotNull):
return reference.reference.value.resolve()
else: else:
raise TypeError return reference.reference.resolve().resolve()

28
rainbowadn/testing/dictresolver.py Normal file
View File

@ -0,0 +1,28 @@
from collections import OrderedDict
from typing import MutableMapping
from rainbowadn.hashing.hashmentionable import HashMentionable
from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.hashresolver import HashResolver
from rainbowadn.hashing.recursivementionable import RecursiveMentionable
class DictResolver(HashResolver):
def __init__(self):
self.table: MutableMapping[bytes, bytes] = OrderedDict()
def resolve(self, point: bytes) -> tuple[bytes, 'HashResolver']:
assert isinstance(point, bytes)
return self.table[point], self
def save(self, hash_point: HashPoint) -> None:
assert isinstance(hash_point, HashPoint)
if hash_point.point in self.table:
pass
else:
value: HashMentionable = hash_point.resolve()
assert isinstance(value, HashMentionable)
self.table[hash_point.point] = HashPoint.bytes_of_mentioned(value)
if isinstance(value, RecursiveMentionable):
for hash_point in value.points():
self.save(hash_point)

163
rainbowadn/testing/test_all.py Normal file
View File

@ -0,0 +1,163 @@
import os
import string
import time
import unittest
from typing import Any
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.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.encryption.encrypted import Encrypted
from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.nullability.notnull import NotNull
from rainbowadn.hashing.resolvermetaorigin import ResolverMetaOrigin
from rainbowadn.testing.dictresolver import DictResolver
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 TestAll(unittest.TestCase):
def test_bankchain(self):
with self.subTest('setup'):
dr = DictResolver()
with self.subTest('create empty'):
bank = BankChain.empty(ReductionChainMetaFactory())
with self.subTest('prepare transactions'):
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(MINT_CONST, NotNull(HashPoint.of(Subject(key_0.verify_key))))
with self.subTest('add transactions'):
bank = bank.adds(
[
transaction_0,
Transaction.make(
[coin_1],
[CoinData.of(Subject(nacl.signing.SigningKey.generate().verify_key), 10_000)],
[key_0]
),
]
)
with self.subTest('add empty'):
bank = bank.adds(
[]
)
print(bank)
with self.subTest('verify'):
assert bank.verify()
with self.subTest('recover'):
dr.save(HashPoint.of(bank.reference))
bank = BankChain.from_reference(
ReductionChainMetaFactory(), ResolverMetaOrigin(dr).migrate(HashPoint.of(bank.reference)).resolve()
)
print(bank)
with self.subTest('verify'):
assert bank.verify()
def test_wrisbt(self):
with self.subTest('setup'):
stoptime = time.process_time()
def measure(message: str) -> float:
nonlocal stoptime
now = time.process_time()
delta = now - stoptime
print(message, delta)
stoptime = now
return delta
dr = DictResolver()
n = 10000
with self.subTest('create empty'):
btree = WrisbtRoot.empty(WrisbtParametres(1, 5))
measure('init')
with self.subTest('add keys', n=n):
for _ in range(n):
key = os.urandom(5)
assert not btree.contains(key)
btree = btree.add(key)
assert btree.contains(key)
measure('add')
with self.subTest('save'):
dr.save(HashPoint.of(btree))
measure('save')
with self.subTest('resolve and iterate'):
btree = ResolverMetaOrigin(dr).migrate(HashPoint.of(btree)).resolve()
assert len(btree.keys()) == n
print(btree.height)
measure('resolve and iterate')
with self.subTest('resolve and add', n=n):
for _ in range(n):
key = os.urandom(5)
assert not btree.contains(key)
btree = btree.add(key)
assert btree.contains(key)
measure('resolve and add')
def test_wrisbt_index(self):
with self.subTest('create empty'):
chain: ChainCollectionInterface[Any, Plain, WrisbtRoot] = BlockChainFactory(
WrisbtChainProtocol(Plain.factory(), 2).loose()
).empty().loose()
with self.subTest('fill'):
for _ in range(1000):
chain = chain.add(HashPoint.of(Plain(os.urandom(16))))
with self.subTest('check'):
assert chain
with self.subTest('measure height'):
reference = chain.actual_state().reference
assert not reference.null()
print(reference.resolve().resolve().height)
def test_avl(self):
tree: ActiveBinaryTree[Plain, Integer] = ActiveBinaryTree.empty(
AVLBTBP(PlainComparator(Replace())), Plain.factory()
)
for i in range(26):
tree = tree.add(HashPoint.of(Plain(bytes([ord('A') + i]))))
print(tree.reference.str(0))
def test_encryption(self):
with self.subTest('setup'):
key = b'a' * 32
dr = DictResolver()
with self.subTest('create empty'):
tree: ActiveBinaryTree[Plain, Integer] = ActiveBinaryTree.empty(
AVLBTBP(PlainComparator(Replace())), Plain.factory()
)
with self.subTest('fill'):
for char in string.ascii_uppercase:
tree = tree.add(HashPoint.of(Plain(char.encode())))
print(tree.reference.str(0))
with self.subTest('encrypt'):
target = tree.reference
target = Encrypted.encrypt(target, key).decrypted
print(Encrypted.ecc)
tree = tree.create(target)
print(tree.reference.str(0))
with self.subTest('alter'):
tree = tree.add(HashPoint.of(Plain(b'NEWKEY')))
tree = tree.remove(HashPoint.of(Plain(b'Q')))
print(tree.reference.str(0))
with self.subTest('encrypt'):
target = tree.reference
eeed = Encrypted.encrypt(target, key)
print(Encrypted.ecc)
dr.save(HashPoint.of(eeed))
print(ResolverMetaOrigin(dr).migrate(HashPoint.of(eeed)).resolve().decrypted.str(0))

13
rainbowadn/v13/bankprotocol.py
View File

@ -3,16 +3,15 @@ from rainbowadn.chain.reduction.reduction import Reduction
from rainbowadn.chain.reduction.reductionprotocol import ReductionProtocol from rainbowadn.chain.reduction.reductionprotocol import ReductionProtocol
from rainbowadn.chain.reduction.reductionresult import ReductionResult from rainbowadn.chain.reduction.reductionresult import ReductionResult
from rainbowadn.data.atomic.integer import Integer from rainbowadn.data.atomic.integer import Integer
from rainbowadn.hashing.static import StaticFactory
from rainbowadn.data.collection.trees.binary.binarytree import BinaryTreeFactory
from rainbowadn.data.collection.keymetadata import KeyMetadataFactory from rainbowadn.data.collection.keymetadata import KeyMetadataFactory
from rainbowadn.data.collection.stack.stack import Stack from rainbowadn.data.collection.stack.stack import Stack
from rainbowadn.data.collection.trees.binary.binarytree import BinaryTreeFactory
from rainbowadn.hashing.hashpoint import HashPoint from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.nullability.notnull import NotNull
from rainbowadn.hashing.nullability.null import Null from rainbowadn.hashing.nullability.null import Null
from rainbowadn.hashing.nullability.nullable import Nullable from rainbowadn.hashing.nullability.nullable import Nullable
from rainbowadn.hashing.nullability.nullablereference import NullableReference from rainbowadn.hashing.nullability.nullablereference import NullableReference
from rainbowadn.hashing.rainbow_factory import RainbowFactory from rainbowadn.hashing.rainbow_factory import RainbowFactory
from rainbowadn.hashing.static import StaticFactory
from rainbowadn.v13.bankstate import BankState from rainbowadn.v13.bankstate import BankState
from rainbowadn.v13.subject import Subject from rainbowadn.v13.subject import Subject
from rainbowadn.v13.transaction import Coin, Transaction from rainbowadn.v13.transaction import Coin, Transaction
@ -30,17 +29,15 @@ class BankProtocol(ReductionProtocol[NullableReference[Stack[Transaction]], Bank
assert isinstance(bank_state, BankState) assert isinstance(bank_state, BankState)
reference: Nullable[HashPoint[Stack[Transaction]]] = reduction.reductor.resolve().reference reference: Nullable[HashPoint[Stack[Transaction]]] = reduction.reductor.resolve().reference
assert isinstance(reference, Nullable) assert isinstance(reference, Nullable)
if isinstance(reference, Null): if reference.null():
return Reduced(HashPoint.of(bank_state.without_miner())) return Reduced(HashPoint.of(bank_state.without_miner()))
elif isinstance(reference, NotNull): else:
stack: Stack[Transaction] = reference.value.resolve() stack: Stack[Transaction] = reference.resolve().resolve()
assert isinstance(stack, Stack) assert isinstance(stack, Stack)
return Reduction( return Reduction(
HashPoint.of(stack.previous), HashPoint.of(stack.previous),
HashPoint.of(bank_state.push(stack.element)) HashPoint.of(bank_state.push(stack.element))
) )
else:
raise TypeError
def initial(self, factory: RainbowFactory[BankState]) -> HashPoint[BankState]: def initial(self, factory: RainbowFactory[BankState]) -> HashPoint[BankState]:
assert isinstance(factory, RainbowFactory) assert isinstance(factory, RainbowFactory)

13
rainbowadn/v13/bankstate.py
View File

@ -10,7 +10,6 @@ from rainbowadn.data.collection.trees.comparison.hashcomparator import HashCompa
from rainbowadn.hashing.hash_point_format import tabulate from rainbowadn.hashing.hash_point_format import tabulate
from rainbowadn.hashing.hashpoint import HashPoint from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.hashresolver import HashResolver from rainbowadn.hashing.hashresolver import HashResolver
from rainbowadn.hashing.nullability.notnull import NotNull
from rainbowadn.hashing.nullability.null import Null from rainbowadn.hashing.nullability.null import Null
from rainbowadn.hashing.nullability.nullable import Nullable from rainbowadn.hashing.nullability.nullable import Nullable
from rainbowadn.hashing.nullability.nullablereference import NullableReference, NullableReferenceFactory from rainbowadn.hashing.nullability.nullablereference import NullableReference, NullableReferenceFactory
@ -96,12 +95,10 @@ class BankState(RecursiveMentionable, StaticMentionable):
miner: Nullable[HashPoint[Subject]] = self.miner.reference miner: Nullable[HashPoint[Subject]] = self.miner.reference
assert isinstance(miner, Nullable) assert isinstance(miner, Nullable)
if isinstance(miner, Null): if miner.null():
mint = MINT_CONST mint = MINT_CONST
elif isinstance(miner, NotNull):
mint = 0
else: else:
raise TypeError mint = 0
assert transaction_resolved.verify(mint) assert transaction_resolved.verify(mint)
transaction_data: TransactionData = transaction_resolved.data.resolve() transaction_data: TransactionData = transaction_resolved.data.resolve()
@ -119,8 +116,8 @@ class BankState(RecursiveMentionable, StaticMentionable):
in_coin: HashPoint[Coin] in_coin: HashPoint[Coin]
for in_coin in transaction_data.iter_in_coins(): for in_coin in transaction_data.iter_in_coins():
assert isinstance(in_coin, HashPoint) assert isinstance(in_coin, HashPoint)
assert isinstance(minted.query_tree().query(in_coin), NotNull) assert not minted.query_tree().query(in_coin).null()
assert isinstance(used.query_tree().query(in_coin), Null) assert used.query_tree().query(in_coin).null()
used = used.add(in_coin) used = used.add(in_coin)
assert isinstance(used, ActiveBinaryTree) assert isinstance(used, ActiveBinaryTree)
@ -128,7 +125,7 @@ class BankState(RecursiveMentionable, StaticMentionable):
for coin, miner in transaction_resolved.iter_coins(mint, miner): for coin, miner in transaction_resolved.iter_coins(mint, miner):
assert isinstance(coin, Coin) assert isinstance(coin, Coin)
assert isinstance(miner, Nullable) assert isinstance(miner, Nullable)
assert isinstance(minted.query_tree().query(HashPoint.of(coin)), Null) assert minted.query_tree().query(HashPoint.of(coin)).null()
minted = minted.add(HashPoint.of(coin)) minted = minted.add(HashPoint.of(coin))
assert isinstance(minted, ActiveBinaryTree) assert isinstance(minted, ActiveBinaryTree)

33
rainbowadn/v13/transaction.py
View File

@ -8,7 +8,6 @@ from rainbowadn.hashing.hash_point_format import hash_point_format, tabulate
from rainbowadn.hashing.hashpoint import HashPoint from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.hashresolver import HashResolver from rainbowadn.hashing.hashresolver import HashResolver
from rainbowadn.hashing.nullability.notnull import NotNull from rainbowadn.hashing.nullability.notnull import NotNull
from rainbowadn.hashing.nullability.null import Null
from rainbowadn.hashing.nullability.nullable import Nullable from rainbowadn.hashing.nullability.nullable import Nullable
from rainbowadn.hashing.nullability.nullablereference import NullableReference, NullableReferenceFactory from rainbowadn.hashing.nullability.nullablereference import NullableReference, NullableReferenceFactory
from rainbowadn.hashing.rainbow_factory import RainbowFactory from rainbowadn.hashing.rainbow_factory import RainbowFactory
@ -143,14 +142,14 @@ class TransactionData(RecursiveMentionable, StaticMentionable):
) -> bool: ) -> bool:
assert isinstance(in_coins, NullableReference) assert isinstance(in_coins, NullableReference)
assert isinstance(signatures, NullableReference) assert isinstance(signatures, NullableReference)
if isinstance(in_coins.reference, Null): if in_coins.reference.null():
assert isinstance(signatures.reference, Null) assert signatures.reference.null()
return True return True
elif isinstance(in_coins.reference, NotNull): else:
assert isinstance(signatures.reference, NotNull) assert not signatures.reference.null()
in_coins_stack: Stack[Coin] = in_coins.reference.value.resolve() in_coins_stack: Stack[Coin] = in_coins.reference.resolve().resolve()
assert isinstance(in_coins_stack, Stack) assert isinstance(in_coins_stack, Stack)
signatures_stack: Stack[Signature] = signatures.reference.value.resolve() signatures_stack: Stack[Signature] = signatures.reference.resolve().resolve()
assert isinstance(signatures_stack, Stack) assert isinstance(signatures_stack, Stack)
coin: Coin = in_coins_stack.element.resolve() coin: Coin = in_coins_stack.element.resolve()
assert isinstance(coin, Coin) assert isinstance(coin, Coin)
@ -164,21 +163,19 @@ class TransactionData(RecursiveMentionable, StaticMentionable):
owner, owner,
self.hash_point self.hash_point
) )
else:
raise TypeError
def iter_in_coins(self) -> Iterable[HashPoint[Coin]]: def iter_in_coins(self) -> Iterable[HashPoint[Coin]]:
in_coins: NullableReference[Stack[Coin]] = self.in_coins in_coins: NullableReference[Stack[Coin]] = self.in_coins
assert isinstance(in_coins, NullableReference) assert isinstance(in_coins, NullableReference)
while isinstance(in_coins.reference, NotNull): while not in_coins.reference.null():
in_coins_stack: Stack[Coin] = in_coins.reference.value.resolve() in_coins_stack: Stack[Coin] = in_coins.reference.resolve().resolve()
assert isinstance(in_coins_stack, Stack) assert isinstance(in_coins_stack, Stack)
coin: HashPoint[Coin] = in_coins_stack.element coin: HashPoint[Coin] = in_coins_stack.element
assert isinstance(coin, HashPoint) assert isinstance(coin, HashPoint)
yield coin yield coin
in_coins = in_coins_stack.previous in_coins = in_coins_stack.previous
assert isinstance(in_coins, NullableReference) assert isinstance(in_coins, NullableReference)
assert isinstance(in_coins.reference, Null) assert in_coins.reference.null()
def _total_in(self) -> int: def _total_in(self) -> int:
total_in = 0 total_in = 0
@ -191,15 +188,15 @@ class TransactionData(RecursiveMentionable, StaticMentionable):
def iter_out_coins(self) -> Iterable[HashPoint[CoinData]]: def iter_out_coins(self) -> Iterable[HashPoint[CoinData]]:
out_coins: NullableReference[Stack[CoinData]] = self.out_coins out_coins: NullableReference[Stack[CoinData]] = self.out_coins
assert isinstance(out_coins, NullableReference) assert isinstance(out_coins, NullableReference)
while isinstance(out_coins.reference, NotNull): while not out_coins.reference.null():
out_coins_stack: Stack[CoinData] = out_coins.reference.value.resolve() out_coins_stack: Stack[CoinData] = out_coins.reference.resolve().resolve()
assert isinstance(out_coins_stack, Stack) assert isinstance(out_coins_stack, Stack)
coin: HashPoint[CoinData] = out_coins_stack.element coin: HashPoint[CoinData] = out_coins_stack.element
assert isinstance(coin, HashPoint) assert isinstance(coin, HashPoint)
yield coin yield coin
out_coins = out_coins_stack.previous out_coins = out_coins_stack.previous
assert isinstance(out_coins, NullableReference) assert isinstance(out_coins, NullableReference)
assert isinstance(out_coins.reference, Null) assert out_coins.reference.null()
def _total_out(self) -> int: def _total_out(self) -> int:
total_out = 0 total_out = 0
@ -278,18 +275,18 @@ class Transaction(RecursiveMentionable, StaticMentionable):
out_coin: HashPoint[CoinData] out_coin: HashPoint[CoinData]
for out_coin in transaction_data.iter_out_coins(): for out_coin in transaction_data.iter_out_coins():
assert isinstance(out_coin, HashPoint) assert isinstance(out_coin, HashPoint)
if isinstance(miner, Null): if miner.null():
miner = NotNull(out_coin.resolve().owner) miner = NotNull(out_coin.resolve().owner)
assert isinstance(miner, Nullable) assert isinstance(miner, Nullable)
coin: Coin = Coin(out_coin, self.hash_point, HashPoint.of(Integer(index))) coin: Coin = Coin(out_coin, self.hash_point, HashPoint.of(Integer(index)))
assert isinstance(coin, Coin) assert isinstance(coin, Coin)
yield coin, miner yield coin, miner
index += 1 index += 1
if isinstance(miner, NotNull): if not miner.null():
coin: Coin = Coin( coin: Coin = Coin(
HashPoint.of( HashPoint.of(
CoinData( CoinData(
miner.value, miner.resolve(),
HashPoint.of(Integer(transaction_data.extra(mint))) HashPoint.of(Integer(transaction_data.extra(mint)))
) )
), ),

4
rainbowadn/wrisbt/wrisbtprotocol.py
View File

@ -1,6 +1,6 @@
from typing import TypeVar from typing import TypeVar
from rainbowadn.chain.states.activestateprotocol import ActiveStateProtocol from rainbowadn.chain.states.metareductionstateprotocol import MetaReductionStateProtocol
from rainbowadn.hashing.hashpoint import HashPoint from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.wrisbt.wrisbtindex import WrisbtIndex from rainbowadn.wrisbt.wrisbtindex import WrisbtIndex
from rainbowadn.wrisbt.wrisbtparametres import WrisbtParametres from rainbowadn.wrisbt.wrisbtparametres import WrisbtParametres
@ -11,7 +11,7 @@ __all__ = ('WrisbtProtocol',)
TargetType = TypeVar('TargetType') TargetType = TypeVar('TargetType')
class WrisbtProtocol(ActiveStateProtocol[TargetType, WrisbtIndex]): class WrisbtProtocol(MetaReductionStateProtocol[TargetType, WrisbtIndex]):
def __init__(self, keymin: int): def __init__(self, keymin: int):
assert isinstance(keymin, int) assert isinstance(keymin, int)
assert keymin >= 2 assert keymin >= 2