def test_local_testnet(self): setup.use_keosd(False) eosf.reset(is_verbose=0) eosf.stop(is_verbose=0) eosf.run(is_verbose=0) account_master = eosf.AccountMaster() print(account_master.info())
def test_reopen_with_stored_password(self): setup.use_keosd(False) eosf.reset(is_verbose=0) eosf.Wallet() eosf.stop(is_verbose=0) node.run(is_verbose=0) wallet = eosf.Wallet() self.assertTrue(wallet.error)
def test_invalid_password(self): setup.use_keosd(False) eosf.reset(is_verbose=0) wallet = eosf.Wallet() eosf.stop(is_verbose=0) eosf.run(is_verbose=0) wallet = eosf.Wallet( "default", "EOS6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV") self.assertTrue(wallet.error)
def test(): cprint(""" Start a local test EOSIO node, use `eosf.reset()`: """, 'magenta') reset = eosf.reset() cprint(""" Create a local wallet, use `wallet = eosf.Wallet()`: """, 'magenta') wallet = eosf.Wallet(is_verbose=2) account_master = eosf.AccountMaster() cprint("wallet.import_key(account_master):", 'magenta') wallet.import_key(account_master) account_bill = eosf.account() cprint("wallet.import_key(account_bill):", 'magenta') wallet.import_key(account_bill) cprint("wallet.import_key(alice):", 'magenta') account_alice = eosf.account() wallet.import_key(account_alice) return
def setUpClass(cls): global wallet global account_master reset = eosf.reset() account_master = eosf.AccountMaster() wallet = eosf.Wallet() wallet.import_key(account_master)
def test_04(self): print(""" Start a local test EOSIO node: """) reset = eosf.reset() self.assertTrue(not reset.error) print(""" Create a local wallet (not with EOSIO `keosd` application): """) global wallet wallet = eosf.Wallet() self.assertTrue(not wallet.error) print(""" Implement the `eosio` master account as a `cleos.AccountMaster` object: """) global account_master account_master = eosf.AccountMaster() wallet.import_key(account_master) print(""" Create accounts `alice`, `bob` and `carol`: """) global alice alice = eosf.account() self.assertTrue(not alice.error) alice.account wallet.import_key(alice) global bob bob = eosf.account() self.assertTrue(not bob.error) wallet.import_key(bob) global carol carol = eosf.account() self.assertTrue(not carol.error) wallet.import_key(carol)
def test_05(self): node_reset = eosf.reset() self.assertTrue(node_reset)
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')