def __init_debot(self, keypair: KeyPair) -> Tuple[str, str]:
""" Deploy debot and target """
signer = Signer.Keys(keys=keypair)
debot_abi = Abi.from_path(
path=os.path.join(SAMPLES_DIR, 'Debot.abi.json'))
with open(os.path.join(SAMPLES_DIR, 'Debot.tvc'), 'rb') as fp:
debot_tvc = base64.b64encode(fp.read()).decode()
# Deploy target
call_set = CallSet(function_name='constructor')
deploy_set = DeploySet(tvc=self.target_tvc)
encode_params = ParamsOfEncodeMessage(
abi=self.target_abi, signer=signer, deploy_set=deploy_set,
call_set=call_set)
message = async_custom_client.abi.encode_message(params=encode_params)
# Check if target contract does not exists
target_address = self.__check_address(address=message.address)
if not target_address:
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
target = async_custom_client.processing.process_message(
params=process_params)
target_address = target.transaction['account_addr']
# Deploy debot
call_set = CallSet(
function_name='constructor', input={
'targetAbi': self.target_abi.value.encode().hex(),
'targetAddr': target_address
})
deploy_set = DeploySet(tvc=debot_tvc)
encode_params = ParamsOfEncodeMessage(
abi=debot_abi, signer=signer, deploy_set=deploy_set,
call_set=call_set)
message = async_custom_client.abi.encode_message(params=encode_params)
# Check if debot contract does not exists
debot_address = self.__check_address(address=message.address)
if not debot_address:
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
debot = async_custom_client.processing.process_message(
params=process_params)
debot_address = debot.transaction['account_addr']
# Set ABI
call_set = CallSet(
function_name='setAbi',
input={'debotAbi': debot_abi.value.encode().hex()})
async_custom_client.processing.process_message(
params=ParamsOfProcessMessage(
message_encode_params=ParamsOfEncodeMessage(
abi=debot_abi, signer=Signer.NoSigner(),
address=debot_address, call_set=call_set),
send_events=False))
return debot_address, target_address
def __init_debot5(self, count: int) -> Tuple[List[str], str]:
debot_abi = Abi.from_path(
path=os.path.join(SAMPLES_DIR, 'Debot5.abi.json'))
with open(os.path.join(SAMPLES_DIR, 'Debot5.tvc'), 'rb') as fp:
debot_tvc = base64.b64encode(fp.read()).decode()
result = async_custom_client.boc.get_code_from_tvc(
params=ParamsOfGetCodeFromTvc(tvc=debot_tvc))
result = async_custom_client.boc.get_boc_hash(
params=ParamsOfGetBocHash(boc=result.code))
contract_hash = result.hash
call_set = CallSet(
function_name='constructor',
input={'codeHash': f'0x{contract_hash}'})
deploy_set = DeploySet(tvc=debot_tvc)
deploy_params = ParamsOfEncodeMessage(
abi=debot_abi, deploy_set=deploy_set, call_set=call_set,
signer=Signer.NoSigner())
addresses = []
for i in range(count):
# Set signer for deploy params
keypair = async_custom_client.crypto.generate_random_sign_keys()
deploy_params.signer = Signer.Keys(keys=keypair)
# Calculate address
message = async_custom_client.abi.encode_message(
params=deploy_params)
self.__check_address(address=message.address)
# Deploy address
process_params = ParamsOfProcessMessage(
message_encode_params=deploy_params, send_events=False)
result = async_custom_client.processing.process_message(
params=process_params)
debot_address = result.transaction['account_addr']
addresses.append(debot_address)
if i > 0:
continue
# Set ABI
call_set = CallSet(
function_name='setABI',
input={'dabi': debot_abi.value.encode().hex()})
async_custom_client.processing.process_message(
params=ParamsOfProcessMessage(
message_encode_params=ParamsOfEncodeMessage(
abi=debot_abi, signer=deploy_params.signer,
address=debot_address, call_set=call_set),
send_events=False))
return addresses, contract_hash
def test_process_message_with_events(self):
# Prepare data for deployment message
keypair = async_core_client.crypto.generate_random_sign_keys()
signer = Signer.from_keypair(keypair=keypair)
call_set = CallSet(
function_name='constructor', header={'pubkey': keypair.public})
# Encode deployment message
encoded = async_core_client.abi.encode_message(
abi=self.events_abi, signer=signer,
deploy_set=self.deploy_set, call_set=call_set)
# Send grams
send_grams(address=encoded['address'])
# Deploy account
generator = async_core_client.processing.process_message(
abi=self.events_abi, signer=signer, deploy_set=self.deploy_set,
call_set=call_set, send_events=True)
events = []
for event in generator:
events.append(event)
result = events[-1]['response_data']
self.assertEqual([], result['out_messages'])
self.assertEqual(
{'out_messages': [], 'output': None}, result['decoded'])
def test_wait_for_transaction(self):
# Create deploy message
keypair = async_custom_client.crypto.generate_random_sign_keys()
signer = Signer.Keys(keys=keypair)
call_set = CallSet(
function_name='constructor',
header=FunctionHeader(pubkey=keypair.public))
encode_params = ParamsOfEncodeMessage(
abi=self.events_abi, signer=signer, deploy_set=self.deploy_set,
call_set=call_set)
encoded = async_custom_client.abi.encode_message(params=encode_params)
# Send grams
send_grams(address=encoded.address)
# Send message
send_params = ParamsOfSendMessage(
message=encoded.message, send_events=False, abi=self.events_abi)
send = async_custom_client.processing.send_message(
params=send_params)
# Wait for transaction
wait_params = ParamsOfWaitForTransaction(
message=encoded.message, shard_block_id=send.shard_block_id,
send_events=False, abi=self.events_abi)
wait = async_custom_client.processing.wait_for_transaction(
params=wait_params)
self.assertEqual([], wait.out_messages)
self.assertEqual([], wait.decoded.out_messages)
self.assertIsNone(wait.decoded.output)
def test_wait_for_transaction_with_events(self):
# Create deploy message
keypair = async_core_client.crypto.generate_random_sign_keys()
signer = Signer.from_keypair(keypair=keypair)
call_set = CallSet(
function_name='constructor', header={'pubkey': keypair.public})
encoded = async_core_client.abi.encode_message(
abi=self.events_abi, signer=signer,
deploy_set=self.deploy_set, call_set=call_set)
# Send grams
send_grams(address=encoded['address'])
# Send message
generator = async_core_client.processing.send_message(
message=encoded['message'], send_events=True, abi=self.events_abi)
events = []
for event in generator:
events.append(event)
shard_block_id = events[-1]['response_data']
# Wait for transaction
generator = async_core_client.processing.wait_for_transaction(
message=encoded['message'], shard_block_id=shard_block_id,
send_events=True, abi=self.events_abi)
events.clear()
for event in generator:
events.append(event)
result = events[-1]['response_data']
self.assertEqual([], result['out_messages'])
self.assertEqual(
{'out_messages': [], 'output': None}, result['decoded'])
def get_testnet_grams(self,address: str):
giver_abi = Abi.from_json_path(
path=os.path.join(self.SAMPLES_DIR, 'Giver.abi.json'))
call_set = CallSet(
function_name='grant',
inputs={'addr': address})
self.async_core_client.processing.process_message(
abi=giver_abi, signer=Signer(), address='0:653b9a6452c7a982c6dc92b2da9eba832ade1c467699ebb3b43dca6d77b780dd',
call_set=call_set, send_events=False)
def send_grams(address: str):
giver_abi = Abi.from_json_path(
path=os.path.join(SAMPLES_DIR, 'Giver.abi.json'))
call_set = CallSet(function_name='grant', inputs={'addr': address})
async_core_client.processing.process_message(abi=giver_abi,
signer=Signer(),
address=GIVER_ADDRESS,
call_set=call_set,
send_events=False)
def send_grams(address: str):
giver_abi = Abi.from_path(path=os.path.join(SAMPLES_DIR, 'Giver.abi.json'))
call_set = CallSet(function_name='grant', input={'dest': address})
encode_params = ParamsOfEncodeMessage(abi=giver_abi,
signer=Signer.NoSigner(),
address=GIVER_ADDRESS,
call_set=call_set)
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
async_custom_client.processing.process_message(params=process_params)
def send_data(self,function_name,inputs,outputs):
with open(".contract.abi.json") as f:
data = json.loads(f.read())
sender = {}
for i in inputs:
for x in data["functions"]:
if x["name"] == function_name:
for t in x["inputs"]:
if t["name"] == i[0]:
if "int" in t["type"]:
sender[i[0]] = int(i[1].text())
else:
sender[i[0]] = i[1].text()
#m = QMessageBox.about(self, "Running...", "Please wait for a while. Dont press any button")
print(self.addr,Abi.from_json_path(
path='.contract.abi.json'),function_name,sender,Signer(self.main_key))
response = self.wrapper.run_contract(self.addr,Abi.from_json_path(
path='.contract.abi.json'),function_name,sender,signer=Signer(self.main_key))
QMessageBox.about(self, "Running...", str(response))
def test_wait_for_transaction_with_events(self):
# Create deploy message
keypair = async_custom_client.crypto.generate_random_sign_keys()
signer = Signer.Keys(keys=keypair)
call_set = CallSet(
function_name='constructor',
header=FunctionHeader(pubkey=keypair.public))
encode_params = ParamsOfEncodeMessage(
abi=self.events_abi, signer=signer, deploy_set=self.deploy_set,
call_set=call_set)
encoded = async_custom_client.abi.encode_message(params=encode_params)
# Send grams
send_grams(address=encoded.address)
# Send message
events = []
def __callback(response_data, response_type, *args):
self.assertEqual(
ProcessingResponseType.PROCESSING_EVENT, response_type)
event = ProcessingEvent.from_dict(data=response_data)
events.append(event)
send_params = ParamsOfSendMessage(
message=encoded.message, send_events=True, abi=self.events_abi)
send = async_custom_client.processing.send_message(
params=send_params, callback=__callback)
logging.info('Send message events:')
for e in events:
logging.info(e.type)
logging.info(f'Shard block id: {send.shard_block_id}')
# Wait for transaction
events.clear()
wait_params = ParamsOfWaitForTransaction(
message=encoded.message, shard_block_id=send.shard_block_id,
send_events=True, abi=self.events_abi)
wait = async_custom_client.processing.wait_for_transaction(
params=wait_params, callback=__callback)
self.assertEqual([], wait.out_messages)
self.assertEqual([], wait.decoded.out_messages)
self.assertIsNone(wait.decoded.output)
logging.info('Wait message events:')
for e in events:
logging.info(e.type)
def test_encode_message_body(self):
header = FunctionHeader(expire=self.events_expire,
time=self.events_time,
pubkey=self.keypair.public)
call_set = CallSet(function_name='returnValue',
header=header,
input={'id': '0'})
signer = Signer.Keys(keys=self.keypair)
params = ParamsOfEncodeMessageBody(abi=self.events_abi,
call_set=call_set,
is_internal=False,
signer=signer)
encoded = async_core_client.abi.encode_message_body(params=params)
self.assertIsNone(encoded.data_to_sign)
def compile_contract(self):
if not ".tmp_contract_deployer" in os.listdir():
os.mkdir(".tmp_contract_deployer")
f = open(f'.tmp_contract_deployer/.contract.sol','w')
f.write(self.plainTextEdit.toPlainText())
f.close()
home_dir = os.system("solc .tmp_contract_deployer/.contract.sol")
os.system("tvm_linker compile .contract.code --abi-json .contract.abi.json --lib stdlib_sol.tvm -o .contract.tvc")
with open(".contract.abi.json","r") as f:
abi = f.read()
addr = self.wrapper.get_address(Signer(self.main_key),Abi.from_json_path(
path='.contract.abi.json'),self.wrapper.open_tvc(".contract.tvc"))
self.address.setText(QCoreApplication.translate("MainWindow", f"Address of contract: {addr}", None))
self.addr = addr
self.update_balance()
with open(".contract.abi.json") as f:
data = json.loads(f.read())
self.create_function(data)
def __init_debot2(self, keypair: KeyPair) -> str:
signer = Signer.Keys(keys=keypair)
debot_abi = Abi.from_path(
path=os.path.join(SAMPLES_DIR, 'Debot2.abi.json'))
with open(os.path.join(SAMPLES_DIR, 'Debot2.tvc'), 'rb') as fp:
debot_tvc = base64.b64encode(fp.read()).decode()
call_set = CallSet(
function_name='constructor',
input={
'pub': f'0x{keypair.public}',
'sec': f'0x{keypair.secret}'
})
deploy_set = DeploySet(tvc=debot_tvc)
encode_params = ParamsOfEncodeMessage(
abi=debot_abi, signer=signer, deploy_set=deploy_set,
call_set=call_set)
message = async_custom_client.abi.encode_message(params=encode_params)
# Check if debot contract does not exists
debot_address = self.__check_address(address=message.address)
if not debot_address:
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
debot = async_custom_client.processing.process_message(
params=process_params)
debot_address = debot.transaction['account_addr']
# Set ABI
call_set = CallSet(
function_name='setAbi',
input={'debotAbi': debot_abi.value.encode().hex()})
async_custom_client.processing.process_message(
params=ParamsOfProcessMessage(
message_encode_params=ParamsOfEncodeMessage(
abi=debot_abi, signer=signer, address=debot_address,
call_set=call_set),
send_events=False))
return debot_address
def test_process_message_with_events(self):
# Prepare data for deployment message
keypair = async_custom_client.crypto.generate_random_sign_keys()
signer = Signer.Keys(keys=keypair)
call_set = CallSet(
function_name='constructor',
header=FunctionHeader(pubkey=keypair.public))
# Encode deployment message
encode_params = ParamsOfEncodeMessage(
abi=self.events_abi, signer=signer, deploy_set=self.deploy_set,
call_set=call_set)
encoded = async_custom_client.abi.encode_message(params=encode_params)
# Send grams
send_grams(address=encoded.address)
# Deploy account
events = []
def __callback(response_data, response_type, *args):
self.assertEqual(
ProcessingResponseType.PROCESSING_EVENT, response_type)
event = ProcessingEvent.from_dict(data=response_data)
events.append(event)
deploy_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=True)
deploy = async_custom_client.processing.process_message(
params=deploy_params, callback=__callback)
self.assertEqual(
encoded.address, deploy.transaction['account_addr'])
self.assertEqual('finalized', deploy.transaction['status_name'])
self.assertEqual(0, len(deploy.out_messages))
logging.info('Events fired')
for e in events:
logging.info(e.type)
def test_process_message(self):
# Prepare data for deployment message
keypair = async_custom_client.crypto.generate_random_sign_keys()
signer = Signer.Keys(keys=keypair)
call_set = CallSet(
function_name='constructor',
header=FunctionHeader(pubkey=keypair.public))
# Encode deployment message
encode_params = ParamsOfEncodeMessage(
abi=self.events_abi, signer=signer, deploy_set=self.deploy_set,
call_set=call_set)
encoded = async_custom_client.abi.encode_message(params=encode_params)
# Send grams
send_grams(address=encoded.address)
# Deploy account
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
result = async_custom_client.processing.process_message(
params=process_params)
self.assertEqual(
encoded.address, result.transaction['account_addr'])
self.assertEqual('finalized', result.transaction['status_name'])
self.assertEqual(0, len(result.out_messages))
# Contract execution error
with self.assertRaises(TonException):
call_set = CallSet(function_name='returnValue', input={'id': -1})
encode_params = ParamsOfEncodeMessage(
abi=self.events_abi, signer=signer, address=encoded.address,
call_set=call_set)
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
async_custom_client.processing.process_message(
params=process_params)
def test_encode_message(self):
deploy_set = DeploySet(tvc=self.events_tvc)
call_set = CallSet(function_name='constructor',
header=FunctionHeader(pubkey=self.keypair.public,
time=self.events_time,
expire=self.events_expire))
signer = Signer.External(public_key=self.keypair.public)
# Create unsigned deployment message
params = ParamsOfEncodeMessage(abi=self.events_abi,
signer=signer,
deploy_set=deploy_set,
call_set=call_set)
unsigned = async_core_client.abi.encode_message(params=params)
self.assertEqual(
'te6ccgECFwEAA2gAAqeIAAt9aqvShfTon7Lei1PVOhUEkEEZQkhDKPgNyzeTL6YSEZTHxAj/Hd67jWQF7peccWoU/dbMCBJBB6YdPCVZcJlJkAAAF0ZyXLg19VzGRotV8/gGAQEBwAICA88gBQMBAd4EAAPQIABB2mPiBH+O713GsgL3S844tQp+62YECSCD0w6eEqy4TKTMAib/APSkICLAAZL0oOGK7VNYMPShCQcBCvSkIPShCAAAAgEgDAoByP9/Ie1E0CDXScIBjhDT/9M/0wDRf/hh+Gb4Y/hijhj0BXABgED0DvK91wv/+GJw+GNw+GZ/+GHi0wABjh2BAgDXGCD5AQHTAAGU0/8DAZMC+ELiIPhl+RDyqJXTAAHyeuLTPwELAGqOHvhDIbkgnzAg+COBA+iogggbd0Cgud6S+GPggDTyNNjTHwH4I7zyudMfAfAB+EdukvI83gIBIBINAgEgDw4AvbqLVfP/hBbo417UTQINdJwgGOENP/0z/TANF/+GH4Zvhj+GKOGPQFcAGAQPQO8r3XC//4YnD4Y3D4Zn/4YeLe+Ebyc3H4ZtH4APhCyMv/+EPPCz/4Rs8LAMntVH/4Z4AgEgERAA5biABrW/CC3Rwn2omhp/+mf6YBov/ww/DN8Mfwxb30gyupo6H0gb+j8IpA3SRg4b3whXXlwMnwAZGT9ghBkZ8KEZ0aCBAfQAAAAAAAAAAAAAAAAACBni2TAgEB9gBh8IWRl//wh54Wf/CNnhYBk9qo//DPAAxbmTwqLfCC3Rwn2omhp/+mf6YBov/ww/DN8Mfwxb2uG/8rqaOhp/+/o/ABkRe4AAAAAAAAAAAAAAAAIZ4tnwOfI48sYvRDnhf/kuP2AGHwhZGX//CHnhZ/8I2eFgGT2qj/8M8AIBSBYTAQm4t8WCUBQB/PhBbo4T7UTQ0//TP9MA0X/4Yfhm+GP4Yt7XDf+V1NHQ0//f0fgAyIvcAAAAAAAAAAAAAAAAEM8Wz4HPkceWMXohzwv/yXH7AMiL3AAAAAAAAAAAAAAAABDPFs+Bz5JW+LBKIc8L/8lx+wAw+ELIy//4Q88LP/hGzwsAye1UfxUABPhnAHLccCLQ1gIx0gAw3CHHAJLyO+Ah1w0fkvI84VMRkvI74cEEIoIQ/////byxkvI84AHwAfhHbpLyPN4=',
unsigned.message)
self.assertEqual('KCGM36iTYuCYynk+Jnemis+mcwi3RFCke95i7l96s4Q=',
unsigned.data_to_sign)
# Create detached signature
sign_params = ParamsOfSign(unsigned=unsigned.data_to_sign,
keys=self.keypair)
signature = async_core_client.crypto.sign(params=sign_params)
self.assertEqual(
'6272357bccb601db2b821cb0f5f564ab519212d242cf31961fe9a3c50a30b236012618296b4f769355c0e9567cd25b366f3c037435c498c82e5305622adbc70e',
signature.signature)
# Attach signature to unsigned message
attach_params = ParamsOfAttachSignature(abi=self.events_abi,
public_key=self.keypair.public,
message=unsigned.message,
signature=signature.signature)
signed = async_core_client.abi.attach_signature(params=attach_params)
self.assertEqual(
'te6ccgECGAEAA6wAA0eIAAt9aqvShfTon7Lei1PVOhUEkEEZQkhDKPgNyzeTL6YSEbAHAgEA4bE5Gr3mWwDtlcEOWHr6slWoyQlpIWeYyw/00eKFGFkbAJMMFLWnu0mq4HSrPmktmzeeAboa4kxkFymCsRVt44dTHxAj/Hd67jWQF7peccWoU/dbMCBJBB6YdPCVZcJlJkAAAF0ZyXLg19VzGRotV8/gAQHAAwIDzyAGBAEB3gUAA9AgAEHaY+IEf47vXcayAvdLzji1Cn7rZgQJIIPTDp4SrLhMpMwCJv8A9KQgIsABkvSg4YrtU1gw9KEKCAEK9KQg9KEJAAACASANCwHI/38h7UTQINdJwgGOENP/0z/TANF/+GH4Zvhj+GKOGPQFcAGAQPQO8r3XC//4YnD4Y3D4Zn/4YeLTAAGOHYECANcYIPkBAdMAAZTT/wMBkwL4QuIg+GX5EPKoldMAAfJ64tM/AQwAao4e+EMhuSCfMCD4I4ED6KiCCBt3QKC53pL4Y+CANPI02NMfAfgjvPK50x8B8AH4R26S8jzeAgEgEw4CASAQDwC9uotV8/+EFujjXtRNAg10nCAY4Q0//TP9MA0X/4Yfhm+GP4Yo4Y9AVwAYBA9A7yvdcL//hicPhjcPhmf/hh4t74RvJzcfhm0fgA+ELIy//4Q88LP/hGzwsAye1Uf/hngCASASEQDluIAGtb8ILdHCfaiaGn/6Z/pgGi//DD8M3wx/DFvfSDK6mjofSBv6PwikDdJGDhvfCFdeXAyfABkZP2CEGRnwoRnRoIEB9AAAAAAAAAAAAAAAAAAIGeLZMCAQH2AGHwhZGX//CHnhZ/8I2eFgGT2qj/8M8ADFuZPCot8ILdHCfaiaGn/6Z/pgGi//DD8M3wx/DFva4b/yupo6Gn/7+j8AGRF7gAAAAAAAAAAAAAAAAhni2fA58jjyxi9EOeF/+S4/YAYfCFkZf/8IeeFn/wjZ4WAZPaqP/wzwAgFIFxQBCbi3xYJQFQH8+EFujhPtRNDT/9M/0wDRf/hh+Gb4Y/hi3tcN/5XU0dDT/9/R+ADIi9wAAAAAAAAAAAAAAAAQzxbPgc+Rx5YxeiHPC//JcfsAyIvcAAAAAAAAAAAAAAAAEM8Wz4HPklb4sEohzwv/yXH7ADD4QsjL//hDzws/+EbPCwDJ7VR/FgAE+GcActxwItDWAjHSADDcIccAkvI74CHXDR+S8jzhUxGS8jvhwQQighD////9vLGS8jzgAfAB+EdukvI83g==',
signed.message)
# Create initially signed message
signer = Signer.Keys(keys=self.keypair)
encode_params = ParamsOfEncodeMessage(abi=self.events_abi,
signer=signer,
deploy_set=deploy_set,
call_set=call_set)
signed = async_core_client.abi.encode_message(params=encode_params)
self.assertEqual(
'te6ccgECGAEAA6wAA0eIAAt9aqvShfTon7Lei1PVOhUEkEEZQkhDKPgNyzeTL6YSEbAHAgEA4bE5Gr3mWwDtlcEOWHr6slWoyQlpIWeYyw/00eKFGFkbAJMMFLWnu0mq4HSrPmktmzeeAboa4kxkFymCsRVt44dTHxAj/Hd67jWQF7peccWoU/dbMCBJBB6YdPCVZcJlJkAAAF0ZyXLg19VzGRotV8/gAQHAAwIDzyAGBAEB3gUAA9AgAEHaY+IEf47vXcayAvdLzji1Cn7rZgQJIIPTDp4SrLhMpMwCJv8A9KQgIsABkvSg4YrtU1gw9KEKCAEK9KQg9KEJAAACASANCwHI/38h7UTQINdJwgGOENP/0z/TANF/+GH4Zvhj+GKOGPQFcAGAQPQO8r3XC//4YnD4Y3D4Zn/4YeLTAAGOHYECANcYIPkBAdMAAZTT/wMBkwL4QuIg+GX5EPKoldMAAfJ64tM/AQwAao4e+EMhuSCfMCD4I4ED6KiCCBt3QKC53pL4Y+CANPI02NMfAfgjvPK50x8B8AH4R26S8jzeAgEgEw4CASAQDwC9uotV8/+EFujjXtRNAg10nCAY4Q0//TP9MA0X/4Yfhm+GP4Yo4Y9AVwAYBA9A7yvdcL//hicPhjcPhmf/hh4t74RvJzcfhm0fgA+ELIy//4Q88LP/hGzwsAye1Uf/hngCASASEQDluIAGtb8ILdHCfaiaGn/6Z/pgGi//DD8M3wx/DFvfSDK6mjofSBv6PwikDdJGDhvfCFdeXAyfABkZP2CEGRnwoRnRoIEB9AAAAAAAAAAAAAAAAAAIGeLZMCAQH2AGHwhZGX//CHnhZ/8I2eFgGT2qj/8M8ADFuZPCot8ILdHCfaiaGn/6Z/pgGi//DD8M3wx/DFva4b/yupo6Gn/7+j8AGRF7gAAAAAAAAAAAAAAAAhni2fA58jjyxi9EOeF/+S4/YAYfCFkZf/8IeeFn/wjZ4WAZPaqP/wzwAgFIFxQBCbi3xYJQFQH8+EFujhPtRNDT/9M/0wDRf/hh+Gb4Y/hi3tcN/5XU0dDT/9/R+ADIi9wAAAAAAAAAAAAAAAAQzxbPgc+Rx5YxeiHPC//JcfsAyIvcAAAAAAAAAAAAAAAAEM8Wz4HPklb4sEohzwv/yXH7ADD4QsjL//hDzws/+EbPCwDJ7VR/FgAE+GcActxwItDWAjHSADDcIccAkvI74CHXDR+S8jzhUxGS8jvhwQQighD////9vLGS8jzgAfAB+EdukvI83g==',
signed.message)
# Sign with signing box
sbox = async_core_client.crypto.get_signing_box(params=self.keypair)
signer_sbox = Signer.SigningBox(handle=sbox.handle)
encode_params = ParamsOfEncodeMessage(abi=self.events_abi,
signer=signer_sbox,
deploy_set=deploy_set,
call_set=call_set)
signed_sbox = async_core_client.abi.encode_message(
params=encode_params)
async_core_client.crypto.remove_signing_box(params=sbox)
self.assertEqual(signed.message, signed_sbox.message)
# Create run unsigned message
address = '0:05beb555e942fa744fd96f45a9ea9d0a8248208ca12421947c06e59bc997d309'
call_set = CallSet(function_name='returnValue',
input={'id': '0'},
header=FunctionHeader(
**{
'pubkey': self.keypair.public,
'time': self.events_time,
'expire': self.events_expire
}))
signer = Signer.External(public_key=self.keypair.public)
encode_params = ParamsOfEncodeMessage(abi=self.events_abi,
signer=signer,
address=address,
call_set=call_set)
unsigned = async_core_client.abi.encode_message(params=encode_params)
self.assertEqual(
'te6ccgEBAgEAeAABpYgAC31qq9KF9Oifst6LU9U6FQSQQRlCSEMo+A3LN5MvphIFMfECP8d3ruNZAXul5xxahT91swIEkEHph08JVlwmUmQAAAXRnJcuDX1XMZBW+LBKAQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=',
unsigned.message)
self.assertEqual('i4Hs3PB12QA9UBFbOIpkG3JerHHqjm4LgvF4MA7TDsY=',
unsigned.data_to_sign)
# Create detached signature
sign_params = ParamsOfSign(unsigned=unsigned.data_to_sign,
keys=self.keypair)
signature = async_core_client.crypto.sign(params=sign_params)
self.assertEqual(
'5bbfb7f184f2cb5f019400b9cd497eeaa41f3d5885619e9f7d4fab8dd695f4b3a02159a1422996c1dd7d1be67898bc79c6adba6c65a18101ac5f0a2a2bb8910b',
signature.signature)
# Attach signature
attach_params = ParamsOfAttachSignature(abi=self.events_abi,
public_key=self.keypair.public,
message=unsigned.message,
signature=signature.signature)
signed = async_core_client.abi.attach_signature(params=attach_params)
self.assertEqual(
'te6ccgEBAwEAvAABRYgAC31qq9KF9Oifst6LU9U6FQSQQRlCSEMo+A3LN5MvphIMAQHhrd/b+MJ5Za+AygBc5qS/dVIPnqxCsM9PvqfVxutK+lnQEKzQoRTLYO6+jfM8TF4841bdNjLQwIDWL4UVFdxIhdMfECP8d3ruNZAXul5xxahT91swIEkEHph08JVlwmUmQAAAXRnJcuDX1XMZBW+LBKACAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==',
signed.message)
# Create initially signed message
signer = Signer.Keys(keys=self.keypair)
encode_params = ParamsOfEncodeMessage(abi=self.events_abi,
signer=signer,
address=address,
call_set=call_set)
signed = async_core_client.abi.encode_message(params=encode_params)
self.assertEqual(
'te6ccgEBAwEAvAABRYgAC31qq9KF9Oifst6LU9U6FQSQQRlCSEMo+A3LN5MvphIMAQHhrd/b+MJ5Za+AygBc5qS/dVIPnqxCsM9PvqfVxutK+lnQEKzQoRTLYO6+jfM8TF4841bdNjLQwIDWL4UVFdxIhdMfECP8d3ruNZAXul5xxahT91swIEkEHph08JVlwmUmQAAAXRnJcuDX1XMZBW+LBKACAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==',
signed.message)
def test_encode_account(self):
# Encode account from encoded deploy message
encoded_deploy_message = 'te6ccgECFwEAA2gAAqeIAAt9aqvShfTon7Lei1PVOhUEkEEZQkhDKPgNyzeTL6YSEZTHxAj/Hd67jWQF7peccWoU/dbMCBJBB6YdPCVZcJlJkAAAF0ZyXLg19VzGRotV8/gGAQEBwAICA88gBQMBAd4EAAPQIABB2mPiBH+O713GsgL3S844tQp+62YECSCD0w6eEqy4TKTMAib/APSkICLAAZL0oOGK7VNYMPShCQcBCvSkIPShCAAAAgEgDAoByP9/Ie1E0CDXScIBjhDT/9M/0wDRf/hh+Gb4Y/hijhj0BXABgED0DvK91wv/+GJw+GNw+GZ/+GHi0wABjh2BAgDXGCD5AQHTAAGU0/8DAZMC+ELiIPhl+RDyqJXTAAHyeuLTPwELAGqOHvhDIbkgnzAg+COBA+iogggbd0Cgud6S+GPggDTyNNjTHwH4I7zyudMfAfAB+EdukvI83gIBIBINAgEgDw4AvbqLVfP/hBbo417UTQINdJwgGOENP/0z/TANF/+GH4Zvhj+GKOGPQFcAGAQPQO8r3XC//4YnD4Y3D4Zn/4YeLe+Ebyc3H4ZtH4APhCyMv/+EPPCz/4Rs8LAMntVH/4Z4AgEgERAA5biABrW/CC3Rwn2omhp/+mf6YBov/ww/DN8Mfwxb30gyupo6H0gb+j8IpA3SRg4b3whXXlwMnwAZGT9ghBkZ8KEZ0aCBAfQAAAAAAAAAAAAAAAAACBni2TAgEB9gBh8IWRl//wh54Wf/CNnhYBk9qo//DPAAxbmTwqLfCC3Rwn2omhp/+mf6YBov/ww/DN8Mfwxb2uG/8rqaOhp/+/o/ABkRe4AAAAAAAAAAAAAAAAIZ4tnwOfI48sYvRDnhf/kuP2AGHwhZGX//CHnhZ/8I2eFgGT2qj/8M8AIBSBYTAQm4t8WCUBQB/PhBbo4T7UTQ0//TP9MA0X/4Yfhm+GP4Yt7XDf+V1NHQ0//f0fgAyIvcAAAAAAAAAAAAAAAAEM8Wz4HPkceWMXohzwv/yXH7AMiL3AAAAAAAAAAAAAAAABDPFs+Bz5JW+LBKIc8L/8lx+wAw+ELIy//4Q88LP/hGzwsAye1UfxUABPhnAHLccCLQ1gIx0gAw3CHHAJLyO+Ah1w0fkvI84VMRkvI74cEEIoIQ/////byxkvI84AHwAfhHbpLyPN4='
message_source = MessageSource.Encoded(message=encoded_deploy_message,
abi=self.events_abi)
state_init_source = StateInitSource.Message(source=message_source)
encode_params = ParamsOfEncodeAccount(state_init=state_init_source)
encoded = async_core_client.abi.encode_account(params=encode_params)
self.assertEqual(
'05beb555e942fa744fd96f45a9ea9d0a8248208ca12421947c06e59bc997d309',
encoded.id)
# Encode account from encoding params
deploy_set = DeploySet(tvc=self.events_tvc)
call_set = CallSet(function_name='constructor',
header=FunctionHeader(
**{
'pubkey': self.keypair.public,
'time': self.events_time,
'expire': self.events_expire
}))
signer = Signer.Keys(keys=self.keypair)
encoding_params = ParamsOfEncodeMessage(abi=self.events_abi,
signer=signer,
deploy_set=deploy_set,
call_set=call_set)
message_source = MessageSource.EncodingParams(params=encoding_params)
state_init_source = StateInitSource.Message(source=message_source)
encode_params = ParamsOfEncodeAccount(state_init=state_init_source)
encoded = async_core_client.abi.encode_account(params=encode_params)
self.assertEqual(
'05beb555e942fa744fd96f45a9ea9d0a8248208ca12421947c06e59bc997d309',
encoded.id)
# Test exception (external signer)
with self.assertRaises(TonException):
signer = Signer.External(public_key=self.keypair.public)
encoding_params = ParamsOfEncodeMessage(abi=self.events_abi,
signer=signer,
deploy_set=deploy_set,
call_set=call_set)
message_source = MessageSource.EncodingParams(
params=encoding_params)
state_init_source = StateInitSource.Message(source=message_source)
encode_params = ParamsOfEncodeAccount(state_init=state_init_source)
async_core_client.abi.encode_account(params=encode_params)
# Encode account from TVC
state_init_source = StateInitSource.Tvc(tvc=self.events_tvc)
encode_params = ParamsOfEncodeAccount(state_init=state_init_source)
encoded = async_core_client.abi.encode_account(params=encode_params)
self.assertNotEqual(
'05beb555e942fa744fd96f45a9ea9d0a8248208ca12421947c06e59bc997d309',
encoded.id)
state_init_source = StateInitSource.Tvc(tvc=self.events_tvc,
public_key=self.keypair.public)
encode_params = ParamsOfEncodeAccount(state_init=state_init_source)
encoded = async_core_client.abi.encode_account(params=encode_params)
self.assertEqual(
'05beb555e942fa744fd96f45a9ea9d0a8248208ca12421947c06e59bc997d309',
encoded.id)
def run_contract(self,address: str, abi: Abi, function_name: str, inputs: dict, signer=Signer()):
call_set = CallSet(
function_name=function_name,
inputs=inputs)
encoded = self.async_core_client.abi.encode_message(
abi=abi, signer=signer, address=address,
call_set=call_set)
shard_block_id = self.async_core_client.processing.send_message(
message=encoded["message"], send_events=False)
return self.async_core_client.processing.wait_for_transaction(encoded['message'], shard_block_id, send_events=False,
abi=abi)
def compile(self):
m = QMessageBox.about(self,"Deploying...","Please wait for a while. Dont press any button")
result = self.wrapper.deploy_contract(abi=Abi.from_json_path(
path='.contract.abi.json'),tvc=self.wrapper.open_tvc('.contract.tvc'),signer=Signer(self.main_key))
m.setText(str(result))
def test_suspend_resume(self):
# Data for contract deployment
keypair = async_custom_client.crypto.generate_random_sign_keys()
abi = Abi.from_path(path=os.path.join(SAMPLES_DIR, 'Hello.abi.json'))
with open(os.path.join(SAMPLES_DIR, 'Hello.tvc'), 'rb') as fp:
tvc = base64.b64encode(fp.read()).decode()
signer = Signer.Keys(keys=keypair)
deploy_set = DeploySet(tvc=tvc)
call_set = CallSet(function_name='constructor')
# Prepare deployment params
encode_params = ParamsOfEncodeMessage(
abi=abi, signer=signer, deploy_set=deploy_set, call_set=call_set)
encode = async_custom_client.abi.encode_message(params=encode_params)
# Subscribe for address deploy transaction status
transactions = []
def __callback(response_data, response_type, *args):
if response_type == SubscriptionResponseType.OK:
result = ResultOfSubscription(**response_data)
transactions.append(result.result)
self.assertEqual(encode.address, result.result['account_addr'])
if response_type == SubscriptionResponseType.ERROR:
logging.info(ClientError(**response_data).__str__())
subscribe_params = ParamsOfSubscribeCollection(
collection='transactions', result='id account_addr',
filter={'account_addr': {'eq': encode.address}, 'status_name': {'eq': 'Finalized'}})
subscribe = async_custom_client.net.subscribe_collection(
params=subscribe_params, callback=__callback)
# Send grams to new account to create first transaction
send_grams(address=encode.address)
# Give some time for subscription to receive all data
time.sleep(2)
# Suspend subscription
async_custom_client.net.suspend()
time.sleep(2) # Wait a bit for suspend
# Deploy to create second transaction.
# Use another client, because of error: Fetch first block failed:
# Can not use network module since it is suspended
second_config = ClientConfig()
second_config.network.server_address = CUSTOM_BASE_URL
second_client = TonClient(config=second_config)
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
second_client.processing.process_message(params=process_params)
second_client.destroy_context()
# Check that second transaction is not received when
# subscription suspended
self.assertEqual(1, len(transactions))
# Resume subscription
async_custom_client.net.resume()
time.sleep(2) # Wait a bit for resume
# Run contract function to create third transaction
call_set = CallSet(function_name='touch')
encode_params = ParamsOfEncodeMessage(
abi=abi, signer=signer, address=encode.address, call_set=call_set)
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
async_custom_client.processing.process_message(params=process_params)
# Give some time for subscription to receive all data
time.sleep(2)
# Check that third transaction is now received after resume
self.assertEqual(2, len(transactions))
self.assertNotEqual(transactions[0]['id'], transactions[1]['id'])
# Unsubscribe
async_custom_client.net.unsubscribe(params=subscribe)
def __init_debot_pair(self, keypair: KeyPair) -> Tuple[str, str]:
signer = Signer.Keys(keys=keypair)
debot_a_abi = Abi.from_path(
path=os.path.join(SAMPLES_DIR, 'DebotPairA.abi.json'))
with open(os.path.join(SAMPLES_DIR, 'DebotPairA.tvc'), 'rb') as fp:
debot_a_tvc = base64.b64encode(fp.read()).decode()
debot_b_abi = Abi.from_path(
path=os.path.join(SAMPLES_DIR, 'DebotPairB.abi.json'))
with open(os.path.join(SAMPLES_DIR, 'DebotPairB.tvc'), 'rb') as fp:
debot_b_tvc = base64.b64encode(fp.read()).decode()
# Deploy debot B
call_set = CallSet(function_name='constructor')
deploy_set = DeploySet(tvc=debot_b_tvc)
encode_params = ParamsOfEncodeMessage(
abi=debot_b_abi, signer=signer, deploy_set=deploy_set,
call_set=call_set)
message = async_custom_client.abi.encode_message(params=encode_params)
b_address = message.address
self.__check_address(address=b_address)
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
debot_b = async_custom_client.processing.process_message(
params=process_params)
b_address = debot_b.transaction['account_addr']
# Set ABI
call_set = CallSet(
function_name='setAbi',
input={'debotAbi': debot_b_abi.value.encode().hex()})
async_custom_client.processing.process_message(
params=ParamsOfProcessMessage(
message_encode_params=ParamsOfEncodeMessage(
abi=debot_b_abi, signer=signer, address=b_address,
call_set=call_set),
send_events=False))
# Deploy debot A
call_set = CallSet(
function_name='constructor', input={
'targetAddr': b_address
})
deploy_set = DeploySet(tvc=debot_a_tvc)
encode_params = ParamsOfEncodeMessage(
abi=debot_a_abi, signer=signer, deploy_set=deploy_set,
call_set=call_set)
message = async_custom_client.abi.encode_message(params=encode_params)
a_address = message.address
self.__check_address(address=a_address)
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
debot_a = async_custom_client.processing.process_message(
params=process_params)
a_address = debot_a.transaction['account_addr']
# Set ABI
call_set = CallSet(
function_name='setAbi',
input={'debotAbi': debot_a_abi.value.encode().hex()})
async_custom_client.processing.process_message(
params=ParamsOfProcessMessage(
message_encode_params=ParamsOfEncodeMessage(
abi=debot_a_abi, signer=signer, address=a_address,
call_set=call_set),
send_events=False))
return a_address, b_address
