def value(self) -> vm.StackItem:
if self._pair is None:
raise ValueError(
"Cannot call 'value' without having advanced the iterator at least once"
)
key = self._pair[0].key
value = self._pair[1].value
if contracts.FindOptions.REMOVE_PREFIX in self.options:
key = key[self.prefix_len:]
if contracts.FindOptions.DESERIALIZE_VALUES in self.options:
item: vm.StackItem = contracts.BinarySerializer.deserialize(
value, 1024, self.reference_counter)
else:
item = vm.ByteStringStackItem(value)
if contracts.FindOptions.PICK_FIELD0 in self.options:
item = cast(vm.ArrayStackItem, item)
item = item[0]
elif contracts.FindOptions.PICK_FIELD1 in self.options:
item = cast(vm.ArrayStackItem, item)
item = item[1]
if contracts.FindOptions.KEYS_ONLY in self.options:
return vm.ByteStringStackItem(key)
if contracts.FindOptions.VALUES_ONLY in self.options:
return vm.ByteStringStackItem(value)
return vm.StructStackItem(self.reference_counter, [
vm.ByteStringStackItem(self._pair[0].key),
vm.ByteStringStackItem(self._pair[1].value)
])
def to_stack_item(self, reference_counter: vm.ReferenceCounter) -> vm.StackItem:
struct = vm.StructStackItem(reference_counter)
struct.append(vm.ByteStringStackItem(self.name))
struct.append(vm.ArrayStackItem(reference_counter,
list(map(lambda g: g.to_stack_item(reference_counter), self.groups)))
)
struct.append(vm.ArrayStackItem(reference_counter,
list(map(lambda s: vm.ByteStringStackItem(s), self.supported_standards)))
)
struct.append(self.abi.to_stack_item(reference_counter))
struct.append(vm.ArrayStackItem(reference_counter,
list(map(lambda p: p.to_stack_item(reference_counter), self.permissions)))
)
if self.trusts.is_wildcard:
struct.append(vm.NullStackItem())
else:
struct.append(
vm.ArrayStackItem(reference_counter,
list(map(lambda t: vm.ByteStringStackItem(t.to_array()),
self.trusts))) # type: ignore
)
if self.extra is None:
struct.append(vm.ByteStringStackItem("null"))
else:
struct.append(vm.ByteStringStackItem(json.dumps(self.extra)))
return struct
def get_candidates(self, engine: contracts.ApplicationEngine) -> None:
array = vm.ArrayStackItem(engine.reference_counter)
for k, v in self._get_candidates(engine.snapshot):
struct = vm.StructStackItem(engine.reference_counter)
struct.append(vm.ByteStringStackItem(k.to_array()))
struct.append(vm.IntegerStackItem(v))
array.append(struct)
engine.push(array)
def test_notify_state_helper_struct(self):
bssi = vm.ByteStringStackItem(b'\x01\x02') # 2
primitive = vm.IntegerStackItem(2) # 1
engine = test_engine()
struct = vm.StructStackItem(engine.reference_counter)
struct.append([bssi, primitive])
self.assertEqual(3, _validate_state_item_limits(engine, struct))
def get_candidates(self, engine: contracts.ApplicationEngine) -> None:
"""
Fetch all registered candidates, convert them to a StackItem and push them onto the evaluation stack.
"""
array = vm.ArrayStackItem(engine.reference_counter)
for k, v in self._get_candidates(engine.snapshot):
struct = vm.StructStackItem(engine.reference_counter)
struct.append(vm.ByteStringStackItem(k.to_array()))
struct.append(vm.IntegerStackItem(v))
array.append(struct)
engine.push(array)
def to_stack_item(self,
reference_counter: vm.ReferenceCounter) -> vm.StackItem:
struct = vm.StructStackItem(reference_counter)
struct.append(vm.ByteStringStackItem(self.name))
array = vm.ArrayStackItem(
reference_counter,
list(
map(lambda p: p.to_stack_item(reference_counter),
self.parameters)))
struct.append(array)
return struct
def test_deserialize_struct(self):
s = vm.StructStackItem(self.reference_counter)
bool1 = vm.BooleanStackItem(True)
bool2 = vm.BooleanStackItem(False)
s.append([bool1, bool2])
s_serialized = contracts.BinarySerializer.serialize(s, 999)
new_s = contracts.BinarySerializer.deserialize(s_serialized, 999,
self.reference_counter)
self.assertIsInstance(new_s, vm.StructStackItem)
for l, r in zip(new_s._items, s._items):
self.assertEqual(l, r)
def to_stack_item(self,
reference_counter: vm.ReferenceCounter) -> vm.StackItem:
struct = vm.StructStackItem(reference_counter)
struct.append(
vm.ArrayStackItem(
reference_counter,
list(
map(lambda m: m.to_stack_item(reference_counter),
self.methods))))
struct.append(
vm.ArrayStackItem(
reference_counter,
list(
map(lambda e: e.to_stack_item(reference_counter),
self.events))))
return struct
def to_stack_item(self, reference_counter: vm.ReferenceCounter) -> vm.StackItem:
struct = vm.StructStackItem(reference_counter)
if self.contract.is_wildcard:
struct.append(vm.NullStackItem())
elif self.contract.is_hash:
struct.append(vm.ByteStringStackItem(self.contract.contract_hash.to_array())) # type: ignore
else:
struct.append(vm.ByteStringStackItem(self.contract.group.to_array())) # type: ignore
if self.methods.is_wildcard:
struct.append(vm.NullStackItem())
else:
struct.append(
vm.ArrayStackItem(reference_counter,
list(map(lambda m: vm.ByteStringStackItem(m), self.methods))) # type: ignore
)
return struct
def to_stack_item(self,
reference_counter: vm.ReferenceCounter) -> vm.StackItem:
struct_ = vm.StructStackItem(reference_counter)
struct_.append(vm.IntegerStackItem(self.balance))
return struct_
def deserialize(data: bytes, max_size: int, max_item_size: int,
reference_counter: vm.ReferenceCounter) -> vm.StackItem:
"""
Deserialize data into a stack item.
Args:
data: byte array of a serialized stack item.
max_size: data reading limit for Array, Struct and Map types.
max_item_size: data reading limit for ByteString or Buffer types.
reference_counter: a valid reference counter instance. Get's passed into reference stack items.
"""
if len(data) == 0:
raise ValueError("Nothing to deserialize")
deserialized: List[Union[vm.StackItem, PlaceHolder]] = []
to_deserialize = 1
with serialization.BinaryReader(data) as reader:
while not to_deserialize == 0:
to_deserialize -= 1
item_type = vm.StackItemType(reader.read_byte()[0])
if item_type == vm.StackItemType.ANY:
deserialized.append(vm.NullStackItem())
elif item_type == vm.StackItemType.BOOLEAN:
deserialized.append(vm.BooleanStackItem(
reader.read_bool()))
elif item_type == vm.StackItemType.INTEGER:
deserialized.append(
vm.IntegerStackItem(
vm.BigInteger(
reader.read_var_bytes(
vm.IntegerStackItem.MAX_SIZE))))
elif item_type == vm.StackItemType.BYTESTRING:
deserialized.append(
vm.ByteStringStackItem(
reader.read_var_bytes(max_item_size)))
elif item_type == vm.StackItemType.BUFFER:
deserialized.append(
vm.BufferStackItem(
reader.read_var_bytes(max_item_size)))
elif item_type in [
vm.StackItemType.ARRAY, vm.StackItemType.STRUCT
]:
count = reader.read_var_int(max_size)
deserialized.append(PlaceHolder(item_type, count))
to_deserialize += count
elif item_type == vm.StackItemType.MAP:
count = reader.read_var_int(max_size)
deserialized.append(PlaceHolder(item_type, count))
to_deserialize += count * 2
else:
raise ValueError("Invalid format")
temp: List[vm.StackItem] = []
while len(deserialized) > 0:
item = deserialized.pop()
if type(item) == PlaceHolder:
item = cast(PlaceHolder, item)
if item.type == vm.StackItemType.ARRAY:
array = vm.ArrayStackItem(reference_counter)
for _ in range(0, item.count):
array.append(temp.pop())
temp.append(array)
elif item.type == vm.StackItemType.STRUCT:
struct = vm.StructStackItem(reference_counter)
for _ in range(0, item.count):
struct.append(temp.pop())
temp.append(struct)
elif item.type == vm.StackItemType.MAP:
m = vm.MapStackItem(reference_counter)
for _ in range(0, item.count):
k = temp.pop()
k = cast(vm.PrimitiveType, k)
v = temp.pop()
m[k] = v
temp.append(m)
else:
item = cast(vm.StackItem, item)
temp.append(item)
return temp.pop()
def value(self) -> vm.StackItem:
if self._value is None:
raise ValueError("Cannot call 'value' without having advanced the iterator at least once")
return vm.StructStackItem(self.reference_counter, [self._key, self._value])
def to_stack_item(self,
reference_counter: vm.ReferenceCounter) -> vm.StackItem:
return vm.StructStackItem(reference_counter, [
vm.ByteStringStackItem(self.name),
vm.IntegerStackItem(self.type.value)
])
def to_stack_item(self,
reference_counter: vm.ReferenceCounter) -> vm.StackItem:
struct = vm.StructStackItem(reference_counter)
struct.append(vm.ByteStringStackItem(self.public_key.to_array()))
struct.append(vm.ByteStringStackItem(self.signature))
return struct
def to_stack_item(self, reference_counter: vm.ReferenceCounter) -> vm.StackItem:
return vm.StructStackItem(reference_counter, [
vm.ByteStringStackItem(self.owner.to_array()),
vm.ByteStringStackItem(self.name),
])
