def test_big_integer_div(self): b1 = BigInteger(55055055055055) b2 = BigInteger(55055055) b3 = b1 / b2 self.assertIsInstance(b3, BigInteger) self.assertEqual(b3, 1000000)
def test_4(self): fn = FunctionCode(script=b'abcd', param_list=[], return_type='Boolean') self.assertEqual(fn.ReturnType, 1) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(1)) fn = FunctionCode(script=b'abcd', param_list=[], return_type=True) self.assertEqual(fn.ReturnType, 1) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(1)) fn = FunctionCode(script=b'abcd', param_list=[], return_type=1) self.assertEqual(fn.ReturnType, 1) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(1)) fn = FunctionCode(script=b'abcd', param_list=[], return_type='1') self.assertEqual(fn.ReturnType, 1) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(1)) fn = FunctionCode(script=b'abcd', param_list=[], return_type=b'1') self.assertEqual(fn.ReturnType, 1) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(1))
def test_big_integer_frombytes(self): b1 = BigInteger(8972340892734890723) ba = b1.ToByteArray() b2 = BigInteger.FromBytes(ba) self.assertEqual(b1, b2) self.assertTrue(b1.Equals(b2))
def test_3(self): fn = FunctionCode(script=b'abcd', param_list=[], return_type=0) self.assertEqual(fn.ReturnType, 0) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(0)) fn = FunctionCode(script=b'abcd', param_list=[], return_type=False) self.assertEqual(fn.ReturnType, 0) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(0)) fn = FunctionCode(script=b'abcd', param_list=[], return_type='0') self.assertEqual(fn.ReturnType, 0) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(0)) fn = FunctionCode(script=b'abcd', param_list=[], return_type=b'0') self.assertEqual(fn.ReturnType, 0) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(0)) fn = FunctionCode(script=b'abcd', param_list=[], return_type='Signature') self.assertEqual(fn.ReturnType, 0) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(0))
def test_2(self): fn = FunctionCode(script=b'abcd', param_list=[], return_type='ff') self.assertEqual(fn.ReturnType, 255) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(255)) fn = FunctionCode(script=b'abcd', param_list=[], return_type=b'ff') self.assertEqual(fn.ReturnType, 255) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(255)) fn = FunctionCode(script=b'abcd', param_list=[], return_type=bytearray(b'\xff')) self.assertEqual(fn.ReturnType, 255) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(255)) fn = FunctionCode(script=b'abcd', param_list=[], return_type=255) self.assertEqual(fn.ReturnType, 255) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(255)) fn = FunctionCode(script=b'abcd', param_list=[], return_type='Void') self.assertEqual(fn.ReturnType, 255) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(255))
def test_big_integer_float(self): b1 = BigInteger(5505.001) b2 = BigInteger(55055.999) b3 = b1 + b2 self.assertIsInstance(b3, BigInteger) self.assertEqual(b3, 60560)
def test_big_integer_mul(self): b1 = BigInteger(55055055055055) b2 = BigInteger(55055055055) b3 = b1 * b2 self.assertIsInstance(b3, BigInteger) self.assertEqual(b3, 3031059087112109081053025)
def test_big_integer_add(self): b1 = BigInteger(10) b2 = BigInteger(20) b3 = b1 + b2 self.assertIsInstance(b3, BigInteger) self.assertEqual(b3, 30)
def test_big_integer_sub(self): b1 = BigInteger(5505505505505505050505) b2 = BigInteger(5505505505505505000000) b3 = b1 - b2 self.assertIsInstance(b3, BigInteger) self.assertEqual(b3, 50505)
def GetHashCodeBytes(self): """ Get the hash code in bytes. Returns: bytes: """ bigint = BigInteger(self.GetHashCode()) return bigint.ToByteArray()
def test_big_integer_div2(self): b1 = BigInteger(41483775933600000000) b2 = BigInteger(414937759336) b3 = b1 / b2 b4 = b1 // b2 self.assertIsInstance(b3, BigInteger) self.assertEqual(b3, 99975899) self.assertEqual(b4, b3)
def test_negative_shifting(self): # C#'s BigInteger changes a left shift with a negative shift index, # to a right shift with a positive index. b1 = BigInteger(8) b2 = BigInteger(-3) # shift against BigInteger self.assertEqual(1, b1 << b2) # shift against integer self.assertEqual(1, b1 << -3) # the same as above but for right shift self.assertEqual(64, b1 >> b2) self.assertEqual(64, b1 >> -3)
def Blockchain_GetHeader(self, engine: ExecutionEngine): data = engine.CurrentContext.EvaluationStack.Pop().GetByteArray() header = None if len(data) <= 5: height = BigInteger.FromBytes(data) if Blockchain.Default() is not None: header = Blockchain.Default().GetHeaderBy(height_or_hash=height) elif height == 0: header = Blockchain.GenesisBlock().Header elif len(data) == 32: hash = UInt256(data=data) if Blockchain.Default() is not None: header = Blockchain.Default().GetHeaderBy(height_or_hash=hash) elif hash == Blockchain.GenesisBlock().Hash: header = Blockchain.GenesisBlock().Header engine.CurrentContext.EvaluationStack.PushT(StackItem.FromInterface(header)) return True
def GetBigInteger(self): try: b = BigInteger(int.from_bytes(self._value, 'little', signed=True)) return b except Exception as e: pass return self._value
def test_7(self): fn = FunctionCode(script=b'abcd', param_list=[], return_type='String') self.assertEqual(fn.ReturnType, 7) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(7)) fn = FunctionCode(script=b'abcd', param_list=[], return_type='7') self.assertEqual(fn.ReturnType, 7) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(7)) fn = FunctionCode(script=b'abcd', param_list=[], return_type=b'07') self.assertEqual(fn.ReturnType, 7) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(7))
def GatherLoadedContractParams(args, script): if len(args) < 5: raise Exception("please specify contract properties like {needs_storage} {needs_dynamic_invoke} {is_payable} {params} {return_type}") params = parse_param(args[3], ignore_int=True, prefer_hex=False) if type(params) is str: params = params.encode('utf-8') try: for p in binascii.unhexlify(params): if p == ContractParameterType.Void.value: raise ValueError("Void is not a valid input parameter type") except binascii.Error: pass return_type = BigInteger(ContractParameterType.FromString(args[4]).value) needs_storage = bool(parse_param(args[0])) needs_dynamic_invoke = bool(parse_param(args[1])) is_payable = bool(parse_param(args[2])) contract_properties = 0 if needs_storage: contract_properties += ContractPropertyState.HasStorage if needs_dynamic_invoke: contract_properties += ContractPropertyState.HasDynamicInvoke if is_payable: contract_properties += ContractPropertyState.Payable out = generate_deploy_script(script, contract_properties=contract_properties, return_type=return_type, parameter_list=params) return out
def parse_param(p, wallet=None, ignore_int=False, prefer_hex=True, parse_addr=True): # first, we'll try to parse an array try: items = eval(p, {"__builtins__": {'list': list}}, {}) if len(items) > 0 and type(items) is list: parsed = [] for item in items: parsed.append(parse_param(item, wallet, parse_addr=parse_addr)) return parsed except Exception as e: # print("Could not eval items as array %s " % e) pass if not ignore_int: try: val = int(p) out = BigInteger(val) return out except Exception as e: pass try: val = eval(p, {"__builtins__": {'bytearray': bytearray, 'bytes': bytes, 'list': list}}, {}) if type(val) is bytearray: return val elif type(val) is bytes: # try to unhex try: val = binascii.unhexlify(val) except Exception as e: pass # now it should be unhexxed no matter what, and we can hex it return val.hex().encode('utf-8') elif type(val) is bool: return val except Exception as e: pass if type(p) is str: if wallet is not None: for na in wallet.NamedAddr: if na.Title == p: return bytearray(na.ScriptHash) # check for address strings like 'ANE2ECgA6YAHR5Fh2BrSsiqTyGb5KaS19u' and # convert them to a bytearray if parse_addr and len(p) == 34 and p[0] == 'A': addr = Helper.AddrStrToScriptHash(p).Data return addr if prefer_hex: return binascii.hexlify(p.encode('utf-8')) else: return p.encode('utf-8') return p
def TestBuild(script, invoke_args, wallet, plist='05', ret='05', dynamic=False, invoke_attrs=None, owners=None, snapshot=None): properties = ContractPropertyState.HasStorage if dynamic: properties += ContractPropertyState.HasDynamicInvoke if not isinstance(ret, bytearray): ret = bytearray(binascii.unhexlify(str(ret).encode('utf-8'))) script = generate_deploy_script(script, contract_properties=int(properties), parameter_list=plist, return_type=BigInteger.FromBytes(ret)) return test_deploy_and_invoke(script, invoke_args, wallet, invoke_attrs=invoke_attrs, owners=owners, snapshot=snapshot)
def Blockchain_GetBlock(self, engine: ExecutionEngine): data = engine.CurrentContext.EvaluationStack.Pop() if data: data = data.GetByteArray() else: return False block = None if len(data) <= 5: height = BigInteger.FromBytes(data) if Blockchain.Default() is not None: block = Blockchain.Default().GetBlockByHeight(height) elif height == 0: block = Blockchain.GenesisBlock() elif len(data) == 32: hash = UInt256(data=data).ToBytes() if Blockchain.Default() is not None: block = Blockchain.Default().GetBlockByHash(hash=hash) elif hash == Blockchain.GenesisBlock().Hash: block = Blockchain.GenesisBlock().Header engine.CurrentContext.EvaluationStack.PushT(StackItem.FromInterface(block)) return True
def test_5(self): fn = FunctionCode(script=b'abcd', param_list=[], return_type='Array') self.assertEqual(fn.ReturnType, 16) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(16)) fn = FunctionCode(script=b'abcd', param_list=[], return_type='10') self.assertEqual(fn.ReturnType, 16) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(16)) fn = FunctionCode(script=b'abcd', param_list=[], return_type=b'10') self.assertEqual(fn.ReturnType, 16) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(16))
def generate_deploy_script(script, name='test', version='test', author='test', email='test', description='test', contract_properties=0, return_type=BigInteger(255), parameter_list=[]): sb = ScriptBuilder() plist = parameter_list try: plist = bytearray(binascii.unhexlify(parameter_list)) except Exception as e: pass sb.push(binascii.hexlify(description.encode('utf-8'))) sb.push(binascii.hexlify(email.encode('utf-8'))) sb.push(binascii.hexlify(author.encode('utf-8'))) sb.push(binascii.hexlify(version.encode('utf-8'))) sb.push(binascii.hexlify(name.encode('utf-8'))) sb.push(contract_properties) sb.push(return_type) sb.push(plist) sb.WriteVarData(script) sb.EmitSysCall("Neo.Contract.Create") script = sb.ToArray() return script
def test_dunder_methods(self): b1 = BigInteger(1) b2 = BigInteger(2) b3 = BigInteger(3) self.assertEqual(abs(b1), 1) self.assertEqual(b1 % 1, 0) self.assertEqual(-b1, -1) self.assertEqual(str(b1), "1") self.assertEqual(b3 // b2, 1) right_shift = b3 >> b1 self.assertEqual(right_shift, 1) self.assertIsInstance(right_shift, BigInteger) left_shift = b1 << b3 self.assertEqual(left_shift, 8) self.assertIsInstance(left_shift, BigInteger)
def test_1(self): fn = FunctionCode() self.assertEqual(fn.ReturnType, 255) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(255)) self.assertEqual(fn.ParameterList, []) self.assertEqual(fn.HasDynamicInvoke, False) self.assertEqual(fn.HasStorage, False)
def New(value): typ = type(value) if typ is BigInteger: return Integer(value) elif typ is int: return Integer(BigInteger(value)) elif typ is float: return Integer(BigInteger(int(value))) elif typ is bool: return Boolean(value) elif typ is bytearray or typ is bytes: return ByteArray(value) elif typ is list: return Array(value) elif typ is str: return ByteArray(bytearray(value.encode())) # raise TypeError(f"{typ} is an invalid StackItem type") return value
def LoadContract(path, needs_storage, needs_dynamic_invoke, is_payable, params_str, return_type): params = parse_param(params_str, ignore_int=True, prefer_hex=False) if type(params) is str: params = params.encode('utf-8') try: for p in binascii.unhexlify(params): if p == ContractParameterType.Void.value: raise ValueError("Void is not a valid input parameter type") except binascii.Error: pass rtype = BigInteger(ContractParameterType.FromString(return_type).value) contract_properties = 0 if needs_storage: contract_properties += ContractPropertyState.HasStorage if needs_dynamic_invoke: contract_properties += ContractPropertyState.HasDynamicInvoke if is_payable: contract_properties += ContractPropertyState.Payable if '.avm' not in path: raise ValueError("Please load a compiled .avm file") script = None with open(path, 'rb') as f: content = f.read() try: content = binascii.unhexlify(content) except Exception as e: pass script = content if script: try: plist = bytearray(binascii.unhexlify(params)) except Exception as e: plist = bytearray(b'\x10') function_code = FunctionCode(script=script, param_list=bytearray(plist), return_type=rtype, contract_properties=contract_properties) return function_code else: raise Exception(f"Error loading contract for path {path}")
def test_6(self): fn = FunctionCode(script=b'abcd', param_list=[], return_type='ByteArray') self.assertEqual(fn.ReturnType, 5) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(5)) fn = FunctionCode(script=b'abcd', param_list=[], return_type='05') self.assertEqual(fn.ReturnType, 5) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(5)) fn = FunctionCode(script=b'abcd', param_list=[], return_type=b'05') self.assertEqual(fn.ReturnType, 5) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(5)) fn = FunctionCode(script=b'abcd', param_list=[], return_type=5) self.assertEqual(fn.ReturnType, 5) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(5)) fn = FunctionCode(script=b'abcd', param_list=[], return_type='5') self.assertEqual(fn.ReturnType, 5) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(5)) fn = FunctionCode(script=b'abcd', param_list=[], return_type=b'5') self.assertEqual(fn.ReturnType, 5) self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(5))
def ToVM(self): """ Used for turning a ContractParameter item into somethnig consumable by the VM Returns: """ if self.Type == ContractParameterType.String: return str(self.Value).encode('utf-8').hex() elif self.Type == ContractParameterType.Integer and isinstance( self.Value, int): return BigInteger(self.Value) return self.Value
def test_big_integer_sign(self): b1 = BigInteger(3) b2 = BigInteger(0) b3 = BigInteger(-4) self.assertEqual(b1.Sign, 1) self.assertEqual(b2.Sign, 0) self.assertEqual(b3.Sign, -1) c1 = BigInteger(-100) c1_bytes = c1.ToByteArray() c2 = BigInteger.FromBytes(c1_bytes, signed=True) self.assertEqual(c2.Sign, -1) c2_unsigned = BigInteger.FromBytes(c1_bytes, signed=False) self.assertEqual(c2_unsigned.Sign, 1)
def test_big_integer_modulo(self): b1 = BigInteger(860593) b2 = BigInteger(-201) self.assertEqual(112, b1 % b2) b1 = BigInteger(20195283520469175757) b2 = BigInteger(1048576) self.assertEqual(888269, b1 % b2) b1 = BigInteger( -18224909727634776050312394179610579601844989529623334093909233530432892596607 ) b2 = BigInteger(14954691977398614017) self.assertEqual(-3100049211437790421, b1 % b2) b3 = BigInteger.from_bytes(bytearray(b'+K\x05\xbe\xaai\xfa\xd4'), 'little', signed=True) self.assertEqual(b3, b1 % b2)
def DeserializeStackItem(reader): stype = reader.ReadUInt8() if stype == StackItemType.ByteArray: return ByteArray(reader.ReadVarBytes()) elif stype == StackItemType.Boolean: return Boolean(ord(reader.ReadByte())) elif stype == StackItemType.Integer: return Integer( BigInteger.FromBytes(reader.ReadVarBytes(), signed=True)) elif stype == StackItemType.Array: stack_item = Array() count = reader.ReadVarInt() while count > 0: count -= 1 stack_item.Add(StackItem.DeserializeStackItem(reader)) return stack_item elif stype == StackItemType.Struct: stack_item = Struct(value=None) count = reader.ReadVarInt() while count > 0: count -= 1 stack_item.Add(StackItem.DeserializeStackItem(reader)) return stack_item elif stype == StackItemType.Map: stack_item = Map() count = reader.ReadVarInt() while count > 0: count -= 1 key = StackItem.DeserializeStackItem(reader) val = StackItem.DeserializeStackItem(reader) stack_item.SetItem(key, val) return stack_item else: raise ValueError( "Could not deserialize stack item with type: %s " % stype)