- Data Coding
- Base-58
- Base-64
- Hex
- UTF-8
- JsON
- PNF (Portable Network File)
- TED (Transportable Encoded Data)
- Digest Digest
- MD-5
- SHA-1
- SHA-256
- Keccak-256
- RipeMD-160
- Cryptography
- AES-256 (AES/CBC/PKCS7Padding)
- RSA-1024 (RSA/ECB/PKCS1Padding), (SHA256withRSA)
- ECC (Secp256k1)
- Address
- BTC
- ETH
- Meta
- MKM (Default)
- BTC
- ETH
- Document
- Visa (User)
- Profile
- Bulletin (Group)
from typing import Optional
from dimp import ConstantString
from dimp import Address, ANYWHERE, EVERYWHERE
from dimplugins import BTCAddress, ETHAddress
from dimplugins import BaseAddressFactory
class CompatibleAddressFactory(BaseAddressFactory):
# Override
def _parse(self, address: str) -> Optional[Address]:
size = len(address)
if size == 0:
assert False, 'address should not be empty'
elif size == 8:
# "anywhere"
if address.lower() == 'anywhere':
return ANYWHERE
elif size == 10:
# "everywhere"
if address.lower() == 'everywhere':
return EVERYWHERE
#
# checking normal address
#
if 26 <= size <= 35:
res = BTCAddress.from_str(address=address)
elif size == 42:
res = ETHAddress.from_str(address=address)
else:
# assert False, 'invalid address: %s' % address
res = None
#
# TODO: other types of address
#
if res is None and 4 <= size <= 64:
res = UnknownAddress(address=address)
assert res is not None, 'invalid address: %s' % address
return res
class UnknownAddress(ConstantString, Address):
"""
Unsupported Address
~~~~~~~~~~~~~~~~~~~
"""
def __init__(self, address: str):
super().__init__(string=address)
@property # Override
def network(self) -> int:
return 0 # EntityType.USER.value
from typing import Optional
from dimp import VerifyKey
from dimp import TransportableData
from dimp import Meta
from dimp.plugins import SharedAccountExtensions
from dimplugins import DefaultMeta, BTCMeta, ETHMeta
from dimplugins import BaseMetaFactory
class CompatibleMetaFactory(BaseMetaFactory):
# Override
def parse_meta(self, meta: dict) -> Optional[Meta]:
ext = SharedAccountExtensions()
version = ext.helper.get_meta_type(meta=meta)
if version in ['1', 'mkm', 'MKM']:
# MKM
out = DefaultMeta(meta=meta)
elif version in ['2', 'btc', 'BTC']:
# BTC
out = BTCMeta(meta=meta)
elif version in ['4', 'eth', 'ETH']:
# ETH
out = ETHMeta(meta=meta)
else:
raise TypeError('unknown meta type: %d' % version)
if out.valid:
return out
from dimp import Address, Meta
from dimplugins import PluginLoader
from .address import CompatibleAddressFactory
from .meta import CompatibleMetaFactory
class CompatiblePluginLoader(PluginLoader):
# Override
def _register_address_factory(self):
Address.set_factory(factory=CompatibleAddressFactory())
# Override
def _register_meta_factories(self):
mkm = CompatibleMetaFactory(version=Meta.MKM)
btc = CompatibleMetaFactory(version=Meta.BTC)
eth = CompatibleMetaFactory(version=Meta.ETH)
Meta.set_factory(version='1', factory=mkm)
Meta.set_factory(version='2', factory=btc)
Meta.set_factory(version='4', factory=eth)
Meta.set_factory(version='mkm', factory=mkm)
Meta.set_factory(version='btc', factory=btc)
Meta.set_factory(version='eth', factory=eth)
Meta.set_factory(version='MKM', factory=mkm)
Meta.set_factory(version='BTC', factory=btc)
Meta.set_factory(version='ETH', factory=eth)
from dimp import ContentType
from dimp.plugins import ExtensionLoader
from ..protocol import HandshakeCommand, BaseHandshakeCommand
from ..protocol import AppCustomizedContent
class CommonExtensionLoader(ExtensionLoader):
# Override
def _register_customized_factories(self):
# Application Customized
self._set_content_factory(msg_type=ContentType.APPLICATION, content_class=AppCustomizedContent)
self._set_content_factory(msg_type=ContentType.CUSTOMIZED, content_class=AppCustomizedContent)
# Override
def _register_command_factories(self):
super()._register_command_factories()
# Handshake
self._set_command_factory(cmd=HandshakeCommand.HANDSHAKE, command_class=BaseHandshakeCommand)
You must load all plugins before your business run:
from dimplugins import ExtensionLoader
from dimplugins import PluginLoader
from .compat_loader import CommonExtensionLoader
from .compat_loader import CompatiblePluginLoader
class LibraryLoader:
def __init__(self, extensions: ExtensionLoader = None, plugins: PluginLoader = None):
super().__init__()
self.__extensions = CommonExtensionLoader() if extensions is None else extensions
self.__plugins = CompatiblePluginLoader() if plugins is None else plugins
self.__loaded = False
def run(self):
if self.__loaded:
# no need to load it again
return
else:
# mark it to loaded
self.__loaded = True
# try to load all plugins
self.load()
# protected
def load(self):
self.__extensions.load()
self.__plugins.load()
if __name__ == '__main__':
loader = LibraryLoader()
loader.run()
# do your jobs after all extensions & plugins loaded
You must ensure that every Address
you extend has a Meta
type that can correspond to it one by one.