DIM Plugins (Java)

Plugins

1. Data Coding
   • Base-58
   • Base-64
   • Hex
   • UTF-8
   • JsON
   • PNF (Portable Network File)
   • TED (Transportable Encoded Data)
2. Digest Digest
   • MD-5
   • SHA-1
   • SHA-256
   • Keccak-256
   • RipeMD-160
3. Cryptography
   • AES-256 (AES/CBC/PKCS7Padding)
   • RSA-1024 (RSA/ECB/PKCS1Padding), (SHA256withRSA)
   • ECC (Secp256k1)
4. Address
   • BTC
   • ETH
5. Meta
   • MKM (Default)
   • BTC
   • ETH
6. Document
   • Visa (User)
   • Profile
   • Bulletin (Group)

Extends

Address

import chat.dim.mem.*;
import chat.dim.protocol.Address;

public class CompatibleAddressFactory extends BaseAddressFactory {

    @Override
    protected Address parse(String address) {
        int len = address == null ? 0 : address.length();
        if (len == 0) {
            assert false : "address empty: " + address;
            return null;
        } else if (len == 8) {
            // "anywhere"
            if (Address.ANYWHERE.equalsIgnoreCase(address)) {
                return Address.ANYWHERE;
            }
        } else if (len == 10) {
            // "everywhere"
            if (Address.EVERYWHERE.equalsIgnoreCase(address)) {
                return Address.EVERYWHERE;
            }
        }
        Address res;
        if (26 <= len && len <= 35) {
            res = BTCAddress.parse(address);
        } else if (len == 42) {
            res = ETHAddress.parse(address);
        } else {
            //throw new AssertionError("invalid address: " + address);
            res = null;
        }
        //
        //  TODO: parse for other types of address
        //
        if (res == null && 4 <= len && len <= 64) {
            res = new UnknownAddress(address);
        }
        assert res != null : "invalid address: " + address;
        return res;
    }

}

import chat.dim.protocol.Address;
import chat.dim.type.ConstantString;

public final class UnknownAddress extends ConstantString implements Address {

    public UnknownAddress(String string) {
        super(string);
    }

    @Override
    public int getNetwork() {
        return 0;  // EntityType.USER;
    }

}

Meta

import java.util.Map;

import chat.dim.mkm.*;
import chat.dim.ext.SharedAccountExtensions;
import chat.dim.protocol.Meta;

public final class CompatibleMetaFactory extends BaseMetaFactory {

    public CompatibleMetaFactory(String algorithm) {
        super(algorithm);
    }

    @Override
    public Meta parseMeta(Map<String, Object> meta) {
        Meta out;
        String type = SharedAccountExtensions.helper.getMetaType(meta, "");
        switch (type) {

            case "MKM":
            case "mkm":
            case "1":
                out = new DefaultMeta(meta);
                break;

            case "BTC":
            case "btc":
            case "2":
                out = new BTCMeta(meta);
                break;

            case "ETH":
            case "eth":
            case "4":
                out = new ETHMeta(meta);
                break;

            default:
                throw new IllegalArgumentException("unknown meta type: " + type);
        }
        return out.isValid() ? out : null;
    }
}

Plugin Loader

import chat.dim.plugins.*;
import chat.dim.protocol.*;

public class CompatiblePluginLoader extends PluginLoader {

   private final CryptoPluginLoader extraPluginLoader = new CryptoPluginLoader();
   //private final NativePluginLoader extraPluginLoader = new NativePluginLoader();

    @Override
    public void load() {
        super.load();
        
        // load extra plugins
        extraPluginLoader.load();
    }

    @Override
    protected void registerAddressFactory() {
        
        Address.setFactory(new CompatibleAddressFactory());
        
    }

    @Override
    protected void registerMetaFactories() {

        Meta.Factory mkm = new CompatibleMetaFactory(MetaType.MKM);
        Meta.Factory btc = new CompatibleMetaFactory(MetaType.BTC);
        Meta.Factory eth = new CompatibleMetaFactory(MetaType.ETH);

        Meta.setFactory("1", mkm);
        Meta.setFactory("2", btc);
        Meta.setFactory("4", eth);

        Meta.setFactory("mkm", mkm);
        Meta.setFactory("btc", btc);
        Meta.setFactory("eth", eth);

        Meta.setFactory("MKM", mkm);
        Meta.setFactory("BTC", btc);
        Meta.setFactory("ETH", eth);
        
    }

}

ExtensionLoader

import chat.dim.dkd.*;
import chat.dim.plugins.ExtensionLoader;
import chat.dim.protocol.*;

public class CommonExtensionLoader extends ExtensionLoader {

    @Override
    public void registerContentFactories() {
        super.registerContentFactories();

        registerCustomizedFactories();
        
    }

    protected void registerCustomizedFactories() {

        // Application Customized
        Content.setFactory(ContentType.APPLICATION, AppCustomizedContent::new);
        Content.setFactory(ContentType.CUSTOMIZED, AppCustomizedContent::new);

    }

    @Override
    protected void registerCommandFactories() {
        super.registerCommandFactories();

        // Handshake
        setCommandFactory(HandshakeCommand.HANDSHAKE, HandshakeCommand::new);

    }

}

Usage

You must load all plugins before your business run:

import chat.dim.plugins.ExtensionLoader;
import chat.dim.plugins.PluginLoader;

public class LibraryLoader implements Runnable {

    private final ExtensionLoader extensionLoader;
    private final PluginLoader pluginLoader;
    private bool loaded = false;

    public LibraryLoader(ExtensionLoader extensionLoader, PluginLoader pluginLoader) {

        if (extensionLoader == null) {
            this.extensionLoader = new CommonExtensionLoader();
        } else {
            this.extensionLoader = extensionLoader;
        }

        if (pluginLoader == null) {
            this.pluginLoader = new CompatiblePluginLoader();
        } else {
            this.pluginLoader = pluginLoader;
        }
    }

    @Override
    public void run() {
        if (loaded) {
            // no need to load it again
            return;
        } else {
            // mark it to loaded
            loaded = true;
        }
        // try to load all plugins
        load();
    }
    
    protected void load() {
        extensionLoader.load();
        pluginLoader.load();
    }
    
    public static void main(String[] args) {
        
        LibraryLoader loader = new 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.

---

Copyright © 2018-2026 Albert Moky