def test_state_tx(self):
ms = MemoryStream(binascii.unhexlify(self.sttx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
# the net_fee calculation in short is : net_fee = inputs - outputs -system fee.
# For this test to be able to grab the input values we need to make the TX that it references available for this test
ms2 = MemoryStream(binascii.unhexlify(
b'80000001def3ab1c73a13e80fea34ca751c79fe8dcf68d93d91d4956818baf0b99d95818010002e72d286979ee6cb1b7e65dfddfb2e384100b8d148e7758de42e4168b71792c6000e8764817000000faaa0f339e0fb33f91697cbf5aac41d17921222ae72d286979ee6cb1b7e65dfddfb2e384100b8d148e7758de42e4168b71792c60008997b2270000002d9a070d388aa24d9f639bc8ddf985dc473c75d70141401a07d186fdfe3f9862c873d7cd9bdcb9cc8b3f5edcf853af31addcc4476d7d4fe89385cc955a4f604c667110332c14cb2fd8f62a29569b01a572774c7f7136572321026aeca2aed2094e9622a44cf584c694554f10cdb84d4f8eeab3e28ead4e87c168ac'))
reader2 = BinaryReader(ms2)
vout_tx = Transaction.DeserializeFrom(reader2)
self.assertEqual(tx.ToArray(), self.sttx)
self.assertEqual(tx.Hash.ToBytes(), self.sttx_id)
with patch('neo.Core.Blockchain.Blockchain.GetTransaction', return_value=(vout_tx, 0)):
json = tx.ToJson()
self.assertEqual(json['size'], 191)
self.assertEqual(json['type'], "StateTransaction")
self.assertEqual(json['version'], 0)
self.assertEqual(len(json['attributes']), 0)
self.assertEqual(len(json['vout']), 0)
self.assertEqual(len(json['vin']), 1)
self.assertEqual(json['sys_fee'], "1000")
self.assertEqual(json['net_fee'], "0")
descriptors = json['descriptors'][0]
self.assertEqual(descriptors['type'], "Validator")
self.assertEqual(descriptors['key'], "025bdf3f181f53e9696227843950deb72dcd374ded17c057159513c3d0abe20b64")
self.assertEqual(descriptors['field'], "Registered")
self.assertEqual(descriptors['value'], "01")
def test_tx_deserialize(self):
ms = MemoryStream(self.tx_raw_hex)
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(type(tx), MinerTransaction )
self.assertEqual(tx.Hash.ToBytes(), self.tx_id)
self.assertEqual(tx.Nonce, self.tx_nonce)
self.assertEqual(tx.inputs, [])
self.assertEqual(tx.outputs, [])
self.assertEqual(tx.scripts, [])
ms = MemoryStream()
writer = BinaryWriter(ms)
tx.Serialize(writer)
out = ms.ToArray()
self.assertEqual(out, self.tx_raw)
json = tx.ToJson()
self.assertEqual(json['nonce'], self.tx_nonce)
def get_tx_data(tx):
ms = MemoryStream()
w = BinaryWriter(ms)
tx.SerializeUnsigned(w)
ms.flush()
tx_data = ms.ToArray().decode()
return tx_data
def FromJson(jsn, isMultiSig=True):
try:
parsed = json.loads(jsn)
if parsed['type'] == 'Neo.Core.ContractTransaction':
verifiable = ContractTransaction()
ms = MemoryStream(binascii.unhexlify(parsed['hex']))
r = BinaryReader(ms)
verifiable.DeserializeUnsigned(r)
context = ContractParametersContext(verifiable,
isMultiSig=isMultiSig)
for key, value in parsed['items'].items():
if "0x" in key:
key = key[2:]
key = key.encode()
parameterbytes = []
for pt in value['parameters']:
if pt['type'] == 'Signature':
parameterbytes.append(0)
contract = Contract.Create(value['script'], parameterbytes,
key)
context.ContextItems[key] = ContextItem(contract)
if 'signatures' in value:
context.ContextItems[key].Signatures = value[
'signatures']
return context
else:
raise ("Unsupported transaction type in JSON")
except Exception as e:
logger.error(
"Failed to import ContractParametersContext from JSON: {}".
format(e))
def AddSignature(self, contract, pubkey, signature):
if contract.Type == ContractType.MultiSigContract:
item = self.CreateItem(contract)
if item is None:
return False
for p in item.ContractParameters:
if p.Value is not None:
return False
if item.Signatures is None:
item.Signatures = {}
elif pubkey.encode_point(True) in item.Signatures:
return False
ecdsa = ECDSA.secp256r1()
points = []
temp = binascii.unhexlify(contract.Script)
ms = MemoryStream(binascii.unhexlify(contract.Script))
reader = BinaryReader(ms)
numr = reader.ReadUInt8()
while reader.ReadUInt8() == 33:
ecpoint = ecdsa.ec.decode_from_hex(
binascii.hexlify(reader.ReadBytes(33)).decode())
points.append(ecpoint)
ms.close()
if pubkey not in points:
return False
item.Signatures[pubkey.encode_point(
True).decode()] = binascii.hexlify(signature)
if len(item.Signatures) == len(contract.ParameterList):
i = 0
points.sort(reverse=True)
for k in points:
pubkey = k.encode_point(True).decode()
if pubkey in item.Signatures:
if self.Add(contract, i,
item.Signatures[pubkey]) is None:
raise Exception("Invalid operation")
i += 1
item.Signatures = None
return True
else:
index = -1
if contract.ParameterList == '00':
contract.ParameterList = b'\x00'
length = len(contract.ParameterList)
for i in range(0, length):
if ContractParameterType(contract.ParameterList[i]
) == ContractParameterType.Signature:
if index >= 0:
raise Exception("Signature must be first")
else:
index = i
return self.Add(contract, index, signature)
def test_yet_another_tx(self):
ms = MemoryStream(binascii.unhexlify(self.yatx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.yatx)
self.assertEqual(tx.Hash.ToBytes(), self.yatx_id)
def test_miner_tx(self):
ms = MemoryStream(binascii.unhexlify(self.mr))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.Nonce, self.mrn)
self.assertEqual(tx.ToArray(), self.mr)
self.assertEqual(tx.Hash.ToBytes(), self.mrh)
def test_contract_tx_again(self):
ms = MemoryStream(binascii.unhexlify(self.cr))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.cr)
self.assertEqual(tx.Hash.ToBytes(), self.crid)
def ToArray( value ):
ms = MemoryStream()
writer = BinaryWriter(ms)
value.Serialize(writer)
ms.flush()
return ms.ToArray()
def test_invocation_transaction(self):
ms = MemoryStream(binascii.unhexlify(self.ir))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.ir)
self.assertEqual(tx.Hash.ToBytes(), self.ir_id)
def test_pub_two(self):
ms = MemoryStream(binascii.unhexlify(self.p2))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.p2)
self.assertEqual(tx.Hash.ToBytes(), self.p2id)
def test_enrollment_tx(self):
ms = MemoryStream(binascii.unhexlify(self.eraw))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.eraw)
self.assertEqual(tx.Hash.ToBytes(), self.eid)
def Trim(self):
ms = MemoryStream()
writer = BinaryWriter(ms)
self.SerializeUnsigned(writer)
writer.WriteByte(1)
self.Script.serialize(writer)
writer.WriteSerializableArray([tx.Hash() for tx in self.Transactions])
ms.flush()
return ms.ToArray()
def test_enrollment_tx(self):
ms = MemoryStream(binascii.unhexlify(self.eraw))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.eraw)
self.assertEqual(tx.Hash.ToBytes(), self.eid)
self.assertEqual(
Fixed8.FromDecimal(settings.ALL_FEES['EnrollmentTransaction']),
tx.SystemFee())
def test_GetScriptHashesForVerifying_neo_gas(self):
# test a raw tx using neo
ms = MemoryStream(binascii.unhexlify(self.ntx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
tx.raw_tx = True
res = tx.GetScriptHashesForVerifying()
self.assertTrue(type(res), list)
# test a raw tx using gas
ms = MemoryStream(binascii.unhexlify(self.gtx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
tx.raw_tx = True
res = tx.GetScriptHashesForVerifying()
self.assertTrue(type(res), list)
def GetHashData(self):
"""
Get the hashable data.
Returns:
bytes:
"""
ms = MemoryStream()
w = BinaryWriter(ms)
self.SerializeUnsigned(w)
ms.flush()
return ms.ToArray()
def test_GetScriptHashesForVerifying_invalid_operation(self):
# test a normal tx with a bad assetId
ms = MemoryStream(binascii.unhexlify(self.rtx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
with self.assertRaises(Exception) as e:
tx.GetScriptHashesForVerifying()
self.assertTrue("Invalid operation" in str(e.exception))
# test a raw tx with a bad assetId
ms = MemoryStream(binascii.unhexlify(self.rtx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
tx.raw_tx = True
with self.assertRaises(Exception) as e:
tx.GetScriptHashesForVerifying()
self.assertTrue("Invalid operation" in str(e.exception))
def test_contract_tx_deserialize(self):
ms = MemoryStream(binascii.unhexlify(self.ctx_raw))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.ctx_raw)
self.assertEqual(tx.Hash.ToBytes(), self.ctx_id)
json = tx.ToJson()
self.assertEqual(json['size'], 605)
self.assertEqual(json['type'], 'ContractTransaction')
def test_pub_two(self):
ms = MemoryStream(binascii.unhexlify(self.p2))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.p2)
self.assertEqual(tx.Hash.ToBytes(), self.p2id)
json = tx.ToJson()
self.assertEqual(json['size'], 402)
self.assertEqual(json['type'], 'PublishTransaction')
def test_register_tx(self):
ms = MemoryStream(binascii.unhexlify(self.rr))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(self.rrid, tx.Hash.ToBytes())
json = tx.ToJson()
asset = json['asset']
self.assertEqual(asset['admin'], 'ARFe4mTKRTETerRoMsyzBXoPt2EKBvBXFX')
self.assertEqual(asset['name'], '[{"lang":"zh-CN","name":"TestCoin"}]')
self.assertEqual(asset['precision'], 8)
def FromTrimmedData(bytes, index, transaction_method):
block = Block()
ms = MemoryStream()
reader = BinaryReader(ms)
block.DeserializeUnsigned(reader)
reader.ReadByte()
block.Script = reader.ReadSerializableArray('neo.Core.Witness.Witness')
block.Transactions = []
for i in range(0, reader.ReadVarInt()):
tx = Transaction.DeserializeFrom(reader)
block.Transactions.append(tx)
return block
def test_message_serialization(self):
message = Message('version', payload=self.payload)
self.assertEqual(message.Command, 'version')
ms = MemoryStream()
writer = BinaryWriter(ms)
message.Serialize(writer)
ms.flush()
result = binascii.unhexlify(ms.ToArray())
ms = MemoryStream(result)
reader = BinaryReader(ms)
deserialized_message = Message()
deserialized_message.Deserialize(reader)
dm = deserialized_message
self.assertEqual(dm.Command, 'version')
self.assertEqual(dm.Magic, Settings.MAGIC)
checksum = Message.GetChecksum(dm.Payload)
self.assertEqual(checksum, dm.Checksum)
deserialized_version = IOHelper.AsSerializableWithType(
dm.Payload, 'neo.Network.Payloads.VersionPayload.VersionPayload')
self.assertEqual(deserialized_version.Port, self.port)
self.assertEqual(deserialized_version.UserAgent, self.ua)
self.assertEqual(deserialized_version.Timestamp,
self.payload.Timestamp)
def FromTrimmedData(data, index):
header = Header()
ms = MemoryStream(data)
reader = BinaryReader(ms)
header.DeserializeUnsigned(reader)
reader.ReadByte()
witness = Witness()
witness.Deserialize(reader)
header.Script = witness
return header
def test_verify_exceeds_max_tx_size(self):
ms = MemoryStream(binascii.unhexlify(self.vvtx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
tx._network_fee = Fixed8.FromDecimal(0.001)
self.assertEqual(tx.ToArray(), self.vvtx)
self.assertEqual(tx.Hash.ToBytes(), self.vvtx_id)
snapshot = GetBlockchain()._db.createSnapshot()
with patch("neo.Core.TX.Transaction.Transaction.Size", return_value=(Transaction.MAX_TX_SIZE + 1)):
res = tx.Verify(snapshot, [tx])
self.assertFalse(res)
tx_size = tx.Size()
self.assertGreater(tx_size, Transaction.MAX_TX_SIZE)
def test_verify_claim_tx_high_priority(self):
ms = MemoryStream(binascii.unhexlify(self.cltx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.cltx)
self.assertEqual(tx.Hash.ToBytes(), self.cltx_id)
snapshot = GetBlockchain()._db.createSnapshot()
with patch("neo.Core.TX.Transaction.Transaction.Size", return_value=(settings.MAX_FREE_TX_SIZE + 1)):
with patch('neo.SmartContract.Helper.Helper.VerifyWitnesses', return_value=True): # we are not testing VerifyScripts
with patch('neo.Core.Blockchain.Blockchain.CalculateBonusIgnoreClaimed', return_value=Fixed8.FromDecimal(0.30551243)):
res = tx.Verify(snapshot, [tx])
self.assertTrue(res)
tx_size = tx.Size()
self.assertGreater(tx_size, settings.MAX_FREE_TX_SIZE)
def ToJson(self):
jsn = {}
jsn['type'] = 'Neo.Core.ContractTransaction' # Verifiable.GetType().FullName
ms = MemoryStream()
w = BinaryWriter(ms)
self.Verifiable.SerializeUnsigned(w)
ms.flush()
jsn['hex'] = ms.ToArray().decode()
jsn['items'] = {}
for key, value in self.ContextItems.items():
if type(key) == str:
shkey = "0x{}".format(key)
else:
shkey = "0x{}".format(key.decode())
jsn['items'][shkey] = value.ToJson()
return jsn
def test_GetScriptHashesForVerifying_DutyFlag(self):
# test a raw tx
ms = MemoryStream(binascii.unhexlify(self.rtx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
tx.raw_tx = True
# create the mocked asset
mock_asset = AssetState()
mock_asset.AssetType = 0x80
snapshot = GetBlockchain()._db.createSnapshot()
with patch("neo.Core.Helper.Helper.StaticAssetState", return_value=mock_asset):
res = tx.GetScriptHashesForVerifying(snapshot)
self.assertTrue(type(res), list)
self.assertEqual(res[0], Helper.AddrStrToScriptHash("AJQ6FoaSXDFzA6wLnyZ1nFN7SGSN2oNTc3"))
def ImportFromArray(self, raw_tx):
"""
Import a raw transaction from an array.
Args:
raw_tx: (bytes) the raw transaction array
"""
if not isinstance(raw_tx, bytes):
raise TypeError('Please input a byte array.')
try:
raw_tx = binascii.unhexlify(raw_tx)
ms = MemoryStream(raw_tx)
reader = BinaryReader(ms)
self.DeserializeFrom(reader)
except Exception as e:
raise FormatError(
f'Unable to import raw transaction.\nError output: {e}')
def test_publish_tx_deserialize(self):
ms = MemoryStream(binascii.unhexlify(self.pb_raw))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.pb_raw)
self.assertEqual(tx.Hash.ToBytes(), self.pb_hash)
json = tx.ToJson()
contract = json['contract']
self.assertEqual(contract['author'], 'Erik Zhang')
self.assertEqual(contract['description'], 'Lock your assets until a timestamp.')
self.assertEqual(contract['code']['hash'], 'ffbd1a7ad1e2348b6b3822426f364bfb4bcce3b9')
self.assertEqual(contract['code']['returntype'], 1)
self.assertEqual(contract['code']['parameters'], '020500')
def test_claim_tx(self):
ms = MemoryStream(binascii.unhexlify(self.cltx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.cltx)
self.assertEqual(tx.Hash.ToBytes(), self.cltx_id)
json = tx.ToJson()
self.assertEqual(json['size'], 577)
self.assertEqual(json['type'], "ClaimTransaction")
self.assertEqual(json['version'], 0)
self.assertEqual(len(json['attributes']), 0)
self.assertEqual(len(json['vout']), 1)
self.assertEqual(len(json['vin']), 0)
self.assertEqual(json['sys_fee'], "0")
self.assertEqual(json['net_fee'], "0")
self.assertEqual(len(json['claims']), 12)