def test_20(self): global key_owner key_owner = cleos.CreateKey("owner") self.assertTrue(not key_owner.error) print(json.dumps(key_owner.json, indent=4)) print(key_owner.name) print(key_owner.key_private) print(key_owner.key_public)
def __init__( self, name="", owner_key_public="", active_key_public="", is_verbose=1, verbosity=None): is_verbose = self.verify_is_verbose(verbosity, is_verbose) self.EOSF_TRACE(""" ######### Get master account. """) self.DEBUG(""" Local node is running: {} """.format(cleos.node_is_running())) AccountEosio.__init__(self, is_verbose) self.DEBUG(""" Name is `{}` Wallet URL is {} Use keosd status is {} self._out: {} self.err_msg: {} """.format( self.name, cleos.wallet_url(), setup.is_use_keosd(), self._out, self.err_msg )) if cleos.is_notrunningnotkeosd_error(self): self.ERROR(self.err_msg) return if self.is_local_testnet(): return self.account_info = "The account is not opened yet!" self.DEBUG("It is not the local testnet.") #cleos.set_wallet_url_arg(node, "") # not local testnet: if not owner_key_public: # print data for registration if not name: self.name = cleos.account_name() else: self.name = name self.owner_key = cleos.CreateKey("owner", is_verbose=0) self.active_key = cleos.CreateKey("active", is_verbose=0) self.OUT(""" Use the following data to register a new account on a public testnet: Accout Name: {} Owner Public Key: {} Owner Private Key: {} Active Public Key: {} Active Private Key: {} """.format( self.name, self.owner_key.key_public, self.owner_key.key_private, self.active_key.key_public, self.active_key.key_private )) else: # restore the master account self.name = name self.owner_key = cleos.CreateKey("owner", owner_key_public, is_verbose=0) if not active_key_public: self.active_key = owner_key else: self.active_key = cleos.CreateKey( "active", active_key_public, is_verbose=0) account_ = cleos.GetAccount(name, is_verbose=-1) if not account_.error: self.account_info = str(account_)
def account_object( account_object_name, creator="", stake_net="", stake_cpu="", account_name="", owner_key="", active_key="", permission = "", buy_ram_kbytes=0, buy_ram="", transfer=False, expiration_sec=30, skip_signature=0, dont_broadcast=0, forceUnique=0, max_cpu_usage=0, max_net_usage=0, ref_block="", restore=False, is_verbose=1, verbosity=None): self = _Eosf() is_verbose = self.verify_is_verbose(verbosity, is_verbose) objects = None context_locals = inspect.stack()[1][0].f_locals context_globals = inspect.stack()[1][0].f_globals objects = {**context_globals, **context_locals} wallet = None wallets = [] for name in objects: if isinstance(objects[name], Wallet): wallets.append(name) wallet = objects[name] error = False if len(wallets) == 0: self.ERROR(""" Cannot find any `Wallet` object. Add the definition of an `Wallet` object, for example: `wallet = eosf.Wallet()` """) if len(wallets) > 1: self.ERROR(""" Too many `Wallet` objects. Can be precisely one wallet object in the scope, but there is many: {} """.format(wallets)) account_map_ = account_map() for name, acc_name in account_map_.items(): if acc_name == account_object_name: self.ERROR( """ The given account object name `{}`({}) points to an existing account, mapped in a file in directory: `{}` Cannot overwrite it. """.format(acc_name, name, wallet_dir())) # create the account object: account_object = None if restore: if creator: account_name = creator self.EOSF_TRACE(""" ######### Create an account object named `{}`, for the blockchain account `{}`. """.format(account_object_name, account_name)) account_object = cleos.RestoreAccount(account_name, is_verbose) else: if not account_name: account_name = cleos.account_name() if owner_key: if not active_key: active_key = owner_key else: owner_key = cleos.CreateKey("owner", is_verbose=-1) active_key = cleos.CreateKey("active", is_verbose=-1) if not creator: creator = AccountMaster() if stake_net: self.EOSF_TRACE(""" ######### Create an account object named `{}`, for a new, properly paid, blockchain account `{}`. """.format(account_object_name, account_name)) account_object = cleos_system.SystemNewaccount( creator, account_name, owner_key, active_key, stake_net, stake_cpu, permission, buy_ram_kbytes, buy_ram, transfer, expiration_sec, skip_signature, dont_broadcast, forceUnique, max_cpu_usage, max_net_usage, ref_block, is_verbose ) else: self.EOSF_TRACE(""" ######### Create an account object named `{}' for a new local testnet account `{}`. """.format(account_object_name, account_name)) account_object = cleos.CreateAccount( creator, account_name, owner_key, active_key, permission, expiration_sec, skip_signature, dont_broadcast, forceUnique, max_cpu_usage, max_net_usage, ref_block, is_verbose=is_verbose ) if account_object.error: self.ERROR(account_object.err_msg) else: self.EOSF("""The account object created.""") account_object.owner_key = owner_key account_object.active_key = active_key # append account methodes to the account_object: def code(self, code="", abi="", wasm=False): return cleos.GetCode( account_object, code, abi, is_verbose=account_object.is_verbose) account_object.code = types.MethodType(code, account_object) def set_contract( self, contract_dir, wast_file="", abi_file="", permission="", expiration_sec=30, skip_signature=0, dont_broadcast=0, forceUnique=0, max_cpu_usage=0, max_net_usage=0, ref_block=""): account_object.set_contract = cleos.SetContract( account_object, contract_dir, wast_file, abi_file, permission, expiration_sec, skip_signature, dont_broadcast, forceUnique, max_cpu_usage, max_net_usage, ref_block, is_verbose=account_object.is_verbose ) return account_object.set_contract account_object.set_contract = types.MethodType( set_contract , account_object) def push_action( self, action, data, permission="", expiration_sec=30, skip_signature=0, dont_broadcast=0, forceUnique=0, max_cpu_usage=0, max_net_usage=0, ref_block=""): if not permission: permission = account_object.name else: try: # permission is an account: permission = permission.name except: # permission is the name of an account: permission = permission account_object.action = cleos.PushAction( account_object, action, data, permission, expiration_sec, skip_signature, dont_broadcast, forceUnique, max_cpu_usage, max_net_usage, ref_block, is_verbose=account_object.is_verbose) if not account_object.action.error: try: account_object._console = account_object.action.console if account_object.is_verbose > 0: print(account_object._console + "\n") except: pass return account_object.action account_object.push_action = types.MethodType( push_action , account_object) def table( self, table_name, scope="", binary=False, limit=10, key="", lower="", upper=""): account_object._table = cleos.GetTable( account_object, table_name, scope, binary, limit, key, lower, upper, is_verbose=account_object.is_verbose) return account_object._table account_object.table = types.MethodType( table, account_object) def __str__(self): return account_object.name account_object.__str__ = types.MethodType( __str__, account_object) # export the account object to the globals in the calling module: context_globals[account_object_name] = account_object # put the account object to the wallet: wallet.open() wallet.unlock() wallet.import_key(account_object) return account_object
def account( creator, name="", owner_key="", active_key="", permission = "", stake_net="", stake_cpu="", buy_ram_kbytes=0, buy_ram="", transfer=False, expiration_sec=30, skip_signature=0, dont_broadcast=0, forceUnique=0, max_cpu_usage=0, max_net_usage=0, ref_block="", is_verbose=1, restore=False): account_object = None if restore: if creator: name = creator account_object = cleos.RestoreAccount(name, is_verbose) else: if not name: name = cleos.account_name() if owner_key: if not active_key: active_key = owner_key else: owner_key = cleos.CreateKey("owner", is_verbose=-1) active_key = cleos.CreateKey("active", is_verbose=-1) if stake_net: account_object = cleos_system.SystemNewaccount( creator, name, owner_key, active_key, stake_net, stake_cpu, permission, buy_ram_kbytes, buy_ram, transfer, expiration_sec, skip_signature, dont_broadcast, forceUnique, max_cpu_usage, max_net_usage, ref_block, is_verbose ) else: account_object = cleos.CreateAccount( creator, name, owner_key, active_key, permission, expiration_sec, skip_signature, dont_broadcast, forceUnique, max_cpu_usage, max_net_usage, ref_block, is_verbose=is_verbose ) account_object.owner_key = owner_key account_object.active_key = active_key def code(self, code="", abi="", wasm=False): return cleos.GetCode( account_object, code, abi, is_verbose=account_object.is_verbose) account_object.code = types.MethodType( code, account_object) def set_contract( self, contract_dir, wast_file="", abi_file="", permission="", expiration_sec=30, skip_signature=0, dont_broadcast=0, forceUnique=0, max_cpu_usage=0, max_net_usage=0, ref_block=""): account_object.set_contract = cleos.SetContract( account_object, contract_dir, wast_file, abi_file, permission, expiration_sec, skip_signature, dont_broadcast, forceUnique, max_cpu_usage, max_net_usage, ref_block, is_verbose=account_object.is_verbose ) return account_object.set_contract account_object.set_contract = types.MethodType( set_contract , account_object) def push_action( self, action, data, permission="", expiration_sec=30, skip_signature=0, dont_broadcast=0, forceUnique=0, max_cpu_usage=0, max_net_usage=0, ref_block=""): if not permission: permission = account_object.name else: try: # permission is an account: permission = permission.name except: # permission is the name of an account: permission = permission account_object.action = cleos.PushAction( account_object, action, data, permission, expiration_sec, skip_signature, dont_broadcast, forceUnique, max_cpu_usage, max_net_usage, ref_block, is_verbose=account_object.is_verbose) if not account_object.action.error: try: account_object._console = account_object.action.console if account_object.is_verbose > 0: print(account_object._console + "\n") except: pass return account_object.action account_object.push_action = types.MethodType( push_action , account_object) def table( self, table_name, scope="", binary=False, limit=10, key="", lower="", upper=""): account_object._table = cleos.GetTable( account_object, table_name, scope, binary, limit, key, lower, upper, is_verbose=account_object.is_verbose) return account_object._table account_object.table = types.MethodType( table, account_object) def __str__(self): return account_object.name account_object.__str__ = types.MethodType( __str__, account_object) return account_object