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), ])