SteamFriends.prototype.sendMessage = function(target, message, type) {
target = SteamID.decode(target);
type = type || Steam.EChatEntryType.ChatMsg;
var payload = new ByteBuffer(Buffer.byteLength(message) + 1);
payload.writeCString(message).flip();
if (target.accountType == Steam.EAccountType.Individual || target.accountType == Steam.EAccountType.ConsoleUser) {
this._client.send({
msg: EMsg.ClientFriendMsg,
proto: {}
}, new schema.CMsgClientFriendMsg({
steamid: target.encode(),
message: payload,
chat_entry_type: type
}).toBuffer());
} else {
// assume chat message
var chatMsg = new schema.MsgClientChatMsg({
steamIdChatter: this._client.steamID,
steamIdChatRoom: toChatID(target),
chatMsgType: type
}).toBuffer();
this._client.send({
msg: EMsg.ClientChatMsg
}, Buffer.concat([chatMsg, payload.toBuffer()]));
}
};
function writeDelimited(protoMessage) {
var msgSize = protoMessage.length;
// TODO: The 1 below is not needed....
var buffer = new ByteBuffer(1 + msgSize);
buffer.writeVarint(msgSize);
buffer.append(protoMessage);
buffer.flip();
return buffer.toBuffer();
}
function signalCommand(aSocket, aCommand) {
var packet = new ByteBuffer();
packet.writeByte(imbMagic);
packet.writeVarint64ZigZag(-aCommand.limit);
packet.append(aCommand.copy());
while (packet.offset<imbMinimumPacketSize)
packet.writeByte(0);
packet.flip();
var buffer = packet.toBuffer();
aSocket.write(buffer);
}
Block.prototype.getBytes = function (block) {
let size = 4 + 4 + 8 + 4 + 4 + 8 + 8 + 4 + 4 + 4 + 32 + 32 + 64;
let b, i;
try {
let bb = new ByteBuffer(size, true);
bb.writeInt(block.version);
bb.writeInt(block.timestamp);
if (block.previousBlock) {
let pb = new bignum(block.previousBlock).toBuffer({size: '8'});
for (i = 0; i < 8; i++) {
bb.writeByte(pb[i]);
}
} else {
for (i = 0; i < 8; i++) {
bb.writeByte(0);
}
}
bb.writeInt(block.numberOfTransactions);
bb.writeLong(block.totalAmount);
bb.writeLong(block.totalFee);
bb.writeLong(block.reward);
bb.writeInt(block.payloadLength);
let payloadHashBuffer = Buffer.from(block.payloadHash, 'hex');
for (i = 0; i < payloadHashBuffer.length; i++) {
bb.writeByte(payloadHashBuffer[i]);
}
let generatorPublicKeyBuffer = Buffer.from(block.generatorPublicKey, 'hex');
for (i = 0; i < generatorPublicKeyBuffer.length; i++) {
bb.writeByte(generatorPublicKeyBuffer[i]);
}
if (block.blockSignature) {
let blockSignatureBuffer = Buffer.from(block.blockSignature, 'hex');
for (i = 0; i < blockSignatureBuffer.length; i++) {
bb.writeByte(blockSignatureBuffer[i]);
}
}
bb.flip();
b = bb.toBuffer();
} catch (e) {
throw e;
}
return b;
};
function signalEvent(aSocket, aEventID, aEvent) {
var packet = new ByteBuffer();
packet.writeByte(imbMagic);
packet.writeVarint64ZigZag(aEvent.limit + 2); // 2 bytes extra for event id
packet.writeUint16(aEventID); // fixed format Uint16
packet.append(aEvent.copy());
while (packet.offset<imbMinimumPacketSize)
packet.writeByte(0);
packet.flip();
var buffer = packet.toBuffer();
aSocket.write(buffer);
}
Multisignature.prototype.getBytes = function (trs, skip) {
var keysgroupBuffer = new Buffer(trs.asset.multisignature.keysgroup.join(''), 'utf8');
var bb = new ByteBuffer(1 + 1 + keysgroupBuffer.length, true);
bb.writeByte(trs.asset.multisignature.min);
bb.writeByte(trs.asset.multisignature.lifetime);
for (var i = 0; i < keysgroupBuffer.length; i++) {
bb.writeByte(keysgroupBuffer[i]);
}
bb.flip();
return bb.toBuffer();
};
Multisignature.prototype.getBytes = function(transaction) {
const keysgroupBuffer = Buffer.from(
transaction.asset.multisignature.keysgroup.join(''),
'utf8'
);
const byteBuffer = new ByteBuffer(1 + 1 + keysgroupBuffer.length, true);
byteBuffer.writeByte(transaction.asset.multisignature.min);
byteBuffer.writeByte(transaction.asset.multisignature.lifetime);
for (let i = 0; i < keysgroupBuffer.length; i++) {
byteBuffer.writeByte(keysgroupBuffer[i]);
}
byteBuffer.flip();
return byteBuffer.toBuffer();
};
SteamFriends.prototype.leaveChat = function(steamID) {
var leaveChat = new schema.MsgClientChatMemberInfo({
steamIdChat: toChatID(steamID),
type: Steam.EChatInfoType.StateChange
}).toBuffer();
var payload = new ByteBuffer(20, ByteBuffer.LITTLE_ENDIAN);
payload.writeUint64(this._client.steamID);
payload.writeUint32(Steam.EChatMemberStateChange.Left);
payload.writeUint64(this._client.steamID);
payload.flip();
this._client.send({
msg: EMsg.ClientChatMemberInfo
}, Buffer.concat([leaveChat, payload.toBuffer()]));
delete this.chatRooms[steamID];
};
function getDAppBytes(dapp) {
try {
var buf = new Buffer([]);
var nameBuf = new Buffer(dapp.name, 'utf8');
buf = Buffer.concat([buf, nameBuf]);
if (dapp.description) {
var descriptionBuf = new Buffer(dapp.description, 'utf8');
buf = Buffer.concat([buf, descriptionBuf]);
}
if (dapp.tags) {
var tagsBuf = new Buffer(dapp.tags, 'utf8');
buf = Buffer.concat([buf, tagsBuf]);
}
if (dapp.siaAscii) {
buf = Buffer.concat([buf, new Buffer(dapp.siaAscii, 'ascii')]);
}
if (dapp.siaIcon) {
buf = Buffer.concat([buf, new Buffer(dapp.siaIcon, 'ascii')]);
}
if (dapp.git) {
buf = Buffer.concat([buf, new Buffer(dapp.git, 'utf8')]);
}
if (dapp.icon) {
buf = Buffer.concat([buf, new Buffer(dapp.icon, 'utf8')]);
}
var bb = new ByteBuffer(4 + 4, true);
bb.writeInt(dapp.type);
bb.writeInt(dapp.category);
bb.flip();
buf = Buffer.concat([buf, bb.toBuffer()]);
} catch (e) {
throw Error(e.toString());
}
return buf;
}
handlers[EMsg.ChannelEncryptRequest] = function(data) {
// assume server isn't dead
this._connection.setTimeout(0);
// var encRequest = Schema.MsgChannelEncryptRequest.decode(data);
this.emit('debug', 'encrypt request');
var sessionKey = SteamCrypto.generateSessionKey();
this._tempSessionKey = sessionKey.plain;
var keyCrc = BufferCRC32.signed(sessionKey.encrypted);
var encResp = new Schema.MsgChannelEncryptResponse().encode();
var body = new ByteBuffer(encResp.limit + 128 + 4 + 4, ByteBuffer.LITTLE_ENDIAN); // key, crc, trailer
body.append(encResp);
body.append(sessionKey.encrypted);
body.writeInt32(keyCrc);
body.writeUint32(0); // TODO: check if the trailer is required
body.flip();
this.send({"msg": EMsg.ChannelEncryptResponse}, body.toBuffer());
};
DApp.prototype.getBytes = function (trs) {
var buf;
try {
buf = new Buffer([]);
var nameBuf = new Buffer(trs.asset.dapp.name, 'utf8');
buf = Buffer.concat([buf, nameBuf]);
if (trs.asset.dapp.description) {
var descriptionBuf = new Buffer(trs.asset.dapp.description, 'utf8');
buf = Buffer.concat([buf, descriptionBuf]);
}
if (trs.asset.dapp.tags) {
var tagsBuf = new Buffer(trs.asset.dapp.tags, 'utf8');
buf = Buffer.concat([buf, tagsBuf]);
}
if (trs.asset.dapp.link) {
buf = Buffer.concat([buf, new Buffer(trs.asset.dapp.link, 'utf8')]);
}
if (trs.asset.dapp.icon) {
buf = Buffer.concat([buf, new Buffer(trs.asset.dapp.icon, 'utf8')]);
}
var bb = new ByteBuffer(4 + 4, true);
bb.writeInt(trs.asset.dapp.type);
bb.writeInt(trs.asset.dapp.category);
bb.flip();
buf = Buffer.concat([buf, bb.toBuffer()]);
} catch (e) {
throw e;
}
return buf;
};
function getBytes(transaction) {
var assetSize = 0,
assetBytes = null;
switch (transaction.type) {
case 1: // Signature
assetSize = 32;
assetBytes = getSignatureBytes(transaction.asset.signature);
break;
case 2: // Delegate
assetBytes = new Buffer(transaction.asset.delegate.username, "utf8");
assetSize = assetBytes.length;
break;
case 3: // Vote
if (transaction.asset.votes !== null) {
assetBytes = new Buffer(transaction.asset.votes.join(""), "utf8");
assetSize = assetBytes.length;
}
break;
case 4: // Multi-Signature
var keysgroupBuffer = new Buffer(transaction.asset.multisignature.keysgroup.join(""), "utf8");
var bb = new ByteBuffer(1 + 1 + keysgroupBuffer.length, true);
bb.writeByte(transaction.asset.multisignature.min);
bb.writeByte(transaction.asset.multisignature.lifetime);
for (var i = 0; i < keysgroupBuffer.length; i++) {
bb.writeByte(keysgroupBuffer[i]);
}
bb.flip();
assetBytes = bb.toBuffer();
assetSize = assetBytes.length;
break;
case 5: // Dapp
assetBytes = getDAppBytes(transaction.asset.dapp);
assetSize = assetBytes.length;
break;
case 6: // In Transfer (Dapp Deposit)
assetBytes = getTransferBytes(transaction.asset.dapptransfer);
assetSize = assetBytes.length;
break;
}
if (transaction.requesterPublicKey) {
assetSize += 32;
}
var bb = new ByteBuffer(1 + 4 + 32 + 8 + 8 + 64 + 64 + assetSize, true);
bb.writeByte(transaction.type);
bb.writeInt(transaction.timestamp);
var senderPublicKeyBuffer = new Buffer(transaction.senderPublicKey, "hex");
for (var i = 0; i < senderPublicKeyBuffer.length; i++) {
bb.writeByte(senderPublicKeyBuffer[i]);
}
if (transaction.requesterPublicKey) {
var requesterPublicKey = new Buffer(transaction.requesterPublicKey, "hex");
for (var i = 0; i < requesterPublicKey.length; i++) {
bb.writeByte(requesterPublicKey[i]);
}
}
if (transaction.recipientId) {
var recipient = transaction.recipientId.slice(0, -1);
recipient = bignum(recipient).toBuffer({size: 8});
for (var i = 0; i < 8; i++) {
bb.writeByte(recipient[i] || 0);
}
} else {
for (var i = 0; i < 8; i++) {
bb.writeByte(0);
}
}
bb.writeLong(transaction.amount);
if (assetSize > 0) {
for (var i = 0; i < assetSize; i++) {
bb.writeByte(assetBytes[i]);
}
}
if (transaction.signature) {
var signatureBuffer = new Buffer(transaction.signature, "hex");
for (var i = 0; i < signatureBuffer.length; i++) {
bb.writeByte(signatureBuffer[i]);
}
}
if (transaction.signSignature) {
var signSignatureBuffer = new Buffer(transaction.signSignature, "hex");
for (var i = 0; i < signSignatureBuffer.length; i++) {
bb.writeByte(signSignatureBuffer[i]);
}
}
bb.flip();
var arrayBuffer = new Uint8Array(bb.toArrayBuffer());
var buffer = [];
for (var i = 0; i < arrayBuffer.length; i++) {
buffer[i] = arrayBuffer[i];
}
return new Buffer(buffer);
}
Block.prototype.getBytes = function(block) {
const capacity =
4 + // version (int)
4 + // timestamp (int)
8 + // previousBlock
4 + // numberOfTransactions (int)
8 + // totalAmount (long)
8 + // totalFee (long)
8 + // reward (long)
4 + // payloadLength (int)
32 + // payloadHash
32 + // generatorPublicKey
64 + // blockSignature or unused
4; // unused
let bytes;
try {
const byteBuffer = new ByteBuffer(capacity, true);
byteBuffer.writeInt(block.version);
byteBuffer.writeInt(block.timestamp);
if (block.previousBlock) {
const pb = new Bignum(block.previousBlock).toBuffer({ size: '8' });
for (let i = 0; i < 8; i++) {
byteBuffer.writeByte(pb[i]);
}
} else {
for (let i = 0; i < 8; i++) {
byteBuffer.writeByte(0);
}
}
byteBuffer.writeInt(block.numberOfTransactions);
byteBuffer.writeLong(block.totalAmount.toString());
byteBuffer.writeLong(block.totalFee.toString());
byteBuffer.writeLong(block.reward.toString());
byteBuffer.writeInt(block.payloadLength);
const payloadHashBuffer = this.scope.ed.hexToBuffer(block.payloadHash);
for (let i = 0; i < payloadHashBuffer.length; i++) {
byteBuffer.writeByte(payloadHashBuffer[i]);
}
const generatorPublicKeyBuffer = this.scope.ed.hexToBuffer(
block.generatorPublicKey
);
for (let i = 0; i < generatorPublicKeyBuffer.length; i++) {
byteBuffer.writeByte(generatorPublicKeyBuffer[i]);
}
if (block.blockSignature) {
const blockSignatureBuffer = this.scope.ed.hexToBuffer(
block.blockSignature
);
for (let i = 0; i < blockSignatureBuffer.length; i++) {
byteBuffer.writeByte(blockSignatureBuffer[i]);
}
}
byteBuffer.flip();
bytes = byteBuffer.toBuffer();
} catch (e) {
throw e;
}
return bytes;
};