def test3():
print('Transfer with flags')
# Deploy the sender's contract and register nickname to be used in the output
sender = ts4.BaseContract('tutorial09', {}, nickname='Sender')
balance_sender = sender.balance
# Deploy the another one recipient's contract and register nickname to be used in the output
recipient = ts4.BaseContract('tutorial09', {}, nickname='Recipient')
addr_recipient = recipient.address
balance_recipient = recipient.balance
# Send grams to the recipient (regular transfer)
amount = 3 * ts4.GRAM
params = dict(addr=addr_recipient, amount=amount, flags=0)
sender.call_method('send_grams_with_flags', params)
# Dispatch created message
ts4.dispatch_one_message()
# Сheck the current balance of the sender and recipient
sender.ensure_balance(balance_sender - amount)
recipient.ensure_balance(balance_recipient + amount)
# Send remainig balance and self-destroy sender's contract
params = dict(addr=addr_recipient, amount=0, flags=160)
sender.call_method('send_grams_with_flags', params)
ts4.dispatch_one_message()
# Сheck the current balance of the recipient, it's should be increased by sender's balance
recipient.ensure_balance(balance_recipient + balance_sender)
# Balance of the sender should be None, because of the contract destroyed
assert eq(None, ts4.get_balance(sender.address))
def test2():
print('Transfer with payload')
# Deploy the sender's contract and register nickname to be used in the output
sender = ts4.BaseContract('tutorial09', {}, nickname='Sender')
balance_sender = sender.balance
# Deploy the another one recipient's contract and register nickname to be used in the output
recipient = ts4.BaseContract('tutorial09', {}, nickname='Recipient')
addr_recipient = recipient.address
balance_recipient = recipient.balance
# Send grams to the recipient without payload
amount = 2 * ts4.GRAM
comment = 'some comment'
params = dict(addr=addr_recipient,
amount=amount,
comment=ts4.str2bytes(comment))
sender.call_method('send_grams_with_payload', params)
# Dispatch created message
ts4.dispatch_one_message()
# Сheck the current balance of the sender and recipient
sender.ensure_balance(balance_sender - amount)
recipient.ensure_balance(balance_recipient + amount)
# Pick up event that was created by called method of the called contract
event = ts4.pop_event()
decoded = recipient.decode_event(event)
# Check correctness of the received data
assert eq(comment, decoded.comment)
assert eq(amount, decoded.amount)
def test1():
# In this scenario we are processing messages step by step
print('Starting call chain (step by step)...')
t_value = 4276994270
contract1.call_method('ping_neighbor',
dict(neighbor=neighbor2, value=t_value))
# Get internal message that was created by previous call
msg_ping = ts4.peek_msg()
assert eq(neighbor1, msg_ping.src)
assert eq(neighbor2, msg_ping.dst)
assert msg_ping.is_call('ping')
assert eq(t_value, int(msg_ping.params['request']))
# Dispatch created message
ts4.dispatch_one_message()
# Pick up event that was created by called method of the callee contract
msg_event1 = ts4.pop_event()
# Check correctness of event addresses
assert msg_event1.is_event('ReceivedRequest',
src=neighbor2,
dst=ts4.Address(None))
assert eq(t_value, int(msg_event1.params['request']))
# Get internal message that was created by last call
msg_pong = ts4.peek_msg()
assert eq(neighbor2, msg_pong.src)
assert eq(neighbor1, msg_pong.dst)
assert msg_pong.is_call('pong')
assert eq(t_value, int(msg_pong.params['reply']))
# Dispatch next message
ts4.dispatch_one_message()
# Pick up last event and check its parameters
msg_event2 = ts4.pop_event()
assert msg_event2.is_event('ReceivedReply',
src=neighbor1,
dst=ts4.Address(None))
assert eq(t_value, int(msg_event2.params['reply']))
# Working with raw JSON data is not always convenient. That's why we
# provide a way to decode data:
event2 = contract1.decode_event(msg_event2)
assert eq(t_value, event2.reply)
def test_exchanger(self):
ts4.reset_all() # reset all data
ts4.init('./', verbose=True)
key1 = ts4.make_keypair()
self.public1 = key1[1]
self.secret1 = key1[0]
now = int(time.time())
ts4.core.set_now(now)
test = ts4.BaseContract('test',
dict(),
pubkey=self.public,
private_key=self.secret,
balance=150_000_000_000,
nickname="test")
now += 5
ts4.core.set_now(now)
main = ts4.BaseContract('main',
dict(),
pubkey=self.public,
private_key=self.secret,
balance=150_000_000_000,
nickname="main")
now += 5
ts4.core.set_now(now)
test.call_method("change_address",
dict(_adr=main.addr),
private_key=self.secret)
now += 5
ts4.core.set_now(now)
test.call_method("createTimer",
dict(_payload=1, _time=20),
private_key=self.secret)
while len(ts4.globals.QUEUE) > 0:
now += 5
ts4.core.set_now(now)
ts4.dispatch_one_message()
print(test.call_getter("results"))
def test1():
print('Transfer with bounce')
# Deploy the sender's contract and register nickname to be used in the output
sender = ts4.BaseContract('tutorial09', {}, nickname='Sender')
addr_sender = sender.address
balance_sender = 100 * ts4.GRAM
# Сheck the sender's initial balance. There are 100 grams by default
sender.ensure_balance(balance_sender)
# The contract address of the recipient
addr_recipient = ts4.Address(
'0:c4a31362f0dd98a8cc9282c2f19358c888dfce460d93adb395fa138d61ae5069')
# Register nickname to be used in the output
ts4.register_nickname(addr_recipient, 'Recipient1')
# Сheck the recipient's balance. Until is not deployed it has no balance
assert eq(None, ts4.get_balance(addr_recipient))
# Send grams to the recipient with bounce flag
amount = ts4.GRAM
params = dict(addr=addr_recipient, amount=amount, bounce=True)
sender.call_method('send_grams', params)
# Pick up internal message that was created by `send_grams()` call
msg_transfer = ts4.peek_msg()
assert eq(addr_sender, msg_transfer.src)
assert eq(addr_recipient, msg_transfer.dst)
assert eq(amount, msg_transfer.value)
# Dispatch created message
ts4.dispatch_one_message()
# Сheck the sender's current balance
sender.ensure_balance(balance_sender - amount)
# Pick up internal message that was bounced
msg_bounced = ts4.peek_msg()
assert eq(addr_recipient, msg_bounced.src)
assert eq(addr_sender, msg_bounced.dst)
assert eq(amount, msg_bounced.value)
assert eq(True, msg_bounced.bounced)
# Dispatch bounced message
ts4.dispatch_one_message()
# Balance of the recipient should stay empty
assert eq(None, ts4.get_balance(addr_recipient))
print('Transfer without bounce')
# Send grams to the recipient without bounce flag
params = dict(addr=addr_recipient, amount=amount, bounce=False)
sender.call_method('send_grams', params)
# Dispatch created message
ts4.dispatch_one_message()
# Check balance of the recipient, it should be equal to transferred amount
assert eq(amount, ts4.get_balance(addr_recipient))
# Сhecking the sender's balance, it should be decreased by the amount of the transfer
sender.ensure_balance(balance_sender - amount)
# Initialize TS4 by specifying where the artifacts of the used contracts are located
# verbose: toggle to print additional execution info
ts4.init('contracts/', verbose=True)
# Deploy a contract (encoder/sender)
sender = ts4.BaseContract('tutorial10_1', {})
# Register nickname to be used in the output
ts4.register_nickname(sender.address, 'Sender')
# Deploy a contract (receiver)
receiver = ts4.BaseContract('tutorial10_2', {})
ts4.register_nickname(receiver.address, 'Receiver')
# Ensure that current value in the receiver contract is default
assert eq(0, receiver.call_getter('m_value'))
value = 0xbeaf
# Encode calling of the receiver contract
payload = sender.call_getter('encode', {'value': value})
# Call receiver contract's method via sender contract
sender.call_method('call_it', {'dest': receiver.address, 'payload': payload})
# Dispatch created internal message from sender to receiver
ts4.dispatch_one_message()
# Ensure that current value was set
assert eq(value, receiver.call_getter('m_value'))
"chunkSize": 0,
"size": 0,
"meta": {
"height": 0,
"width": 0,
"duration": 0,
"extra": "",
"json": "",
},
},
),
)
mint(smc_wallet)
ts4.dispatch_one_message()
ts4.dispatch_messages()
mint(smc_wallet_random)
ts4.dispatch_one_message(100)
ts4.dispatch_messages(cb_false)
mint(smc_wallet_random, 8 * 10**9)
ts4.dispatch_one_message(100)
ts4.dispatch_messages()
# Test only fee minting
smc_nft_root = init_smc_nft_root(smc_wallet.address, 1, 5 * 10**9)
mint(smc_wallet)
ts4.dispatch_one_message(100)
ts4.dispatch_messages(cb_false)
