Initial commit'

Author: clockworkgr

example.js

@@ -0,0 +1,11 @@
+var KeyboxJS=require('./index');
+let keybox=new KeyboxJS();
+
+
+console.log(keybox.connect());
+keybox.sendMessage('EccGetPublicKeyRequest',{ Hdpath: "bip32/m/48'/1'/1'/1'/2" }).then(res=> {
+
+   console.log(res.getPubkey_asU8());
+
+});
+

index.js

@@ -0,0 +1,164 @@
+var usb = require('usb');
+var messages = require('./lib/messages_pb');
+const MessageTypes =require('./lib/messagetypes');
+
+class KeyboxJS {
+
+    constructor() {
+        this.vid = 46763;
+        this.pid = 47851;
+        this.connected = false;
+    }
+    connect() {
+        this.device = usb.findByIds(this.vid, this.pid);
+        if (this.device == null) {
+            return false;
+        } else {
+            this.device.open();
+            this.iface = this.device.interface(0);
+            this.iface.claim();
+            this.tx = this.iface.endpoint(2);
+            this.rx = this.iface.endpoint(129);
+            this.connected = true;
+            return true;
+        }
+    }
+    reset() {
+        let buffer = Buffer.alloc(1024);
+        buffer.writeUInt8(0x5, 0);
+        return new Promise((resolve, reject) => {
+            this.tx.transfer(buffer, function (data) {
+                this.rx.transfer(1024, function (error, data) {
+                    if (error) {
+                        throw error;
+                    }
+                    if (data.readUInt8(0) == 0x4) {
+                        resolve();
+                    } else {
+                        reject();
+                    }
+                });
+            });
+        });
+    }
+    async sendMessage(messageType,props) {
+        let self=this;
+        let requestType=this.messageFromName(messageType);
+        
+        let msg =new messages[requestType.name]();
+        for(let prop in props) {
+            msg['set'+prop](props[prop]);
+        }
+        let bytes = msg.serializeBinary();
+        let buffer = Buffer.alloc(1024);
+        if (bytes.length <= 1015) {
+            let msglength=bytes.length;
+            buffer.writeUInt8(0x1, 0);
+            buffer.writeUInt32BE(requestType.id, 1);
+            buffer.writeUInt32BE(msglength, 5);
+            Buffer.from(bytes).copy(buffer,9);            
+            await this._sendSingleMessage(buffer);
+        }else{
+            throw new Error('Long messages (>1015) not implemented yet');
+        }
+        try {
+            let data= await this._receive(1024);
+            let response;
+            if (data.readUInt8(0) == 1) {
+                response=this._receiveSingleMessage(data);
+            }else{
+                if (data.readUInt8(0) == 2) {
+                    response=this._receiveMultiMessage(data);
+                }else{
+                    this.reset();
+                    throw new Error('Unexpected response');
+                }
+            }
+            return response;
+        }catch(e) {
+            this.reset();
+            throw new Error(e);
+        }
+    }
+    _sendSingleMessage(buffer) {
+        return this._send(buffer);
+    }
+    _receiveSingleMessage(data) {
+        let msgType=this.messageFromType(data.readUInt32BE(1));
+        
+        let msgLength=data.readUInt32BE(5);
+        
+        let message=data.slice(9,msgLength+9);
+        
+        
+        let msgObject=messages[msgType.name].deserializeBinary(message);
+        return(msgObject);
+    }    
+    _sendMultiMessage() {
+
+    }
+    _send(bytes) {
+        return new Promise((resolve,reject) => {
+            this.tx.transfer(bytes,resolve) 
+        });
+    }
+    _receive(size) {
+        return new Promise((resolve,reject) => {
+            this.rx.transfer(size,function(error,data) {
+                if (error) {
+                    reject(error);
+                }else{
+                    resolve(data);
+                }
+            });
+        });
+    }
+    async _receiveMultiMessage(data) {
+        let msgType=this.messageFromType(data.readUInt32BE(1));
+        let msgLength=data.readUInt32BE(5);
+        let message=data.slice(9);
+        let count=0;
+        while(message.length<msgLength) {
+            await this._sendAck(1015+count*1019);
+            let _part=await this._receive(1024);
+            let _msgpart;
+            if (_part.readUInt8(0)==0x3) {
+                if ((message.length+1019)>msgLength) {
+                    _msgpart=_part.slice(5);
+                }else{
+                    _msgpart=_part.slice(5,5+(msgLength-(1015+count*1019)));
+                }
+            }else{
+                throw new Error('Unexpected rx code');
+            }
+            message=Buffer.concat([message,_msgpart]);
+            count++;
+        }
+        let msgObject=messages[msgType.name].deserializeBinary(message).toObject()
+        return message;
+        
+    }
+    _sendAck(offset) {
+        return new Promise((resolve,reject)=> {
+            let buffer = Buffer.alloc(1024);
+            buffer.writeUInt8(0x4, 0);
+            buffer.writeUInt32BE(offset, 1);
+            this.tx.transfer(buffer, resolve);
+        });
+    }
+    messageFromType(msgtype) {
+        for(let type in MessageTypes) {
+            if (MessageTypes[type].id==msgtype) {
+                return MessageTypes[type];
+            }
+        }
+    }
+    messageFromName(msgtype) {
+        for(let type in MessageTypes) {
+            if (MessageTypes[type].name==msgtype) {
+                return MessageTypes[type];
+            }
+        }
+    }
+}
+module.exports=KeyboxJS;