tronpytool.common.account API documentation

# Module `tronpytool.common.account`

Expand source code

    # --------------------------------------------------------------------
    # Copyright (c) iEXBase. All rights reserved.
    # Licensed under the MIT License.
    # See License.txt in the project root for license information.
    # --------------------------------------------------------------------

    import codecs
    from binascii import unhexlify

    import base58
    import ecdsa
    from eth_account import Account as ETHAccount
    from eth_keys import KeyAPI
    from trx_utils import is_hex, is_bytes

    from tronpytool.common.datastructures import AttributeDict
    from tronpytool.common.key import PrivateKey as PFactory

    class Account:

        def generate_address(self, priv_key=None) -> dict:
            """Generate a random address."""
            if priv_key is None:
                priv_key = PFactory.random()
            return {
                "base58check_address": priv_key.public_key.to_base58check_address(),
                "hex_address": priv_key.public_key.to_hex_address(),
                "private_key": priv_key.hex(),
                "public_key": priv_key.public_key.hex(),
            }

        def get_address_from_passphrase(self, passphrase: str) -> dict:
            """Get an address from a passphrase, compatiable with `wallet/createaddress`."""
            priv_key = PFactory.from_passphrase(passphrase.encode())
            return self.generate_address(priv_key)

        @staticmethod
        def create():
            generate_key = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1)
            return PrivateKey(generate_key.to_string().hex())

        @staticmethod
        def sign_hash(message_hash, private_key):
            if not is_hex(message_hash):
                raise ValueError('Invalid message_hash provided')

            return ETHAccount.signHash(message_hash, private_key)

        @staticmethod
        def recover_hash(message_hash, signature):
            if not is_hex(message_hash):
                raise ValueError('Invalid message_hash provided')

            return ETHAccount.recoverHash(message_hash, signature=signature)

    class Address:

        @staticmethod
        def from_hex(address) -> str:
            """Helper function that will convert a generic value from hex"""
            if not is_hex(address):
                return address
            return base58.b58encode_check(bytes.fromhex(address)).decode()

        @staticmethod
        def to_hex(address) -> str:
            """Helper function that will convert a generic value to hex"""
            if is_hex(address):
                return address.lower().replace('0x', '41', 2)

            return base58.b58decode_check(address).hex().upper()

        @staticmethod
        def to_hex_0x(address) -> str:
            """Helper function that will convert a generic value to hex"""
            if is_hex(address):
                return address
            return '0x' + base58.b58decode_check(address).hex().upper()[2:]

        @staticmethod
        def to_hex_0x_41(address) -> str:
            """Helper function that will convert a generic value to hex"""
            if is_hex(address):
                return address
            return '0x' + base58.b58decode_check(address).hex().upper()

        @staticmethod
        def from_private_key(private_key) -> AttributeDict:
            return PrivateKey(private_key).address

    class PrivateKey(object):

        def __init__(self, private_key: str):
            """Work with private key.
            Getting: PublicKey, PublicToAddress

            Example:::
                PrivateKey("4d1bc37b069b9f2e975c37770b7c87185dc3a10454e3ea024ce1fce8f3eb78bf")
            """
            if private_key is None:
                raise ValueError('Empty private key here')

            _private = unhexlify(bytes(private_key, encoding='utf8'))
            self._key = KeyAPI.PrivateKey(_private)
            self.stored_privkey = private_key
            _length = len(self._key)

            # Key length must not exceed 64 length
            if _length < 64:
                raise ValueError('Key length must not exceed 64 length')

        @property
        def private_key(self) -> str:
            _raw_key = self._key.to_bytes()
            return codecs.decode(codecs.encode(_raw_key, 'hex'), 'ascii')

        @property
        def public_key(self) -> str:
            public_key = self._key.public_key
            return '04' + str(public_key)[2:]

        @property
        def address(self) -> AttributeDict:
            public_key = self._key.public_key
            address = '41' + public_key.to_address()[2:]
            contract_address = '0x' + public_key.to_address()[2:]
            to_base58 = base58.b58encode_check(bytes.fromhex(address))
            # If bytecode then convert to string
            if is_bytes(to_base58):
                to_base58 = to_base58.decode()

            return AttributeDict({
                'hex': address,
                'base58': to_base58,
                'sol': contract_address
            })

        def printKeys(self):
            pair = self.address
            print("public hex: {}".format(pair.hex))
            print("public wallet address in base58: {}".format(pair.base58))
            print("public address in contract: {}".format(pair.sol))

        def __str__(self):
            return self.stored_privkey

        def __bytes__(self):
            return self._key.to_bytes()

