diff --git a/lib/account.js b/lib/account.js
index 4ff2782..c365c12 100644
--- a/lib/account.js
+++ b/lib/account.js
@@ -1,146 +1,146 @@
 'use strict';
 
 import debug from 'debug';
 import md5 from 'blueimp-md5';
 import transform from 'sdp-transform';
 
 
 import { EventEmitter } from 'events';
 import { Call } from './call';
 import { ConferenceCall } from './conference';
 import { Identity } from './utils';
 
 const DEBUG = debug('sylkrtc:Account');
 
 
 class Account extends EventEmitter {
     constructor(options, connection) {
         if (options.account.indexOf('@') === -1) {
             throw new Error('Invalid account id specified');
         }
         super();
         const id = options.account;
         const [username, domain] = id.split('@');
         this._id = id;
         this._displayName = options.displayName;
         this._password = md5(username + ':' + (options.realm || domain)+ ':' + options.password);
         this._connection = connection;
         this._registrationState = null;
         this._calls = new Map();
         this._confCalls = new Map();
     }
 
     get id() {
         return this._id;
     }
 
     get password() {
         return this._password;
     }
 
     get displayName() {
         return this._displayName;
     }
 
     get registrationState() {
         return this._registrationState;
     }
 
     register() {
-        let req = {
+        const req = {
             sylkrtc: 'account-register',
             account: this._id
         };
         this._sendRequest(req, (error) => {
             if (error) {
                 DEBUG('Register error: %s', error);
                 const oldState = this._registrationState;
                 const newState = 'failed';
-                let data = {reason: error.toString()};
+                const data = {reason: error.toString()};
                 this._registrationState = newState;
                 this.emit('registrationStateChanged', oldState, newState, data);
             }
         });
     }
 
     unregister() {
-        let req = {
+        const req = {
             sylkrtc: 'account-unregister',
             account: this._id,
         };
         this._sendRequest(req, (error) => {
             if (error) {
                 DEBUG('Unregister error: %s', error);
             }
             const oldState = this._registrationState;
             const newState = null;
             this._registrationState = newState;
             this.emit('registrationStateChanged', oldState, newState, {});
         });
     }
 
     call(uri, options={}) {
-        let callObj = new Call(this);
+        const callObj = new Call(this);
         callObj._initOutgoing(uri, options);
         this._calls.set(callObj.id, callObj);
         this.emit('outgoingCall', callObj);
         return callObj;
     }
 
     joinConference(uri, options={}) {
-        let confCall = new ConferenceCall(this);
+        const confCall = new ConferenceCall(this);
         confCall._initialize(uri, options);
         this._confCalls.set(confCall.id, confCall);
         this.emit('conferenceCall', confCall);
         return confCall;
     }
 
     // Private API
 
     _handleEvent(message) {
         DEBUG('Received account event: %s', message.event);
-        let data = {};
+        const data = {};
         switch (message.event) {
             case 'registration_state':
                 const oldState = this._registrationState;
                 const newState = message.data.state;
                 this._registrationState = newState;
                 if (newState === 'failed') {
                     data.reason = message.data.reason;
                 }
                 this.emit('registrationStateChanged', oldState, newState, data);
                 break;
             case 'incoming_session':
                 let call = new Call(this);
                 call._initIncoming(message.session, message.data.originator, message.data.sdp);
                 this._calls.set(call.id, call);
                 // see what media types are offered
-                let mediaTypes = { audio: false, video: false };
+                const mediaTypes = { audio: false, video: false };
                 const parsedSdp = transform.parse(message.data.sdp);
                 for (let media of parsedSdp.media) {
                     if (media.type === 'audio' && media.port !== 0 && media.direction === 'sendrecv') {
                         mediaTypes.audio = true;
                     } else if (media.type === 'video' && media.port !== 0 && media.direction === 'sendrecv') {
                         mediaTypes.video = true;
                     }
                 }
                 DEBUG('Incoming call from %s with media types: %o', message.data.originator.uri, mediaTypes);
                 this.emit('incomingCall', call, mediaTypes);
                 break;
             case 'missed_session':
                 data.originator = new Identity(message.data.originator.uri, message.data.originator.display_name);
                 this.emit('missedCall', data);
                 break;
             default:
                 break;
         }
     }
 
     _sendRequest(req, cb) {
         this._connection._sendRequest(req, cb);
     }
 
 }
 
 
 export { Account };
diff --git a/lib/call.js b/lib/call.js
index f4b2727..fad4338 100644
--- a/lib/call.js
+++ b/lib/call.js
@@ -1,360 +1,360 @@
 'use strict';
 
 import debug from 'debug';
 import uuid from 'node-uuid';
 import rtcninja from 'rtcninja';
 import utils from './utils';
 
 import { EventEmitter } from 'events';
 
 const DEBUG = debug('sylkrtc:Call');
 
 
 class Call extends EventEmitter {
     constructor(account) {
         super();
         this._account = account;
         this._id = null;
         this._direction = null;
         this._pc = null;
         this._state = null;
         this._terminated = false;
         this._incomingSdp = null;
         this._localIdentity = new utils.Identity(account.id, account.displayName);
         this._remoteIdentity = null;
         this._dtmfSender = null;
 
         // bind some handlers to this instance
         this._onDtmf = this._onDtmf.bind(this);
     }
 
     get account() {
         return this._account;
     }
 
     get id() {
         return this._id;
     }
 
     get direction() {
         return this._direction;
     }
 
     get state() {
         return this._state;
     }
 
     get localIdentity() {
         return this._localIdentity;
     }
 
     get remoteIdentity() {
         return this._remoteIdentity;
     }
 
     getLocalStreams() {
         if (this._pc !== null) {
             return this._pc.getLocalStreams();
         } else {
             return [];
         }
     }
 
     getRemoteStreams() {
         if (this._pc !== null) {
             return this._pc.getRemoteStreams();
         } else {
             return [];
         }
     }
 
     answer(options = {}) {
         if (this._state !== 'incoming') {
             throw new Error('Call is not in the incoming state: ' + this._state);
         }
 
         const pcConfig = options.pcConfig || {iceServers:[]};
         const mediaConstraints = options.mediaConstraints || {audio: true, video: true};
         const answerOptions = options.answerOptions;
         const localStream = options.localStream || null;
 
         // Create the RTCPeerConnection
         this._initRTCPeerConnection(pcConfig);
 
         utils.getUserMedia(mediaConstraints, localStream)
             .then((stream) => {
                 this._pc.addStream(stream);
                 this.emit('localStreamAdded', stream);
                 this._pc.setRemoteDescription(
                     new rtcninja.RTCSessionDescription({type: 'offer', sdp: this._incomingSdp}),
                     // success
                     () => {
                         utils.createLocalSdp(this._pc, 'answer', answerOptions)
                             .then((sdp) => {
                                 DEBUG('Local SDP: %s', sdp);
                                 this._sendAnswer(sdp);
                             })
                             .catch((reason) => {
                                 DEBUG(reason);
                                 this.terminate();
                             });
                     },
                     // failure
                     (error) => {
                         DEBUG('Error setting remote description: %s', error);
                         this.terminate();
                     }
                 );
             })
             .catch(function(reason) {
                 DEBUG(reason);
                 this.terminate();
             });
     }
 
     terminate() {
         if (this._terminated) {
             return;
         }
         DEBUG('Terminating call');
         this._sendTerminate();
     }
 
     sendDtmf(tones, duration=100, interToneGap=70) {
         DEBUG('sendDtmf()');
         if (this._dtmfSender === null) {
             if (this._pc !== null) {
                 let track = null;
                 try {
                     track = this._pc.getLocalStreams()[0].getAudioTracks()[0];
                 } catch (e) {
                     // ignore
                 }
                 if (track !== null) {
                     DEBUG('Creating DTMF sender');
                     this._dtmfSender = this._pc.createDTMFSender(track);
                     if (this._dtmfSender) {
                         this._dtmfSender.addEventListener('tonechange', this._onDtmf);
                     }
                 }
             }
         }
         if (this._dtmfSender) {
             DEBUG('Sending DTMF tones');
             this._dtmfSender.insertDTMF(tones, duration, interToneGap);
         }
     }
 
     // Private API
 
     _initOutgoing(uri, options={}) {
         if (uri.indexOf('@') === -1) {
             throw new Error('Invalid URI');
         }
 
         this._id = uuid.v4();
         this._direction = 'outgoing';
         this._remoteIdentity = new utils.Identity(uri);
 
         const pcConfig = options.pcConfig || {iceServers:[]};
         const mediaConstraints = options.mediaConstraints || {audio: true, video: true};
         const offerOptions = options.offerOptions;
         const localStream = options.localStream || null;
 
         // Create the RTCPeerConnection
         this._initRTCPeerConnection(pcConfig);
 
         utils.getUserMedia(mediaConstraints, localStream)
             .then((stream) => {
                 this._pc.addStream(stream);
                 this.emit('localStreamAdded', stream);
                 utils.createLocalSdp(this._pc, 'offer', offerOptions)
                     .then((sdp) => {
                         DEBUG('Local SDP: %s', sdp);
                         this._sendCall(uri, sdp);
                     })
                     .catch((reason) => {
                         DEBUG(reason);
                         this._localTerminate(reason);
                     });
             })
             .catch(function(reason) {
                 DEBUG(reason);
                 this._localTerminate(reason);
             });
     }
 
     _initIncoming(id, caller, sdp) {
         this._id = id;
         this._remoteIdentity = new Identity(caller.uri, caller.display_name);
         this._incomingSdp = sdp;
         this._direction = 'incoming';
         this._state = 'incoming';
         DEBUG('Remote SDP: %s', sdp);
     }
 
     _handleEvent(message) {
         DEBUG('Call event: %o', message);
         switch (message.event) {
             case 'state':
                 const oldState = this._state;
                 const newState = message.data.state;
                 this._state = newState;
-                let data = {};
+                const data = {};
 
                 if (newState === 'accepted' && this._direction === 'outgoing') {
-                    let sdp = utils.mungeSdp(message.data.sdp);
+                    const sdp = utils.mungeSdp(message.data.sdp);
                     DEBUG('Remote SDP: %s', sdp);
                     this._pc.setRemoteDescription(
                         new rtcninja.RTCSessionDescription({type: 'answer', sdp: sdp}),
                         // success
                         () => {
                             DEBUG('Call accepted');
                             this.emit('stateChanged', oldState, newState, data);
                         },
                         // failure
                         (error) => {
                             DEBUG('Error accepting call: %s', error);
                             this.terminate();
                         }
                     );
                 } else {
                     if (newState === 'terminated') {
                         data.reason = message.data.reason;
                         this._terminated = true;
                         this._closeRTCPeerConnection();
                     }
                     this.emit('stateChanged', oldState, newState, data);
                 }
                 break;
             default:
                 break;
         }
     }
 
     _initRTCPeerConnection(pcConfig) {
         if (this._pc !== null) {
             throw new Error('RTCPeerConnection already initialized');
         }
 
         this._pc = new rtcninja.RTCPeerConnection(pcConfig);
         this._pc.onaddstream = (event, stream) => {
             DEBUG('Stream added');
             this.emit('streamAdded', stream);
         };
         this._pc.onicecandidate = (event) => {
             if (event.candidate !== null) {
                 DEBUG('New ICE candidate %o', event.candidate);
             } else {
                 DEBUG('ICE candidate gathering finished');
             }
             this._sendTrickle(event.candidate);
         };
     }
 
     _sendRequest(req, cb) {
         this._account._sendRequest(req, cb);
     }
 
     _sendCall(uri, sdp) {
-        let req = {
+        const req = {
             sylkrtc: 'session-create',
             account: this.account.id,
             session: this.id,
             uri: uri,
             sdp: sdp
         };
         this._sendRequest(req, (error) => {
             if (error) {
                 DEBUG('Call error: %s', error);
                 this._localTerminate(error);
             }
         });
     }
 
     _sendTerminate() {
-        let req = {
+        const req = {
             sylkrtc: 'session-terminate',
             session: this.id
         };
         this._sendRequest(req, (error) => {
             if (error) {
                 DEBUG('Error terminating call: %s', error);
                 this._localTerminate(error);
             }
             this._terminated = true;
         });
         setTimeout(() => {
             if (!this._terminated) {
                 DEBUG('Timeout terminating call');
                 this._localTerminate('200 OK');
             }
             this._terminated = true;
         }, 150);
     }
 
     _sendTrickle(candidate) {
-        let req = {
+        const req = {
             sylkrtc: 'session-trickle',
             session: this.id,
             candidates: candidate !== null ? [candidate] : [],
         };
         this._sendRequest(req, null);
     }
 
     _sendAnswer(sdp) {
-        let req = {
+        const req = {
             sylkrtc: 'session-answer',
             session: this.id,
             sdp: sdp
         };
         this._sendRequest(req, (error) => {
             if (error) {
                 DEBUG('Answer error: %s', error);
                 this.terminate();
             }
         });
     }
 
     _closeRTCPeerConnection() {
         DEBUG('Closing RTCPeerConnection');
         if (this._pc !== null) {
             for (let stream of this._pc.getLocalStreams()) {
                 rtcninja.closeMediaStream(stream);
             }
             for (let stream of this._pc.getRemoteStreams()) {
                 rtcninja.closeMediaStream(stream);
             }
             this._pc.close();
             this._pc = null;
             if (this._dtmfSender !== null) {
                 this._dtmfSender.removeEventListener('tonechange', this._onDtmf);
                 this._dtmfSender = null;
             }
         }
     }
 
     _localTerminate(error) {
         if (this._terminated) {
             return;
         }
         DEBUG('Local terminate');
         this._account._calls.delete(this.id);
         this._terminated = true;
         const oldState = this._state;
         const newState = 'terminated';
-        let data = {
+        const data = {
             reason: error.toString()
         };
         this._closeRTCPeerConnection();
         this.emit('stateChanged', oldState, newState, data);
     }
 
     _onDtmf(event) {
         DEBUG('Sent DTMF tone %s', event.tone);
         this.emit('dtmfToneSent', event.tone);
     }
 }
 
 
 export { Call };
diff --git a/lib/connection.js b/lib/connection.js
index b04990a..cc3e8ea 100644
--- a/lib/connection.js
+++ b/lib/connection.js
@@ -1,324 +1,323 @@
 'use strict';
 
 import bowser from 'bowser';
 import debug from 'debug';
 import uuid from 'node-uuid';
 
 import { EventEmitter } from 'events';
 import { setImmediate } from 'timers';
 import { w3cwebsocket as W3CWebSocket } from 'websocket';
 import { Account } from './account';
 
 const SYLKRTC_PROTO = 'sylkRTC-1';
 const DEBUG = debug('sylkrtc:Connection');
 
 const MSECS = 1000;
 const INITIAL_DELAY = 0.5 * MSECS;
 const MAX_DELAY = 64 * MSECS;
 
 // compute a string for our well-known platforms
 let platform;
 if (bowser.iphone) {
     platform = 'iPhone';
 } else if (bowser.ipad) {
     platform = 'iPad';
 } else if (bowser.ipod) {
     platform = 'iPod';
 } else if (bowser.android) {
     platform = 'Android';
 } else if (bowser.mac) {
     platform = 'macOS';
 } else if (bowser.linux) {
     platform = 'Linux';
 } else if (bowser.windows) {
     platform = 'Windows';
 } else {
     platform = 'Unknown';
 }
 if (bowser.osversion) {
     platform = `${platform} ${bowser.osversion}`;
 }
 let browser = bowser.name;
 if (bowser.version) {
     browser = `${browser} ${bowser.version}`;
 }
 
 const USER_AGENT = `SylkRTC (${browser} on ${platform})`;
 
 
 class Connection extends EventEmitter {
     constructor(options = {}) {
         if (!options.server) {
             throw new Error('\"server\" must be specified');
         }
         super();
         this._wsUri = options.server;
         this._sock = null;
         this._state = null;
         this._closed = false;
         this._timer = null;
         this._delay = INITIAL_DELAY;
         this._accounts = new Map();
         this._requests = new Map();
     }
 
     get state() {
         return this._state;
     }
 
     close() {
         if (this._closed) {
             return;
         }
         this._closed = true;
         if (this._timer) {
             clearTimeout(this._timer);
             this._timer = null;
         }
         if (this._sock) {
             this._sock.close();
             this._sock = null;
         } else {
             setImmediate(() => {
                 this._setState('closed');
             });
         }
     }
 
     addAccount(options = {}, cb = null) {
         if (typeof options.account !== 'string' || typeof options.password !== 'string') {
             throw new Error('Invalid options, \"account\" and \"password\" must be supplied');
         }
         if (this._accounts.has(options.account)) {
             throw new Error('Account already added');
         }
 
-        let acc = new Account(options, this);
+        const acc = new Account(options, this);
         // add it early to the set so we don't add it more than once, ever
         this._accounts.set(acc.id, acc);
 
-        let req = {
+        const req = {
             sylkrtc: 'account-add',
             account: acc.id,
             password: acc.password,
             display_name: acc.displayName,
             user_agent: USER_AGENT
         };
         this._sendRequest(req, (error) => {
             if (error) {
                 DEBUG('add_account error: %s', error);
                 this._accounts.delete(acc.id);
-                acc = null;
             }
             if (cb) {
-                cb(error, acc);
+                cb(error, error ? null : acc);
             }
         });
 
     }
 
     removeAccount(account, cb=null) {
         const acc = this._accounts.get(account.id);
         if (account !== acc) {
             throw new Error('Unknown account');
         }
 
         // delete the account from the mapping, regardless of the result
         this._accounts.delete(account.id);
 
-        let req = {
+        const req = {
             sylkrtc: 'account-remove',
             account: acc.id
         };
         this._sendRequest(req, (error) => {
             if (error) {
                 DEBUG('remove_account error: %s', error);
             }
             if (cb) {
                 cb();
             }
         });
 
     }
 
     reconnect() {
         if (this._state === 'disconnected') {
             clearTimeout(this._timer);
             this._delay = INITIAL_DELAY;
             this._timer = setTimeout(() => {
                 this._connect();
             }, this._delay);
         }
     }
 
     // Private API
 
     _initialize() {
         if (this._sock !== null) {
             throw new Error('WebSocket already initialized');
         }
         if (this._timer !== null) {
             throw new Error('Initialize is in progress');
         }
 
         DEBUG('Initializing');
 
         if (process.browser) {
             window.addEventListener('beforeunload', () => {
                 if (this._sock !== null) {
-                    let noop = function() {};
+                    const noop = function() {};
                     this._sock.onerror = noop;
                     this._sock.onmessage = noop;
                     this._sock.onclose = noop;
                     this._sock.close();
                 }
             });
         }
 
         this._timer = setTimeout(() => {
             this._connect();
         }, this._delay);
     }
 
     _connect() {
         DEBUG('WebSocket connecting');
         this._setState('connecting');
 
         this._sock = new W3CWebSocket(this._wsUri, SYLKRTC_PROTO);
         this._sock.onopen = () => {
             DEBUG('WebSocket connection open');
             this._onOpen();
         };
         this._sock.onerror = () => {
             DEBUG('WebSocket connection got error');
         };
         this._sock.onclose = (event) => {
             DEBUG('WebSocket connection closed: %d: (reason=\"%s\", clean=%s)', event.code, event.reason, event.wasClean);
             this._onClose();
         };
         this._sock.onmessage = (event) => {
             DEBUG('WebSocket received message: %o', event);
             this._onMessage(event);
         };
     }
 
     _sendRequest(req, cb) {
         const transaction = uuid.v4();
         req.transaction = transaction;
         if (this._state !== 'ready') {
             setImmediate(() => {
                 cb(new Error('Connection is not ready'));
             });
             return;
         }
         this._requests.set(transaction, {req: req, cb: cb});
         this._sock.send(JSON.stringify(req));
     }
 
     _setState(newState) {
         DEBUG('Set state: %s -> %s', this._state, newState);
         const oldState = this._state;
         this._state = newState;
         this.emit('stateChanged', oldState, newState);
     }
 
     // WebSocket callbacks
 
     _onOpen() {
         clearTimeout(this._timer);
         this._timer = null;
         this._delay = INITIAL_DELAY;
         this._setState('connected');
     }
 
     _onClose() {
         this._sock = null;
         if (this._timer) {
             clearTimeout(this._timer);
             this._timer = null;
         }
 
         // remove all accounts, the server no longer has them anyway
         this._accounts.clear();
 
         this._setState('disconnected');
         if (!this._closed) {
             this._delay = this._delay * 2;
             if (this._delay > MAX_DELAY) {
                 this._delay = INITIAL_DELAY;
             }
             DEBUG('Retrying connection in %s seconds', this._delay / MSECS);
             this._timer = setTimeout(() => {
                 this._connect();
             }, this._delay);
         } else {
             this._setState('closed');
         }
     }
 
     _onMessage(event) {
-        let message = JSON.parse(event.data);
+        const message = JSON.parse(event.data);
         if (typeof message.sylkrtc === 'undefined') {
             DEBUG('Unrecognized message received');
             return;
         }
 
         DEBUG('Received \"%s\" message: %o', message.sylkrtc, message);
 
         if (message.sylkrtc === 'event') {
             DEBUG('Received event: \"%s\"', message.event);
             switch (message.event) {
                 case 'ready':
                     this._setState('ready');
                     break;
                 default:
                     break;
             }
         } else if (message.sylkrtc === 'account_event') {
             let acc = this._accounts.get(message.account);
             if (!acc) {
                 DEBUG('Account %s not found', message.account);
                 return;
             }
             acc._handleEvent(message);
         } else if (message.sylkrtc === 'session_event') {
             const sessionId = message.session;
             for (let acc of this._accounts.values()) {
                 let call = acc._calls.get(sessionId);
                 if (call) {
                     call._handleEvent(message);
                     break;
                 }
             }
         } else if (message.sylkrtc === 'videoroom_event') {
             const confId = message.session;
             for (let acc of this._accounts.values()) {
                  let confCall = acc._confCalls.get(confId);
                  if (confCall) {
                      confCall._handleEvent(message);
                      break;
                  }
             }
         } else if (message.sylkrtc === 'ack' || message.sylkrtc === 'error') {
             const transaction = message.transaction;
             const data = this._requests.get(transaction);
             if (!data) {
                 DEBUG('Could not find transaction %s', transaction);
                 return;
             }
             this._requests.delete(transaction);
             DEBUG('Received \"%s\" for request: %o', message.sylkrtc, data.req);
             if (data.cb) {
                 if (message.sylkrtc === 'ack') {
                     data.cb(null);
                 } else {
                     data.cb(new Error(message.error));
                 }
             }
         }
     }
 
 }
 
 
 export { Connection };