def setUp(self):
# start node
assert (not node.reset().error)
# create wallet
eosf.set_verbosity([]) # disable logs
self.wallet = eosf.Wallet()
# create eosio account
self.eosio_acc = eosf.AccountMaster()
self.wallet.import_key(self.eosio_acc)
eosf.set_verbosity() # enable logs
# create token deployer account
self.token_deployer_acc = eosf.account(self.eosio_acc, "tkn.deployer")
self.wallet.import_key(self.token_deployer_acc)
# deploy eosio.bios contract
self.eosio_bios_contract = eosf.Contract(self.eosio_acc, "eosio.bios")
assert (not self.eosio_bios_contract.error)
deployment_bios = self.eosio_bios_contract.deploy()
assert (not deployment_bios.error)
# deploy custom eosio.token contract
self.token_contract = eosf.Contract(self.token_deployer_acc,
"eosiotoken/eosio.token",
wast_file='eosio.token.wast',
abi_file='eosio.token.abi')
assert (not self.token_contract.error)
deployment_token = self.token_contract.deploy()
assert (not deployment_token.error)
assert (not self.token_deployer_acc.code().error)
def setUpClass(cls):
testnet = node.reset()
assert (not testnet.error)
wallet = eosf.Wallet()
assert (not wallet.error)
account_master = eosf.AccountMaster()
wallet.import_key(account_master)
assert (not account_master.error)
global account_alice
account_alice = eosf.account(account_master)
wallet.import_key(account_alice)
assert (not account_alice.error)
global account_carol
account_carol = eosf.account(account_master)
wallet.import_key(account_carol)
assert (not account_carol.error)
account_deploy = eosf.account(account_master)
wallet.import_key(account_deploy)
assert (not account_deploy.error)
contract_eosio_bios = eosf.Contract(account_master,
"eosio.bios").deploy()
assert (not contract_eosio_bios.error)
global contract
contract = eosf.Contract(account_deploy, sys.path[0] + "/../")
assert (not contract.error)
deployment = contract.deploy()
assert (not deployment.error)
def test_01(self):
global contract
cprint("""
Create a reference to the new contract
""", 'magenta')
contract = eosf.ContractBuilderFromTemplate(CONTRACT_NAME,
remove_existing=True)
cprint("""
Build the contract abi
""", 'magenta')
self.assertFalse(contract.build_abi().error)
cprint("""
Build the contract wast
""", 'magenta')
self.assertFalse(contract.build_wast().error)
cprint("""
Associate the contract with an account
""", 'magenta')
contract = eosf.Contract(account_deploy, CONTRACT_NAME)
cprint("""
Deploy the contract
""", 'magenta')
self.assertFalse(contract.deploy().error)
cprint("""
Confirm `account_deploy` contains code
""", 'magenta')
self.assertFalse(account_deploy.code().error)
def setUpClass(cls):
global contract
contract = eosf.Contract(account_master, sys.path[0] + "/../build")
if deployment:
assert (not contract.deploy().error)
def test_66(self):
global account_master
global key_owner
global account_test
account_test = cleos.CreateAccount(account_master, "ttt", key_owner,
key_owner)
self.assertTrue(not account_test.error, "CreateAccount ttt")
global contract_test
contract_test = eosf.Contract(account_test, "eosio.token").deploy()
self.assertTrue(not contract_test.error, "Contract(account_test")
def setUpClass(cls):
CONTRACT_NAME = "/Users/markmathis/Projects/EOS/lottery/src/contracts/Lottery"
testnet = node.reset()
assert (not testnet.error)
wallet = eosf.Wallet()
assert (not wallet.error)
account_master = eosf.AccountMaster()
wallet.import_key(account_master)
assert (not account_master.error)
global account_admin
account_admin = eosf.account(account_master)
wallet.import_key(account_admin)
assert (not account_admin.error)
global account_parent
account_parent = eosf.account(account_master)
wallet.import_key(account_parent)
assert (not account_parent.error)
global account_deploy
account_deploy = eosf.account(account_master, name="lotteryxcode")
wallet.import_key(account_deploy)
assert (not account_deploy.error)
global contract
cprint(""" Create a reference to the new contract """, 'magenta')
contract = eosf.ContractBuilder(CONTRACT_NAME)
cprint(""" Not Building the contract abi/wast due to jankyness """,
'magenta')
# cprint(""" Build the contract abi """, 'magenta')
# assert(not contract.build_abi().error)
# cprint(""" Build the contract wast """, 'magenta')
# assert(not contract.build_wast().error)
cprint(""" Associate the contract with an account """, 'magenta')
contract = eosf.Contract(account_deploy, CONTRACT_NAME)
cprint(""" Deploy the contract """, 'magenta')
assert (not contract.deploy().error)
cprint(""" Confirm `account_deploy` contains code """, 'magenta')
assert (not account_deploy.code().error)
def init():
"""
Initialise a test session.
- **global variables**::
eosio: The primary EOSIO account predefined in the genesis file.
alice, bob, carol: Prefabricated demo accounts.
key_owner, key_active: Cryptographic keys.
wallet: The wallet holding keys.
On error, return False.
"""
global wallet
global eosio
global alice
global bob
global carol
wallet = eosf.Wallet()
eosio = eosf.AccountMaster()
wallet.import_key(eosio)
alice = eosf.account(eosio, "alice")
wallet.import_key(alice)
bob = eosf.account(eosio, "bob")
wallet.import_key(bob)
carol = eosf.account(eosio, "carol")
wallet.import_key(carol)
eosf.Contract(eosio, "eosio.bios").deploy()
if setup.is_verbose():
print("# Available test accounts: " + eosio.name + ", " + alice.name +
", " + carol.name + ", " + bob.name + "\n")
sess.init()
# Create accounts
bonder = eosf.account(sess.eosio)
sess.wallet.import_key(bonder)
claimer = eosf.account(sess.eosio)
sess.wallet.import_key(claimer)
arbitrator = eosf.account(sess.eosio)
sess.wallet.import_key(arbitrator)
# Load eosio.token contract
token = eosf.account(sess.eosio, name='eosio.token')
sess.wallet.import_key(token)
token = eosf.Contract(token, 'eosio.token')
token.deploy()
# Create and issue system token
token.push_action('create',
'["{}", "1000000000.0000 SYS"]'.format(token.account),
token.account)
token.push_action('issue', '["{}", "10000.0000 SYS"]'.format(bonder),
token.account)
token.push_action('issue', '["{}", "10000.0000 SYS"]'.format(claimer),
token.account)
# Load tungsten contract
tungsten = eosf.account(sess.eosio)
sess.wallet.import_key(tungsten)
tungsten = eosf.Contract(tungsten, os.path.join(os.getcwd(), 'contract'))
def test():
testnet = node.reset()
assert (not testnet.error)
wallet = eosf.Wallet()
assert (not wallet.error)
account_master = eosf.AccountMaster()
assert (not account_master.error)
wallet.import_key(account_master)
account_alice = eosf.account(account_master)
assert (not account_alice.error)
wallet.import_key(account_alice)
account_bob = eosf.account(account_master)
assert (not account_bob.error)
wallet.import_key(account_bob)
account_carol = eosf.account(account_master)
assert (not account_carol.error)
wallet.import_key(account_carol)
account_deploy = eosf.account(account_master)
assert (not account_deploy.error)
wallet.import_key(account_deploy)
contract_eosio_bios = eosf.Contract(account_master, "eosio.bios").deploy()
assert (not contract_eosio_bios.error)
contract = eosf.Contract(account_deploy, "eosio.token")
assert (not contract.error)
deployment = contract.deploy()
assert (not deployment.error)
cprint("""
Action contract.push_action("create")
""", 'magenta')
assert (not contract.push_action(
"create", '{"issuer":"' + str(account_master) +
'", "maximum_supply":"1000000000.0000 EOS",\
"can_freeze":0, "can_recall":0, "can_whitelist":0}').error)
cprint("""
Action contract.push_action("issue")
""", 'magenta')
assert (not contract.push_action(
"issue", '{"to":"' + str(account_alice) +
'", "quantity":"100.0000 EOS", "memo":"memo"}', account_master).error)
cprint("""
Action contract.push_action("transfer", account_alice)
""", 'magenta')
assert (not contract.push_action(
"transfer", '{"from":"' + str(account_alice) + '", "to":"' +
str(account_carol) + '", "quantity":"25.0000 EOS", "memo":"memo"}',
account_alice).error)
cprint("""
Action contract.push_action("transfer", account_carol)
""", 'magenta')
assert (not contract.push_action(
"transfer", '{"from":"' + str(account_carol) + '", "to":"' +
str(account_bob) + '", "quantity":"13.0000 EOS", "memo":"memo"}',
account_carol).error)
cprint("""
Action contract.push_action("transfer" account_bob)
""", 'magenta')
assert (not contract.push_action(
"transfer", '{"from":"' + str(account_bob) + '", "to":"' +
str(account_alice) + '", "quantity":"2.0000 EOS", "memo":"memo"}',
account_bob).error)
cprint("""
Assign t1 = contract.table("accounts", account_alice)
""", 'magenta')
t1 = contract.table("accounts", account_alice)
cprint("""
Assign t2 = contract.table("accounts", account_bob)
""", 'magenta')
t2 = contract.table("accounts", account_bob)
cprint("""
Assign t3 = contract.table("accounts", account_carol)
""", 'magenta')
t3 = contract.table("accounts", account_carol)
cprint("""
Assert t1.json["rows"][0]["balance"] == '77.0000 EOS'
""", 'magenta')
assert (t1.json["rows"][0]["balance"] == '77.0000 EOS')
cprint("""
Assert t2.json["rows"][0]["balance"] == '11.0000 EOS'
""", 'magenta')
assert (t2.json["rows"][0]["balance"] == '11.0000 EOS')
cprint("""
Assert t3.json["rows"][0]["balance"] == '12.0000 EOS'
""", 'magenta')
assert (t3.json["rows"][0]["balance"] == '12.0000 EOS')
node.stop()
cprint("OK OK OK OK OK OK OK OK 0K 0K 0K 0K", 'green')
def test_63(self):
global account_master
contract_eosio_bios = eosf.Contract(account_master,
"eosio.bios").deploy()
self.assertTrue(not contract_eosio_bios.error, "eosf.Contract(")
print(contract_eosio_bios.contract_path_absolute)
saving = eosf.account(eosio, name="eosio.saving")
stake = eosf.account(eosio, name="eosio.stake")
vpay = eosf.account(eosio, name="eosio.vpay")
wallet.import_key(eosiotoken)
wallet.import_key(bpay)
wallet.import_key(names)
wallet.import_key(ram)
wallet.import_key(ramfee)
wallet.import_key(saving)
wallet.import_key(stake)
wallet.import_key(vpay)
# Load contract (eos/build/contracts/eosio.token) on eosio.token account
token = eosf.Contract(eosiotoken, "eosio.token")
token.deploy()
#Create token
token.push_action(
"create", '{"issuer":"' + eosio.name + '", ' +
'"maximum_supply":"10000000000.0000 SYS"}', eosiotoken)
#Issue to accountMaster eosio
token.push_action(
"issue", '{"to":"' + eosio.name + '", ' +
'"quantity":"1000000000.0000 SYS", ' + '"memo":"memo"}', eosio)
# Load contract (eos/build/contracts/eosio.system) on eosio (Master) account
def test():
testnet = node.reset()
assert(not testnet.error)
wallet = eosf.Wallet()
assert(not wallet.error)
account_master = eosf.AccountMaster()
assert(not account_master.error)
wallet.import_key(account_master)
account_alice = eosf.account(account_master)
assert(not account_alice.error)
wallet.import_key(account_alice)
account_carol = eosf.account(account_master)
assert(not account_carol.error)
wallet.import_key(account_carol)
account_deploy = eosf.account(account_master, name="tic.tac.toe")
assert(not account_deploy.error)
wallet.import_key(account_deploy)
contract_eosio_bios = eosf.Contract(
account_master, "eosio.bios").deploy()
assert(not contract_eosio_bios.error)
contract = eosf.Contract(account_deploy, "tic_tac_toe")
assert(not contract.error)
deployment = contract.deploy()
assert(not deployment.error)
cprint("""
Action contract.push_action("create")
""", 'magenta')
action = contract.push_action(
"create",
'{"challenger":"'
+ str(account_alice) +'", "host":"'
+ str(account_carol) + '"}', account_carol)
print(action)
assert(not action.error)
t = contract.table("games", account_carol)
assert(not t.error)
assert(t.json["rows"][0]["board"][0] == 0)
assert(t.json["rows"][0]["board"][1] == 0)
assert(t.json["rows"][0]["board"][2] == 0)
assert(t.json["rows"][0]["board"][3] == 0)
assert(t.json["rows"][0]["board"][4] == 0)
assert(t.json["rows"][0]["board"][5] == 0)
assert(t.json["rows"][0]["board"][6] == 0)
assert(t.json["rows"][0]["board"][7] == 0)
assert(t.json["rows"][0]["board"][8] == 0)
cprint("""
Action contract.push_action("move")
""", 'magenta')
action = contract.push_action(
"move",
'{"challenger":"'
+ str(account_alice) + '", "host":"'
+ str(account_carol) + '", "by":"'
+ str(account_carol) + '", "mvt":{"row":0, "column":0} }', account_carol)
print(action)
assert(not action.error)
cprint("""
Action contract.push_action("move")
""", 'magenta')
action = contract.push_action(
"move",
'{"challenger":"'
+ str(account_alice) + '", "host":"'
+ str(account_carol) + '", "by":"'
+ str(account_alice) + '", "mvt":{"row":1, "column":1} }', account_alice)
print(action)
assert(not action.error)
t = contract.table("games", account_carol)
assert(not t.error)
assert(t.json["rows"][0]["board"][0] == 1)
assert(t.json["rows"][0]["board"][1] == 0)
assert(t.json["rows"][0]["board"][2] == 0)
assert(t.json["rows"][0]["board"][3] == 0)
assert(t.json["rows"][0]["board"][4] == 2)
assert(t.json["rows"][0]["board"][5] == 0)
assert(t.json["rows"][0]["board"][6] == 0)
assert(t.json["rows"][0]["board"][7] == 0)
assert(t.json["rows"][0]["board"][8] == 0)
cprint("""
Action contract.push_action("restart")
""", 'magenta')
action = contract.push_action(
"restart",
'{"challenger":"'
+ str(account_alice) + '", "host":"'
+ str(account_carol) + '", "by":"' + str(account_carol) + '"}', account_carol)
print(action)
assert(not action.error)
t = contract.table("games", account_carol)
assert(not t.error)
assert(t.json["rows"][0]["board"][0] == 0)
assert(t.json["rows"][0]["board"][1] == 0)
assert(t.json["rows"][0]["board"][2] == 0)
assert(t.json["rows"][0]["board"][3] == 0)
assert(t.json["rows"][0]["board"][4] == 0)
assert(t.json["rows"][0]["board"][5] == 0)
assert(t.json["rows"][0]["board"][6] == 0)
assert(t.json["rows"][0]["board"][7] == 0)
assert(t.json["rows"][0]["board"][8] == 0)
cprint("""
Action contract.push_action("close")
""", 'magenta')
action = contract.push_action(
"close",
'{"challenger":"'
+ str(account_alice) + '", "host":"' + str(account_carol) + '"}', account_carol)
print(action)
assert(not action.error)
node.stop()
cprint("OK OK OK OK OK OK OK OK 0K 0K 0K 0K", 'green')
def test():
testnet = node.reset(is_verbose=False)
assert(not testnet.error)
cprint(
"Started a local testnet: {}".format(not testnet.error),
'magenta')
wallet = eosf.Wallet()
assert(not wallet.error)
cprint(
"The wallet is unlocked: {}".format(not wallet.error),
'magenta')
account_master = eosf.AccountMaster(is_verbose=False)
assert(not account_master.error)
cprint(
"The account_master is in the wallet: {}" \
.format(not account_master.error),
'magenta')
wallet.import_key(account_master)
contract_eosio_bios = eosf.Contract(
account_master, "eosio.bios", is_verbose=False).deploy()
assert(not contract_eosio_bios.error)
cprint(
"The contract_eosio_bios is deployed: {}" \
.format(not contract_eosio_bios.error),
'magenta')
cprint("account_deploy = eosf.account(account_master)", 'magenta')
account_deploy = eosf.account(account_master)
wallet.import_key(account_deploy)
cprint("""contract = eosf.Contract(account_deploy, sys.path[0] + "/../")""", 'magenta')
contract = eosf.Contract(account_deploy, sys.path[0] + "/../")
cprint("contract.deploy()", 'magenta')
assert(not contract.deploy(is_verbose=0).error)
cprint("contract.code()", 'magenta')
code = contract.code()
print("code hash: {}".format(code.code_hash))
cprint("account_alice = eosf.account(account_master)", 'magenta')
account_alice = eosf.account(account_master)
assert(not account_alice.error)
wallet.import_key(account_alice)
cprint("account_carol = eosf.account(account_master)", 'magenta')
account_carol = eosf.account(account_master)
assert(not account_carol.error)
wallet.import_key(account_carol)
cprint(
"""contract.push_action("hi", '{"user":"******"}', account_alice)""", 'magenta')
assert(not contract.push_action(
"hi", '{"user":"******"}', account_alice, output=True).error)
cprint(
"""contract.push_action("hi", '{"user":"******"}', account_carol)""", 'magenta')
assert(not contract.push_action(
"hi", '{"user":"******"}', account_carol, output=True).error)
testnet = node.stop()
assert(not testnet.error)
cprint(
"Closed the local testnet: {}".format(not testnet.error), 'magenta')
def test():
testnet = node.reset()
assert (not testnet.error)
wallet = eosf.Wallet()
assert (not wallet.error)
account_master = eosf.AccountMaster()
assert (not account_master.error)
wallet.import_key(account_master)
account_deploy = eosf.account(account_master)
wallet.import_key(account_deploy)
assert (not account_deploy.error)
account_alice = eosf.account(account_master)
assert (not account_alice.error)
wallet.import_key(account_alice)
account_carol = eosf.account(account_master)
assert (not account_carol.error)
wallet.import_key(account_carol)
contract_eosio_bios = eosf.Contract(account_master, "eosio.bios").deploy()
assert (not contract_eosio_bios.error)
cprint("""
Create a reference to the new contract
""", 'magenta')
contract = eosf.ContractBuilderFromTemplate(CONTRACT_NAME,
remove_existing=True)
cprint("""
Build the contract abi
""", 'magenta')
assert (not contract.build_abi().error)
cprint("""
Associate the contract with an account
""", 'magenta')
contract = eosf.Contract(account_deploy, CONTRACT_NAME)
cprint("""
Build the contract wast
""", 'magenta')
assert (not contract.build_wast().error)
cprint("""
Deploy the contract
""", 'magenta')
assert (not contract.deploy().error)
cprint("""
Confirm `account_deploy` contains code
""", 'magenta')
assert (not account_deploy.code().error)
cprint(
"""
Action contract.push_action("hi", '{"user":"******"}', account_alice)
""", 'magenta')
action = contract.push_action("hi",
'{"user":"******"}',
account_alice)
assert (not action.error)
cprint(
"""
Action contract.push_action("hi", '{"user":"******"}', account_carol)
""", 'magenta')
action = contract.push_action("hi",
'{"user":"******"}',
account_carol)
assert (not action.error)
cprint(
"""
Action contract.push_action("hi", '{"user":"******"}', account_alice)
WARNING: This action should fail due to authority mismatch!
""", 'magenta')
action = contract.push_action("hi",
'{"user":"******"}',
account_alice)
assert (action.error)
contract.delete()
node.stop()
cprint("OK OK OK OK OK OK OK OK 0K 0K 0K 0K", 'green')
def test():
wallet_name = "default"
wallet_pass = "******"
wallet = eosf.Wallet(wallet_name, wallet_pass)
cprint(
"""
Creating wallet: default
Save password to use in the future to unlock this wallet.
Without password imported keys will not be retrievable.
"PW5JhJKaibFbv1cg8sPQiCtiGLh5WP4FFWFeRqXANetKeA8XKn31N"
""", 'magenta')
wallet.index()
wallet.keys()
restored = wallet.restore_accounts(globals())
return
print()
print(account_master.info())
global account_alice
if "account_alice" in restored:
print(account_alice.info())
else:
cprint(
"""
./programs/cleos/cleos -u http://"dev.cryptolions.io:38888 system newaccount
nbhyi5exmjcl ljzirxm1wy1n
EOS6wAChSUxgHpUaG8bdCSKVFEMbmT85qnja1bh7zaWiYDp4sLW98
EOS6wAChSUxgHpUaG8bdCSKVFEMbmT85qnja1bh7zaWiYDp4sLW98
--buy-ram-kbytes 8 --stake-net '100 EOS' --stake-cpu '100 EOS' --transfer
""", 'magenta')
account_alice = eosf.account(account_master,
stake_net="100 EOS",
stake_cpu="100 EOS",
buy_ram_kbytes="8",
transfer=True)
if (not account_alice.error):
wallet.import_key(account_alice)
account_test = eosf.account(account_master,
stake_net="10 EOS",
stake_cpu="10 EOS",
buy_ram_kbytes="8",
transfer=True)
print(account_test.info())
cprint(
"""
name: yeyuoae5rtcg
permissions:
owner 1: 1 EOS8jeCrY4EjJtvcveuy1aK2aFv7rqhGAGvGLJ2Sodazmv2yyi2hm
active 1: 1 EOS5PD28JPyHALuRPPJnm1oR83KxLFKvKkVXx9VrsLjLieHSLq35j
""", 'magenta')
wallet.open()
wallet.unlock()
wallet.import_key(account_test)
return
import setup
import eosf
import cleos
setup.use_keosd(True)
setup.set_nodeos_URL("dev.cryptolions.io:38888")
wallet_name = "default"
wallet_pass = "******"
wallet = eosf.Wallet(wallet_name, wallet_pass)
wallet.restore_accounts(globals())
# print(account_alice.info())
# account_test = eosf.account(
# account_master,
# stake_net="10 EOS",
# stake_cpu="10 EOS",
# buy_ram_kbytes="8",
# transfer=True)
# print(account_test.info())
# cprint("""
# name: yeyuoae5rtcg
# permissions:
# owner 1: 1 EOS8jeCrY4EjJtvcveuy1aK2aFv7rqhGAGvGLJ2Sodazmv2yyi2hm
# active 1: 1 EOS5PD28JPyHALuRPPJnm1oR83KxLFKvKkVXx9VrsLjLieHSLq35j
# """, 'magenta')
# wallet.open()
# wallet.unlock()
# wallet.import_key(account_test)
contract_test = eosf.Contract(
account_test,
"/mnt/c/Workspaces/EOS/eosfactory/contracts/xs_and_os/test/../build/",
dont_broadcast=True,
is_verbose=False).deploy()
import json
print(json.dumps(contract_test.json, indent=4))
def test():
global account_alice
global account_carol
global account_master
global account_bill
global account_test
cprint(
"""
Start session: reset the local EOSIO node, create a wallet object, put the
master account into it.
""", 'magenta')
reset = eosf.reset()
account_master = eosf.AccountMaster()
wallet = eosf.Wallet()
wallet.import_key(account_master)
return
cprint(
"""
Create an account object, named `account_alice`, with the `eosf.account()`,
with default parameters:
-- using the `account_master` as the creator;
-- using a random 12 character long name;
-- using internally created `owner` and `active` keys.
""", 'magenta')
account_alice = eosf.account()
wallet.import_key(account_alice)
account_carol = eosf.account()
wallet.import_key(account_carol)
cprint(
"""
The following `account_bill` object represents the account of the name `bill`
""", 'magenta')
account_bill = eosf.account(name="bill")
wallet.import_key(account_bill)
account_test = eosf.account()
wallet.import_key(account_test)
cprint(
"""
The last account `account_test` is going to take a contract. Now, it does not have
any:
""", 'magenta')
account_test.code()
cprint(
"""
Define a contract, with its code specified in the EOS repository
(build/contracts/eosio.token), and deploy it:
""", 'magenta')
contract_test = eosf.Contract(account_test, "eosio.token")
deploy = contract_test.deploy()
account_test.code()
time.sleep(1)
action = account_test.push_action(
"create", '{"issuer":"' + str(account_master) +
'", "maximum_supply":"1000000000.0000 EOS", \
"can_freeze":0, "can_recall":0, "can_whitelist":0}')
action = contract_test.push_action(
"issue",
'{"to":"' + str(account_alice)
+ '", "quantity":"100.0000 EOS", "memo":"memo"}', \
account_master)
cprint(
"""
Experiments with the `eosio.token` contract are shown elsewere.
Here, we show how the session accounts recover after restarting
the session.
""", 'magenta')
account_alice = None
account_bill = None
account_carol = None
account_test = None
contract_test = None
wallet = None
wallet = eosf.Wallet()
cprint(
"""
The old wallet is restored. It is possible, because there is a password map
in the wallet directory.
Note that this provision is available only if the `keosd` Wallet Manager is not
used and wallets are managed by the local node - this condition is set with the
`setup.use_keosd(False)` statement above.
""", 'magenta')
wallet.restore_accounts(globals())
print(account_alice.info())
cprint("""
Continue operations on the restored account objects:
""", 'magenta')
action = account_test.push_action(
"transfer", '{"from":"' + str(account_alice) + '", "to":"' +
str(account_carol) + '", "quantity":"25.0000 EOS", "memo":"memo"}',
account_alice)
cprint(
"""
Note that the accounts have to be declared global, in order to be
restorable with the current means.
""", 'magenta')
#create user
#load hello.world and yourcontractname contract
#deploy
###############################################
import node
import sess
import eosf
node.reset()
sess.init()
john = eosf.account(sess.eosio, name="john")
sess.wallet.import_key(john)
#change hello.world to yourcontractname
contract = eosf.Contract(john, "hello.world")
contract.build()
contract.code()
contract.deploy()
contract.code()
contract.push_action("hi", '["world"]')
#contract = eosf.Contract(john, "yourcontractname")
#contract.code()
#contract.deploy()
#contract.code()
node.stop()
def test():
global account_master
global account_alice
global account_carol
wallet = eosf.Wallet(wallet_name, wallet_pass)
assert (not wallet.error)
restored = wallet.restore_accounts(globals())
assert ("account_master" in restored)
if (not "account_alice" in restored):
account_alice = eosf.account(account_master,
stake_net="100 EOS",
stake_cpu="100 EOS",
buy_ram_kbytes="80",
transfer=True)
assert (not account_alice.error)
wallet.import_key(account_alice)
if (not "account_carol" in restored):
account_carol = eosf.account(account_master,
stake_net="1000 EOS",
stake_cpu="1000 EOS",
buy_ram_kbytes="1200",
transfer=True)
assert (not account_carol.error)
wallet.import_key(account_carol)
contract = eosf.Contract(account_master, "tic_tac_toe_jungle")
if deployment:
assert (not contract.deploy().error)
cprint("""
Action contract.push_action("create")
""", 'magenta')
action = contract.push_action(
"create", '{"challenger":"' + str(account_alice) + '", "host":"' +
str(account_carol) + '"}', account_carol)
assert (not action.error)
t = contract.table("games", account_carol)
assert (not t.error)
assert (t.json["rows"][0]["board"][0] == 0)
assert (t.json["rows"][0]["board"][1] == 0)
assert (t.json["rows"][0]["board"][2] == 0)
assert (t.json["rows"][0]["board"][3] == 0)
assert (t.json["rows"][0]["board"][4] == 0)
assert (t.json["rows"][0]["board"][5] == 0)
assert (t.json["rows"][0]["board"][6] == 0)
assert (t.json["rows"][0]["board"][7] == 0)
assert (t.json["rows"][0]["board"][8] == 0)
cprint("""
Action contract.push_action("move")
""", 'magenta')
action = contract.push_action(
"move", '{"challenger":"' + str(account_alice) + '", "host":"' +
str(account_carol) + '", "by":"' + str(account_carol) +
'", "mvt":{"row":0, "column":0} }', account_carol)
assert (not action.error)
cprint("""
Action contract.push_action("move")
""", 'magenta')
action = contract.push_action(
"move", '{"challenger":"' + str(account_alice) + '", "host":"' +
str(account_carol) + '", "by":"' + str(account_alice) +
'", "mvt":{"row":1, "column":1} }', account_alice)
assert (not action.error)
t = contract.table("games", account_carol)
assert (not t.error)
assert (t.json["rows"][0]["board"][0] == 1)
assert (t.json["rows"][0]["board"][1] == 0)
assert (t.json["rows"][0]["board"][2] == 0)
assert (t.json["rows"][0]["board"][3] == 0)
assert (t.json["rows"][0]["board"][4] == 2)
assert (t.json["rows"][0]["board"][5] == 0)
assert (t.json["rows"][0]["board"][6] == 0)
assert (t.json["rows"][0]["board"][7] == 0)
assert (t.json["rows"][0]["board"][8] == 0)
cprint("""
Action contract.push_action("restart")
""", 'magenta')
action = contract.push_action(
"restart", '{"challenger":"' + str(account_alice) + '", "host":"' +
str(account_carol) + '", "by":"' + str(account_carol) + '"}',
account_carol)
assert (not action.error)
t = contract.table("games", account_carol)
assert (not t.error)
assert (t.json["rows"][0]["board"][0] == 0)
assert (t.json["rows"][0]["board"][1] == 0)
assert (t.json["rows"][0]["board"][2] == 0)
assert (t.json["rows"][0]["board"][3] == 0)
assert (t.json["rows"][0]["board"][4] == 0)
assert (t.json["rows"][0]["board"][5] == 0)
assert (t.json["rows"][0]["board"][6] == 0)
assert (t.json["rows"][0]["board"][7] == 0)
assert (t.json["rows"][0]["board"][8] == 0)
cprint("""
Action contract.push_action("close")
""", 'magenta')
action = contract.push_action(
"close", '{"challenger":"' + str(account_alice) + '", "host":"' +
str(account_carol) + '"}', account_carol)
assert (not action.error)
cprint("OK OK OK OK OK OK OK OK 0K 0K 0K 0K", 'green')
