def test_trx_vote_witness(self, app):
tx = app.packContract(
tron.Transaction.Contract.VoteWitnessContract,
contract.VoteWitnessContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
votes=[
contract.VoteWitnessContract.Vote(
vote_address=bytes.fromhex(app.address_hex("TKSXDA8HfE9E1y39RczVQ1ZascUEtaSToF")),
vote_count=100
),
contract.VoteWitnessContract.Vote(
vote_address=bytes.fromhex(app.address_hex("TE7hnUtWRRBz3SkFrX8JESWUmEvxxAhoPt")),
vote_count=100
),
contract.VoteWitnessContract.Vote(
vote_address=bytes.fromhex(app.address_hex("TTcYhypP8m4phDhN6oRexz2174zAerjEWP")),
vote_count=100
),
contract.VoteWitnessContract.Vote(
vote_address=bytes.fromhex(app.address_hex("TY65QiDt4hLTMpf3WRzcX357BnmdxT2sw9")),
vote_count=100
),
]
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_trx_withdraw_balance(self, app):
tx = app.packContract(
tron.Transaction.Contract.WithdrawBalanceContract,
contract.WithdrawBalanceContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex'])
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_trx_proposal_delete(self, app):
tx = app.packContract(
tron.Transaction.Contract.ProposalDeleteContract,
contract.ProposalDeleteContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
proposal_id=10,
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_trx_send_wrong_path(self, app):
tx = app.packContract(
tron.Transaction.Contract.TransferContract,
contract.TransferContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
to_address=bytes.fromhex(app.getAccount(0)['addressHex']),
amount=100000000
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == False)
def test_trx_account_update(self, app):
tx = app.packContract(
tron.Transaction.Contract.AccountUpdateContract,
contract.AccountUpdateContract(
account_name=b'CryptoChainTest',
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_vs_proposal_create(self, app):
tx = app.packContract(
vision.Transaction.Contract.ProposalCreateContract,
contract.ProposalCreateContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
parameters={1: 100000, 2: 400000}
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_trx_unfreeze_balance_bw(self, app):
tx = app.packContract(
tron.Transaction.Contract.UnfreezeBalanceContract,
contract.UnfreezeBalanceContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
resource=contract.BANDWIDTH,
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_trx_send_with_data_field(self, app):
tx = app.packContract(
tron.Transaction.Contract.TransferContract,
contract.TransferContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
to_address=bytes.fromhex(app.getAccount(0)['addressHex']),
amount=100000000
),
b'CryptoChain-TronSR Ledger Transactions Tests'
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_trx_trc20_approve(self, app):
tx = app.packContract(
tron.Transaction.Contract.TriggerSmartContract,
contract.TriggerSmartContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
contract_address=bytes.fromhex(app.address_hex("TBoTZcARzWVgnNuB9SyE3S5g1RwsXoQL16")),
data=bytes.fromhex("095ea7b3000000000000000000000000364b03e0815687edaf90b81ff58e496dea7383d700000000000000000000000000000000000000000000000000000000000f4240")
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_trx_unknown_trc20_send(self, app):
tx = app.packContract(
tron.Transaction.Contract.TriggerSmartContract,
contract.TriggerSmartContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
contract_address=bytes.fromhex(app.address_hex("TVGLX58e3uBx1fmmwLCENkrgKqmpEjhtfG")),
data=bytes.fromhex("a9059cbb000000000000000000000000364b03e0815687edaf90b81ff58e496dea7383d700000000000000000000000000000000000000000000000000000000000f4240")
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def createaccount(self, from_address, account_address, ac_type):
"""
创建账户
:return: account 对象
"""
accontract = Contract_pb2.AccountCreateContract()
accontract.owner_address = from_address.encode()
accontract.account_address = account_address.encode()
accontract.tpye = Tron_pb2.AccountType()
with grpc.insecure_channel('localhost:50051') as channel:
stub = api_pb2_grpc.WalletStub(channel)
response = stub.CreateAccount2(accontract)
return response
def test_trx_send_asset_without_name(self, app):
tx = app.packContract(
tron.Transaction.Contract.TransferAssetContract,
contract.TransferAssetContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
to_address=bytes.fromhex(app.getAccount(0)['addressHex']),
amount=1000000,
asset_name="1002000".encode()
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_vs_unfreeze_balance_delegate_entropy(self, app):
tx = app.packContract(
vision.Transaction.Contract.UnfreezeBalanceContract,
contract.UnfreezeBalanceContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
resource=contract.ENTROPY,
receiver_address=bytes.fromhex(app.getAccount(1)['addressHex']),
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_trx_freeze_balance_energy(self, app):
tx = app.packContract(
tron.Transaction.Contract.FreezeBalanceContract,
contract.FreezeBalanceContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
frozen_balance=10000000000,
frozen_duration=3,
resource=contract.ENERGY
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_trx_exchange_withdraw(self, app):
tx = app.packContract(
tron.Transaction.Contract.ExchangeWithdrawContract,
contract.ExchangeWithdrawContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
exchange_id=6,
token_id="1000166".encode(),
quant=1000000
)
)
exchangeSignature = ["08061207313030303136361a0b43727970746f436861696e20002a015f3203545258380642473045022100fe276f30a63173b2440991affbbdc5d6d2d22b61b306b24e535a2fb866518d9c02205f7f41254201131382ec6c8b3c78276a2bb136f910b9a1f37bfde192fc448793"]
data, status = app.sign(app.getAccount(0)['path'], tx, exchangeSignature)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_trx_exchange_create(self, app):
tx = app.packContract(
tron.Transaction.Contract.ExchangeCreateContract,
contract.ExchangeCreateContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
first_token_id="_".encode(),
first_token_balance=10000000000,
second_token_id="1000166".encode(),
second_token_balance=10000000
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_vs_send_permissioned(self, app):
tx = app.packContract(
vision.Transaction.Contract.TransferContract,
contract.TransferContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
to_address=bytes.fromhex(app.getAccount(0)['addressHex']),
amount=100000000
),
None,
2
)
data, status = app.sign(app.getAccount(0)['path'], tx)
assert(status == 0x9000)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_trx_send_asset_with_name(self, app):
tx = app.packContract(
tron.Transaction.Contract.TransferAssetContract,
contract.TransferAssetContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
to_address=bytes.fromhex(app.getAccount(0)['addressHex']),
amount=1000000,
asset_name="1002000".encode()
)
)
# BTT token ID 1002000 - 6 decimals
tokenSignature = ["0a0a426974546f7272656e7410061a46304402202e2502f36b00e57be785fc79ec4043abcdd4fdd1b58d737ce123599dffad2cb602201702c307f009d014a553503b499591558b3634ceee4c054c61cedd8aca94c02b"]
data, status = app.sign(app.getAccount(0)['path'], tx, tokenSignature)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_trx_send_asset_with_name_wrong_signature(self, app):
tx = app.packContract(
tron.Transaction.Contract.TransferAssetContract,
contract.TransferAssetContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
to_address=bytes.fromhex(app.getAccount(0)['addressHex']),
amount=1000000,
asset_name="1002000".encode()
)
)
# BTT token ID 1002000 - 6 decimals
tokenSignature = ["0a0a4e6577416765436f696e10001a473045022100d8d73b4fad5200aa40b5cdbe369172b5c3259c10f1fb17dfb9c3fa6aa934ace702204e7ef9284969c74a0e80b7b7c17e027d671f3a9b3556c05269e15f7ce45986c8"]
data, status = app.sign(app.getAccount(0)['path'], tx, tokenSignature)
# expected fail
assert( status == 0x6800 )
def test_trx_exchange_create_with_token_name(self, app):
tx = app.packContract(
tron.Transaction.Contract.ExchangeCreateContract,
contract.ExchangeCreateContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
first_token_id="_".encode(),
first_token_balance=10000000000,
second_token_id="1000166".encode(),
second_token_balance=10000000
)
)
tokenSignature = ["0a0354525810061a463044022037c53ecb06abe1bfd708bd7afd047720b72e2bfc0a2e4b6ade9a33ae813565a802200a7d5086dc08c4a6f866aad803ac7438942c3c0a6371adcb6992db94487f66c7",
"0a0b43727970746f436861696e10001a4730450221008417d04d1caeae31f591ae50f7d19e53e0dfb827bd51c18e66081941bf04639802203c73361a521c969e3fd7f62e62b46d61aad00e47d41e7da108546d954278a6b1"]
data, status = app.sign(app.getAccount(0)['path'], tx, tokenSignature)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def test_trx_custom_contract(self, app):
tx = app.packContract(
tron.Transaction.Contract.TriggerSmartContract,
contract.TriggerSmartContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
contract_address=bytes.fromhex(app.address_hex("TTg3AAJBYsDNjx5Moc5EPNsgJSa4anJQ3M")),
data=bytes.fromhex('{:08x}{:064x}'.format(
0x0a857040,
int(10001)
))
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
validSignature, txID = validateSignature.validate(tx,data[0:65],app.getAccount(0)['publicKey'][2:])
assert(validSignature == True)
def createtransaction(self, owner_address, to_address, amount):
"""
创建一个转账的交易
:return: 返回转账合约对象
{
"transaction" :
{"txID":"454f156bf1256587ff6ccdbc56e64ad0c51e4f8efea5490dcbc720ee606bc7b8",
"raw_data":
{"contract":
[{"parameter":
{"value":
{"amount":1,
"owner_address":"41235d90e1d0a0ccfa268781f464e0252ba6112993",
"to_address":"41d1e7a6bc354106cb410e65ff8b181c600ff14292"
},
"type_url":"type.googleapis.com/protocol.TransferContract"
},
"type":"TransferContract"
}],
"ref_block_bytes":"267e",
"ref_block_hash":"9a447d222e8de9f2",
"expiration":1530893064000,
"timestamp":1530893006233
}
}
,"privateKey": "your private key"
}
"""
transfer = Contract_pb2.TransferContract()
transfer.owner_address = owner_address.encode()
transfer.to_address = to_address.encode()
transfer.amount = amount
with grpc.insecure_channel('localhost:50051') as channel:
stub = api_pb2_grpc.WalletStub(channel)
response = stub.CreateTransaction2(transfer)
return response
def test_trx_vote_witness_more_than_5(self, app):
tx = app.packContract(
tron.Transaction.Contract.VoteWitnessContract,
contract.VoteWitnessContract(
owner_address=bytes.fromhex(app.getAccount(0)['addressHex']),
votes=[
contract.VoteWitnessContract.Vote(
vote_address=bytes.fromhex(app.address_hex("TKSXDA8HfE9E1y39RczVQ1ZascUEtaSToF")),
vote_count=100
),
contract.VoteWitnessContract.Vote(
vote_address=bytes.fromhex(app.address_hex("TE7hnUtWRRBz3SkFrX8JESWUmEvxxAhoPt")),
vote_count=100
),
contract.VoteWitnessContract.Vote(
vote_address=bytes.fromhex(app.address_hex("TTcYhypP8m4phDhN6oRexz2174zAerjEWP")),
vote_count=100
),
contract.VoteWitnessContract.Vote(
vote_address=bytes.fromhex(app.address_hex("TY65QiDt4hLTMpf3WRzcX357BnmdxT2sw9")),
vote_count=100
),
contract.VoteWitnessContract.Vote(
vote_address=bytes.fromhex(app.address_hex("TSzoLaVCdSNDpNxgChcFt9rSRF5wWAZiR4")),
vote_count=100
),
contract.VoteWitnessContract.Vote(
vote_address=bytes.fromhex(app.address_hex("TSNbzxac4WhxN91XvaUfPTKP2jNT18mP6T")),
vote_count=100
),
]
)
)
data, status = app.sign(app.getAccount(0)['path'], tx)
assert(status == 0x6800)
# check if device have custom contracts enable
result = dongle.exchange(bytearray.fromhex("E0060000FF"))
customAllowed = result[0] & 0x02
if customAllowed == 0:
print("Custom Contract not allowed, test should fail...")
sys.exit(0)
####################
# TWM Deposit TRX #
####################
logger.debug('\n\SmartContract Trigger: Deposit TRX in TWM Contract')
data = '{:08x}'.format(0xd0e30db0)
tx = stub.TriggerContract(
contract.TriggerSmartContract(
owner_address=bytes.fromhex(accounts[1]['addressHex']),
contract_address=bytes.fromhex(
address_hex("TTg3AAJBYsDNjx5Moc5EPNsgJSa4anJQ3M")),
call_value=1000000,
data=bytes.fromhex(data)))
raw_tx, result = ledgerSign(accounts[1]['path'], tx.transaction)
tx.transaction.signature.extend([bytes(result[0:65])])
#r = stub.BroadcastTransaction(tx.transaction)
validSignature, txID = validateSignature.validate(raw_tx, result[0:65],
accounts[1]['publicKey'][2:])
logger.debug('- RAW: {}'.format(raw_tx))
logger.debug('- txID: {}'.format(txID))
logger.debug('- Signature: {}'.format(binascii.hexlify(result[0:65])))
if (validSignature):
logger.debug('- Valid: {}'.format(validSignature))
else:
from core import Vision_pb2 as vision
from google.protobuf.any_pb2 import Any
import grpc
# Start Channel and WalletStub
channel = grpc.insecure_channel("vtest.infragrid.v.network:50051")
stub = WalletStub(channel)
logger.debug('''
Vision MultiSign tests
''')
tx = stub.CreateTransaction2(
contract.TransferContract(
owner_address=bytes.fromhex(
address_hex("VUEZSdKsoDHQMeZwihtdoBiN46zxhGWYdH")),
to_address=bytes.fromhex(
address_hex("VPnYqC2ukKyhEDAjqRRobSVygMAb8nAcXM")),
amount=100000))
# use permission 2
tx.transaction.raw_data.contract[0].Permission_id = 2
raw_tx, sign1 = ledgerSign(parse_bip32_path("44'/195'/0'/0/0"), tx.transaction)
raw_tx, sign2 = ledgerSign(parse_bip32_path("44'/195'/1'/0/0"), tx.transaction)
tx.transaction.signature.extend([bytes(sign1[0:65])])
tx.transaction.signature.extend([bytes(sign2[0:65])])
r = stub.BroadcastTransaction(tx.transaction)
if r.result == True:
print("Success")
# Start Channel and WalletStub
channel = grpc.insecure_channel("vtest.infragrid.v.network:50051")
stub = WalletStub(channel)
logger.debug('''
Vision Transactions tests
''')
############
# Send VS #
############
logger.debug('\n\nTransfer Contract:')
tx = stub.CreateTransaction2(
contract.TransferContract(
owner_address=bytes.fromhex(accounts[1]['addressHex']),
to_address=bytes.fromhex(accounts[0]['addressHex']),
amount=1))
raw_tx, result = ledgerSign(accounts[1]['path'], tx.transaction)
validSignature, txID = validateSignature.validate(raw_tx, result[0:65],
accounts[1]['publicKey'][2:])
logger.debug('- RAW: {}'.format(raw_tx))
logger.debug('- txID: {}'.format(txID))
logger.debug('- Signature: {}'.format(binascii.hexlify(result[0:65])))
if (validSignature):
logger.debug('- Valid: {}'.format(validSignature))
else:
logger.error('- Valid: {}'.format(validSignature))
sys.exit(0)
# Broadcast Example
