 {
                return connectionManager.importIdentity(connectionProfile, connectionOptions, id, certificate, privateKey);
            })
           .then(() =&gt; {
                callback(null);
                LOG.exit(method);
            })
           .catch((error) =&gt; {
                LOG.error(method, error);
                callback(ConnectorServer.serializerr(error));
                LOG.exit(method, null);
            });
    }
&nbsp;
    /**
     * Handle a request from the client to remove an identity.
     * @param {string} connectionProfile The name of the connection profile
     * @param {object} connectionOptions The connection options loaded from the profile
     * @param {string} id the id to associate with the identity
     * @param {function} callback The callback to call when complete.
     */
    async connectionManagerRemoveIdentity(connectionProfile, connectionOptions, id, callback) {
        const method = 'connectionManagerRemoveIdentity';
        LOG.entry(method, connectionProfile, id);
        try {
            connectionOptions.wallet = await this.businessNetworkCardStore.getWallet(connectionOptions.cardName);
            const connectionManager = await this.connectionProfileManager.getConnectionManagerByType(ConnectorServer.getConnectionType(connectionOptions));
            const deleted = await connectionManager.removeIdentity(connectionProfile, connectionOptions, id);
            callback(null, deleted);
            LOG.exit(method);
        } catch (error) {
            LOG.error(method, error);
            callback(ConnectorServer.serializerr(error));
            LOG.exit(method, null);
        }
    }
&nbsp;
&nbsp;
    /**
     * Obtain the credentials associated with a given identity.
     * @param {String} connectionProfileName - Name of the connection profile.
     * @param {Object} connectionOptions - connection options loaded from the profile.
     * @param {String} id - Name of the identity.
     * @param {function} callback The callback to call when complete.
     * @return {Promise} Promise that resolves to credentials.
     */
    async connectionManagerExportIdentity (connectionProfileName, connectionOptions, id, callback) {
        const method = 'connectionManagerExportIdentity';
        LOG.entry(method, connectionProfileName, connectionOptions, id);
        connectionOptions.wallet = await this.businessNetworkCardStore.getWallet(connectionOptions.cardName);
        return this.connectionProfileManager.getConnectionManagerByType(ConnectorServer.getConnectionType(connectionOptions))
           .then((connectionManager) =&gt; {
                return connectionManager.exportIdentity(connectionProfileName, connectionOptions, id);
            })
           .then((credentials) =&gt; {
                callback(null, credentials);
                LOG.exit(method, credentials);
            })
           .catch((error) =&gt; {
                LOG.error(method, error);
                callback(ConnectorServer.serializerr(error));
                LOG.exit(method, null);
            });
    }
&nbsp;
    /**
     * Handle a request from the client to connect to a business network.
     * @param {string} connectionProfile The connection profile name.
     * @param {string} businessNetworkIdentifier The business network identifier.
     * @param {Object} connectionOptions The connection profile options to use.
     * @param {function} callback The callback to call when complete.
     */
    async connectionManagerConnect (connectionProfile, businessNetworkIdentifier, connectionOptions, callback) {
        const method = 'connectionManagerConnect';
        LOG.entry(method, connectionProfile, businessNetworkIdentifier, connectionOptions);
        try {
            connectionOptions.wallet = await this.businessNetworkCardStore.getWallet(connectionOptions.cardName);
            let connectionManager = await this.connectionProfileManager.getConnectionManagerByType(ConnectorServer.getConnectionType(connectionOptions));
&nbsp;
            // don't have to worry about changing the connectionOptions for x-type as that information is not processed
            // by an connector connect call or by the connectors themselves. x-type is purely for use by the connectionprofilemanager
            const connection = await connectionManager.connect(connectionProfile, businessNetworkIdentifier, connectionOptions);
            const connectionID = uuid.v4();
            this.connections[connectionID] = connection;
            callback(null, connectionID);
            LOG.exit(method, connectionID);
        } catch (error) {
            LOG.error(method, error);
            callback(ConnectorServer.serializerr(error));
            LOG.exit(method, null);
        }
    }
&nbsp;
    /**
     * Handle a request from the client to disconnect from a business network.
     * @param {string} connectionID The connection ID.
     * @param {function} callback The callback to call when complete.
     * @return {Promise} A promise that is resolved when complete.
     */
    connectionDisconnect (connectionID, callback) {
        const method = 'connectionDisconnect';
        LOG.entry(method, connectionID);
        let connection = this.connections[connectionID];
        if (!connection) {
            let error = new Error(`No connection found with ID ${connectionID}`);
            LOG.error(method, error);
            callback(ConnectorServer.serializerr(error));
            LOG.exit(method, null);
            return Promise.resolve();
        }
        delete this.connections[connectionID];
&nbsp;
        connection.removeListener('events', () =&gt; {
        });
&nbsp;
        return connection.disconnect()
           .then(() =&gt; {
                callback(null);
                LOG.exit(method);
            })
           .catch((error) =&gt; {
                LOG.error(method, error);
                callback(ConnectorServer.serializerr(error));
                LOG.exit(method);
            });
    }
&nbsp;
    /**
     * Handle a request from the client to login to a business network.
     * @param {string} connectionID The connection ID.
     * @param {string} enrollmentID The enrollment ID.
     * @param {string} enrollmentSecret The enrollment secret.
     * @param {function} callback The callback to call when complete.
     * @return {Promise} A promise that is resolved when complete.
     */
    connectionLogin (connectionID, enrollmentID, enrollmentSecret, callback) {
        const method = 'connectionLogin';
        LOG.entry(method, connectionID, enrollmentID, enrollmentSecret);
        let connection = this.connections[connectionID];
        if (!connection) {
            let error = new Error(`No connection found with ID ${connectionID}`);
            LOG.error(method, error);
            callback(ConnectorServer.serializerr(error));
            LOG.exit(method, null);
            return Promise.resolve();
        }
        return connection.login(enrollmentID, enrollmentSecret)
           .then((securityContext) =&gt; {
                let securityContextID = uuid.v4();
                this.securityContexts[securityContextID] = securityContext;
                callback(null, securityContextID);
                LOG.exit(method, securityContextID);
            })
           .then(() =&gt; {
                connection.on('events', (events) =&gt; {
                    LOG.debug(method, events);
                    this.socket.emit('events', connectionID, events);
                });
            })
           .catch((error) =&gt; {
                LOG.error(method, error);
                callback(ConnectorServer.serializerr(error));
                LOG.exit(method);
            });
    }
&nbsp;
    /**
     * Handle a request from the client to install the runtime.
     * @param {string} connectionID The connection ID.
     * @param {string} securityContextID The security context ID.
     * @param {string} networkArchiveBase64 Base64 encoded business network archive
     * @param {Object} installOptions connector specific install options
     * @param {function} callback The callback to call when complete.
     * @return {Promise} A promise that is resolved when complete.
     */
    connectionInstall (connectionID, securityContextID, networkArchiveBase64, installOptions, callback) {
        const method = 'connectionDeploy';
        LOG.entry(method, connectionID, securityContextID, networkArchiveBase64, installOptions);
        let connection = this.connections[connectionID];
        if (!connection) {
            let error = new Error(`No connection found with ID ${connectionID}`);
            LOG.error(method, error);
            callback(ConnectorServer.serializerr(error));
            LOG.exit(method, null);
            return Promise.resolve();
        }
        let securityContext = this.