docs: def create_account(
          self,
          account_name,
          registrar=None,
          referrer="1.2.0",
          referrer_percent=50,
          owner_key=None,
          active_key=None,
          memo_key=None,
          password=None,
          additional_owner_keys=[],
          additional_active_keys=[],
          additional_owner_accounts=[],
          additional_active_accounts=[],
          proxy_account="proxy-to-self",
          storekeys=True,
          **kwargs
      ):
          """ Create new account on PeerPlays
  
              The brainkey/password can be used to recover all generated keys
              (see `peerplaysbase.account` for more details.
  
              By default, this call will use ``default_account`` to
              register a new name ``account_name`` with all keys being
              derived from a new brain key that will be returned. The
              corresponding keys will automatically be installed in the
              wallet.
  
              .. warning:: Don't call this method unless you know what
                            you are doing! Be sure to understand what this
                            method does and where to find the private keys
                            for your account.
  
              .. note:: Please note that this imports private keys
                        (if password is present) into the wallet by
                        default. However, it **does not import the owner
                        key** for security reasons. Do NOT expect to be
                        able to recover it from the wallet if you lose
                        your password!
  
              :param str account_name: (**required**) new account name
              :param str registrar: which account should pay the registration fee
                                  (defaults to ``default_account``)
              :param str owner_key: Main owner key
              :param str active_key: Main active key
              :param str memo_key: Main memo_key
              :param str password: Alternatively to providing keys, one
                                   can provide a password from which the
                                   keys will be derived
              :param array additional_owner_keys:  Additional owner public keys
              :param array additional_active_keys: Additional active public keys
              :param array additional_owner_accounts: Additional owner account
                  names
              :param array additional_active_accounts: Additional acctive account
                  names
              :param bool storekeys: Store new keys in the wallet (default:
                  ``True``)
              :raises AccountExistsException: if the account already exists on
                  the blockchain
  
          """
          if not registrar and self.config["default_account"]:
              registrar = self.config["default_account"]
          if not registrar:
              raise ValueError(
                  "Not registrar account given. Define it with "
                  "registrar=x, or set the default_account using 'peerplays'"
              )
          if password and (owner_key or active_key or memo_key):
              raise ValueError("You cannot use 'password' AND provide keys!")
  
          try:
              Account(account_name, blockchain_instance=self)
              raise AccountExistsException
          except:
              pass
  
          referrer = Account(referrer, blockchain_instance=self)
          registrar = Account(registrar, blockchain_instance=self)
  
          " Generate new keys from password"
          from peerplaysbase.account import PasswordKey, PublicKey
  
          if password:
              active_key = PasswordKey(account_name, password, role="active")
              owner_key = PasswordKey(account_name, password, role="owner")
              memo_key = PasswordKey(account_name, password, role="memo")
              active_pubkey = active_key.get_public_key()
              owner_pubkey = owner_key.get_public_key()
              memo_pubkey = memo_key.get_public_key()
              active_privkey = active_key.get_private_key()
              # owner_privkey   = owner_key.get_private_key()
              memo_privkey = memo_key.get_private_key()
              # store private keys
              if storekeys:
                  # self.wallet.addPrivateKey(str(owner_privkey))
                  self.wallet.addPrivateKey(str(active_privkey))
                  self.wallet.addPrivateKey(str(memo_privkey))
          elif owner_key and active_key and memo_key:
              active_pubkey = PublicKey(active_key, prefix=self.prefix)
              owner_pubkey = PublicKey(owner_key, prefix=self.prefix)
              memo_pubkey = PublicKey(memo_key, prefix=self.prefix)
          else:
              raise ValueError(
                  "Call incomplete! Provide either a password or public keys!"
              )
          owner = format(owner_pubkey, self.prefix)
          active = format(active_pubkey, self.prefix)
          memo = format(memo_pubkey, self.prefix)
  
          owner_key_authority = [[owner, 1]]
          active_key_authority = [[active, 1]]
          owner_accounts_authority = []
          active_accounts_authority = []
  
          # additional authorities
          for k in additional_owner_keys:
              owner_key_authority.append([k, 1])
          for k in additional_active_keys:
              active_key_authority.append([k, 1])
  
          for k in additional_owner_accounts:
              addaccount = Account(k, blockchain_instance=self)
              owner_accounts_authority.append([addaccount["id"], 1])
          for k in additional_active_accounts:
              addaccount = Account(k, blockchain_instance=self)
              active_accounts_authority.append([addaccount["id"], 1])
  
          # voting account
          voting_account = Account(
              proxy_account or "proxy-to-self", blockchain_instance=self
          )
  
          op = {
              "fee": {"amount": 0, "asset_id": "1.3.0"},
              "registrar": registrar["id"],
              "referrer": referrer["id"],
              "referrer_percent": int(referrer_percent * 100),
              "name": account_name,
              "owner": {
                  "account_auths": owner_accounts_authority,
                  "key_auths": owner_key_authority,
                  "address_auths": [],
                  "weight_threshold": 1,
              },
              "active": {
                  "account_auths": active_accounts_authority,
                  "key_auths": active_key_authority,
                  "address_auths": [],
                  "weight_threshold": 1,
              },
              "options": {
                  "memo_key": memo,
                  "voting_account": voting_account["id"],
                  "num_witness": 0,
                  "num_committee": 0,
                  "votes": [],
                  "extensions": [],
              },
              "extensions": {},
              "prefix": self.prefix,
          }
          op = operations.Account_create(**op)
          return self.finalizeOp(op, registrar, "active", **kwargs)