## Classes

`class Account`
  Expand source code

      class Account:

          def generate_address(self, priv_key=None) -> dict:
              """Generate a random address."""
              if priv_key is None:
                  priv_key = PFactory.random()
              return {
                  "base58check_address": priv_key.public_key.to_base58check_address(),
                  "hex_address": priv_key.public_key.to_hex_address(),
                  "private_key": priv_key.hex(),
                  "public_key": priv_key.public_key.hex(),
              }

          def get_address_from_passphrase(self, passphrase: str) -> dict:
              """Get an address from a passphrase, compatiable with `wallet/createaddress`."""
              priv_key = PFactory.from_passphrase(passphrase.encode())
              return self.generate_address(priv_key)

          @staticmethod
          def create():
              generate_key = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1)
              return PrivateKey(generate_key.to_string().hex())

          @staticmethod
          def sign_hash(message_hash, private_key):
              if not is_hex(message_hash):
                  raise ValueError('Invalid message_hash provided')

              return ETHAccount.signHash(message_hash, private_key)

          @staticmethod
          def recover_hash(message_hash, signature):
              if not is_hex(message_hash):
                  raise ValueError('Invalid message_hash provided')

              return ETHAccount.recoverHash(message_hash, signature=signature)

  ### Static methods

  `def create()`
    Expand source code

        @staticmethod
        def create():
            generate_key = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1)
            return PrivateKey(generate_key.to_string().hex())

  `def recover_hash(message_hash, signature)`
    Expand source code

        @staticmethod
        def recover_hash(message_hash, signature):
            if not is_hex(message_hash):
                raise ValueError('Invalid message_hash provided')

            return ETHAccount.recoverHash(message_hash, signature=signature)

  `def sign_hash(message_hash, private_key)`
    Expand source code

        @staticmethod
        def sign_hash(message_hash, private_key):
            if not is_hex(message_hash):
                raise ValueError('Invalid message_hash provided')

            return ETHAccount.signHash(message_hash, private_key)

  ### Methods

  `def generate_address(self, priv_key=None) ‑> dict`

    Generate a random address.

    Expand source code

        def generate_address(self, priv_key=None) -> dict:
            """Generate a random address."""
            if priv_key is None:
                priv_key = PFactory.random()
            return {
                "base58check_address": priv_key.public_key.to_base58check_address(),
                "hex_address": priv_key.public_key.to_hex_address(),
                "private_key": priv_key.hex(),
                "public_key": priv_key.public_key.hex(),
            }

  `def get_address_from_passphrase(self, passphrase: str) ‑> dict`

    Get an address from a passphrase, compatiable with `wallet/createaddress`.

    Expand source code

        def get_address_from_passphrase(self, passphrase: str) -> dict:
            """Get an address from a passphrase, compatiable with `wallet/createaddress`."""
            priv_key = PFactory.from_passphrase(passphrase.encode())
            return self.generate_address(priv_key)

`class Address`
  Expand source code

      class Address:

          @staticmethod
          def from_hex(address) -> str:
              """Helper function that will convert a generic value from hex"""
              if not is_hex(address):
                  return address
              return base58.b58encode_check(bytes.fromhex(address)).decode()

          @staticmethod
          def to_hex(address) -> str:
              """Helper function that will convert a generic value to hex"""
              if is_hex(address):
                  return address.lower().replace('0x', '41', 2)

              return base58.b58decode_check(address).hex().upper()

          @staticmethod
          def to_hex_0x(address) -> str:
              """Helper function that will convert a generic value to hex"""
              if is_hex(address):
                  return address
              return '0x' + base58.b58decode_check(address).hex().upper()[2:]

          @staticmethod
          def to_hex_0x_41(address) -> str:
              """Helper function that will convert a generic value to hex"""
              if is_hex(address):
                  return address
              return '0x' + base58.b58decode_check(address).hex().upper()

          @staticmethod
          def from_private_key(private_key) -> AttributeDict:
              return PrivateKey(private_key).address

  ### Static methods

  `def from_hex(address) ‑> str`

    Helper function that will convert a generic value from hex

    Expand source code

        @staticmethod
        def from_hex(address) -> str:
            """Helper function that will convert a generic value from hex"""
            if not is_hex(address):
                return address
            return base58.b58encode_check(bytes.fromhex(address)).decode()

  `def from_private_key(private_key) ‑> AttributeDict`
    Expand source code

        @staticmethod
        def from_private_key(private_key) -> AttributeDict:
            return PrivateKey(private_key).address

  `def to_hex(address) ‑> str`

    Helper function that will convert a generic value to hex

    Expand source code

        @staticmethod
        def to_hex(address) -> str:
            """Helper function that will convert a generic value to hex"""
            if is_hex(address):
                return address.lower().replace('0x', '41', 2)

            return base58.b58decode_check(address).hex().upper()

  `def to_hex_0x(address) ‑> str`

    Helper function that will convert a generic value to hex

    Expand source code

        @staticmethod
        def to_hex_0x(address) -> str:
            """Helper function that will convert a generic value to hex"""
            if is_hex(address):
                return address
            return '0x' + base58.b58decode_check(address).hex().upper()[2:]

  `def to_hex_0x_41(address) ‑> str`

    Helper function that will convert a generic value to hex

    Expand source code

        @staticmethod
        def to_hex_0x_41(address) -> str:
            """Helper function that will convert a generic value to hex"""
            if is_hex(address):
                return address
            return '0x' + base58.b58decode_check(address).hex().upper()

