Plugins

public async load(): Promise<void> {
    const app = express();
    app.get('/api/config', (_req, res) => {
        const config = {
            applicationUrl: this.config.applicationUrl,
            amount: this.config.amount,
            tokenPrefix: this.config.tokenPrefix,
            captchaSitekey: this.config.captchaSitekey,
            logoURL: this.config.logoURL,
            faucetAddress: this._state.publicKey
                ? cryptography.address.getLisk32AddressFromPublicKey(this._state.publicKey)
                : undefined,
        };
        res.json(config);
    });
    app.use(express.static(join(__dirname, '../../build')));
    this._server = app.listen(this.config.port, this.config.host);
}

public async unload(): Promise<void> {
    return new Promise((resolve, reject) => {
        this._server.close(err => {
            if (err) {
                reject(err);
                return;
            }
            resolve();
        });
    });
}

export class Endpoint extends BasePluginEndpoint {

    // ...

    public async authorize(context: PluginEndpointContext): Promise<{ result: string }> {
		validator.validate(authorizeParamsSchema, context.params);
		const { enable, password } = context.params;
		try {
			const parsedEncryptedPassphrase = cryptography.encrypt.parseEncryptedMessage(
				this._config.encryptedPassphrase,
			);
			const passphrase = await cryptography.encrypt.decryptMessageWithPassword(
				parsedEncryptedPassphrase,
				password as string,
				'utf-8',
			);
			const { publicKey } = cryptography.legacy.getPrivateAndPublicKeyFromPassphrase(passphrase);
			this._state.publicKey = enable ? publicKey : undefined;
			this._state.passphrase = enable ? passphrase : undefined;
			const changedState = enable ? 'enabled' : 'disabled';
			return {
				result: `Successfully ${changedState} the faucet.`,
			};
		} catch (error) {
			throw new Error('Password given is not valid.');
		}
	}

    // ...
}

public get nodeModulePath(): string {
    return __filename;
}

public get name(): string {
    const name = this.constructor.name.replace('Plugin', '');
    return name.charAt(0).toLowerCase() + name.substr(1);
}

public get dataPath(): string {
    const dirs = systemDirs(this.appConfig.system.dataPath);
    return join(dirs.plugins, this.name, 'data');
}

import { BasePlugin, PluginInitContext, cryptography } from 'lisk-sdk';
import { configSchema } from './schemas'; //Configuration Schema
import { FaucetPluginConfig, State } from './types'; // Types Object
import { Endpoint } from './endpoint';

// A plugin with Custom Plugin configuration needs a configuration schema and types objects.
export class FaucetPlugin extends BasePlugin<FaucetPluginConfig> { //Config Type Object
    public configSchema = configSchema; //Schema Object

}

export const configSchema = {
	$id: '#/plugins/liskFaucet/config',
	type: 'object',
	properties: {
		port: {
			type: 'integer',
			minimum: 1,
			maximum: 65535,
		},
		host: {
			type: 'string',
			format: 'ip',
		},
		encryptedPassphrase: {
			type: 'string',
			format: 'encryptedPassphrase',
			description: 'Encrypted passphrase of the genesis account',
		},
		applicationUrl: {
			type: 'string',
			format: 'uri',
			description: 'URL to connect',
		},
		fee: {
			type: 'string',
			description: 'The transaction fee used to faucet an account',
		},
		amount: {
			type: 'string',
			description: 'Number of tokens to fund an account per request',
		},
		tokenPrefix: {
			type: 'string',
			description: 'The token prefix associated with your application',
		},
		logoURL: {
			type: 'string',
			format: 'uri',
			description: 'The URL of the logo used on the UI',
		},
		captchaSecretkey: {
			type: 'string',
			description: 'The re-captcha secret key',
		},
		captchaSitekey: {
			type: 'string',
			description: 'The re-captcha site key',
		},
	},
	required: ['encryptedPassphrase', 'captchaSecretkey', 'captchaSitekey'],
	default: {
		port: 4004,
		host: '127.0.0.1',
		applicationUrl: 'ws://localhost:8080/ws',
		fee: '0.1',
		amount: '100',
		tokenPrefix: 'lsk',
	},
};

export const fundParamsSchema = {
	$id: '/lisk/faucet/fund',
	type: 'object',
	required: ['address'],
	properties: {
		address: {
			type: 'string',
			format: 'hex',
		},
		token: {
			type: 'string',
		},
	},
};

export interface FaucetPluginConfig {
	port: number;
	host: string;
	encryptedPassphrase: string;
	captchaSitekey: string;
	captchaSecretkey: string;
	applicationUrl: string;
	fee: string;
	amount: string;
	tokenPrefix: string;
	captchaSecret: string;
	logoURL?: string;
}

export interface State {
	publicKey?: Buffer;
	passphrase?: string;
}