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')