`class PrivateKey (private_key: str)`

  Work with private key. Getting: PublicKey, PublicToAddress

  Example::: PrivateKey("4d1bc37b069b9f2e975c37770b7c87185dc3a10454e3ea024ce1fce8f3eb78bf")

  Expand source code

      class PrivateKey(object):

          def __init__(self, private_key: str):
              """Work with private key.
              Getting: PublicKey, PublicToAddress

              Example:::
                  PrivateKey("4d1bc37b069b9f2e975c37770b7c87185dc3a10454e3ea024ce1fce8f3eb78bf")
              """
              if private_key is None:
                  raise ValueError('Empty private key here')

              _private = unhexlify(bytes(private_key, encoding='utf8'))
              self._key = KeyAPI.PrivateKey(_private)
              self.stored_privkey = private_key
              _length = len(self._key)

              # Key length must not exceed 64 length
              if _length < 64:
                  raise ValueError('Key length must not exceed 64 length')

          @property
          def private_key(self) -> str:
              _raw_key = self._key.to_bytes()
              return codecs.decode(codecs.encode(_raw_key, 'hex'), 'ascii')

          @property
          def public_key(self) -> str:
              public_key = self._key.public_key
              return '04' + str(public_key)[2:]

          @property
          def address(self) -> AttributeDict:
              public_key = self._key.public_key
              address = '41' + public_key.to_address()[2:]
              contract_address = '0x' + public_key.to_address()[2:]
              to_base58 = base58.b58encode_check(bytes.fromhex(address))
              # If bytecode then convert to string
              if is_bytes(to_base58):
                  to_base58 = to_base58.decode()

              return AttributeDict({
                  'hex': address,
                  'base58': to_base58,
                  'sol': contract_address
              })

          def printKeys(self):
              pair = self.address
              print("public hex: {}".format(pair.hex))
              print("public wallet address in base58: {}".format(pair.base58))
              print("public address in contract: {}".format(pair.sol))

          def __str__(self):
              return self.stored_privkey

          def __bytes__(self):
              return self._key.to_bytes()

  ### Instance variables

  `var address : AttributeDict`
    Expand source code

        @property
        def address(self) -> AttributeDict:
            public_key = self._key.public_key
            address = '41' + public_key.to_address()[2:]
            contract_address = '0x' + public_key.to_address()[2:]
            to_base58 = base58.b58encode_check(bytes.fromhex(address))
            # If bytecode then convert to string
            if is_bytes(to_base58):
                to_base58 = to_base58.decode()

            return AttributeDict({
                'hex': address,
                'base58': to_base58,
                'sol': contract_address
            })

  `var private_key : str`
    Expand source code

        @property
        def private_key(self) -> str:
            _raw_key = self._key.to_bytes()
            return codecs.decode(codecs.encode(_raw_key, 'hex'), 'ascii')

  `var public_key : str`
    Expand source code

        @property
        def public_key(self) -> str:
            public_key = self._key.public_key
            return '04' + str(public_key)[2:]

  ### Methods

  `def printKeys(self)`
    Expand source code

        def printKeys(self):
            pair = self.address
            print("public hex: {}".format(pair.hex))
            print("public wallet address in base58: {}".format(pair.base58))
            print("public address in contract: {}".format(pair.sol))