Bitmessage
/
bitmessage-js
2
0
Fork 1
Code Issues 1 Pull Requests 1 Actions Packages Releases Activity

More substitutions for Buffer() in tests

This commit is contained in:
Lee Miller 2024-03-02 17:44:55 +02:00
parent a25dfbbbf3
commit e8efe4e6fd
Signed by untrusted user: lee.miller
GPG Key ID: 4F97A5EA88F4AB63
1 changed files with 97 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

175
test.js
View File

@ -35,19 +35,19 @@ var skipPow = {skipPow: true};
describe("Crypto", function() {
it("should implement SHA-1 hash", function() {
expect(bmcrypto.sha1(Buffer("test")).toString("hex")).to.equal("a94a8fe5ccb19ba61c4c0873d391e987982fbbd3");
expect(bmcrypto.sha1(Buffer.from("test")).toString("hex")).to.equal("a94a8fe5ccb19ba61c4c0873d391e987982fbbd3");
});
it("should implement SHA-256 hash", function() {
expect(bmcrypto.sha256(Buffer("test")).toString("hex")).to.equal("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08");
expect(bmcrypto.sha256(Buffer.from("test")).toString("hex")).to.equal("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08");
});
it("should implement SHA-512 hash", function() {
expect(bmcrypto.sha512(Buffer("test")).toString("hex")).to.equal("ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff");
expect(bmcrypto.sha512(Buffer.from("test")).toString("hex")).to.equal("ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff");
});
it("should implement RIPEMD-160 hash", function() {
expect(bmcrypto.ripemd160(Buffer("test")).toString("hex")).to.equal("5e52fee47e6b070565f74372468cdc699de89107");
expect(bmcrypto.ripemd160(Buffer.from("test")).toString("hex")).to.equal("5e52fee47e6b070565f74372468cdc699de89107");
});
it("should implement cryptographically secure PRNG", function() {
@ -93,7 +93,7 @@ describe("Crypto", function() {
var privateKey = Buffer.alloc(32);
privateKey.fill(1);
var publicKey = bmcrypto.getPublic(privateKey);
var message = Buffer("test");
var message = Buffer.from("test");
return bmcrypto.sign(privateKey, message).then(function(sig) {
expect(Buffer.isBuffer(sig)).to.be.true;
expect(sig.toString("hex")).to.equal("304402204737396b697e5a3400e3aedd203d8be89879f97708647252bd0c17752ff4c8f302201d52ef234de82ce0719679fa220334c83b80e21b8505a781d32d94a27d9310aa");
@ -104,7 +104,7 @@ describe("Crypto", function() {
it("should allow to encrypt and decrypt message", function() {
var privateKeyA = bmcrypto.getPrivate();
var publicKeyA = bmcrypto.getPublic(privateKeyA);
return bmcrypto.encrypt(publicKeyA, Buffer("msg to a")).then(function(buf) {
return bmcrypto.encrypt(publicKeyA, Buffer.from("msg to a")).then(function(buf) {
expect(Buffer.isBuffer(buf)).to.be.true;
return bmcrypto.decrypt(privateKeyA, buf).then(function(plaintext) {
expect(Buffer.isBuffer(plaintext)).to.be.true;
@ -118,22 +118,28 @@ describe("Common structures", function() {
describe("message", function() {
it("should decode", function() {
var res;
res = message.decode(Buffer("e9beb4d97465737400000000000000000000000770b33ce97061796c6f6164", "hex"));
res = message.decode(Buffer.from(
"e9beb4d97465737400000000000000000000000770b33ce97061796c6f6164", "hex"
));
expect(res.command).to.equal("test");
expect(res.payload.toString()).to.equal("payload");
expect(res.length).to.equal(31);
expect(res.rest.toString("hex")).to.equal("");
res = message.decode(Buffer("e9beb4d90000000000000000000000000000000770b33ce97061796c6f6164", "hex"));
res = message.decode(Buffer.from(
"e9beb4d90000000000000000000000000000000770b33ce97061796c6f6164", "hex"
));
expect(res.command).to.equal("");
});
it("should throw when decoding message with truncated payload", function() {
expect(message.decode.bind(null, Buffer("e9beb4d97465737400000000000000000000000770b33ce97061796c6f61", "hex"))).to.throw(Error);
expect(message.decode.bind(null, Buffer.from(
"e9beb4d97465737400000000000000000000000770b33ce97061796c6f61", "hex"))
).to.throw(Error);
});
it("should encode", function() {
expect(message.encode("test", Buffer("payload")).toString("hex")).to.equal("e9beb4d97465737400000000000000000000000770b33ce97061796c6f6164");
expect(message.encode("test", Buffer.from("payload")).toString("hex")).to.equal("e9beb4d97465737400000000000000000000000770b33ce97061796c6f6164");
});
it("should encode empty payload without second argument", function() {
@ -143,7 +149,7 @@ describe("Common structures", function() {
});
it("should decode messages in stream mode", function() {
var res = message.tryDecode(Buffer(""));
var res = message.tryDecode(Buffer.from(""));
expect(res).to.not.exist;
res = message.tryDecode(Buffer.alloc(25));
@ -151,15 +157,15 @@ describe("Common structures", function() {
expect(res.rest.toString("hex")).to.equal("");
expect(res).to.not.have.property("message");
res = message.tryDecode(message.encode("test", Buffer([1,2,3])));
res = message.tryDecode(message.encode("test", Buffer.from("010203", "hex")));
expect(res).to.not.have.property("error");
expect(res.message.command).to.equal("test");
expect(res.message.payload.toString("hex")).to.equal("010203");
expect(res.rest.toString("hex")).to.equal("");
var encoded = message.encode("cmd", Buffer("buf"));
var encoded = message.encode("cmd", Buffer.from("buf"));
encoded[20] ^= 1; // Corrupt checksum
encoded = Buffer.concat([encoded, Buffer("rest")]);
encoded = Buffer.concat([encoded, Buffer.from("rest")]);
res = message.tryDecode(encoded);
expect(res.error).to.match(/bad checksum/i);
expect(res.rest.toString()).to.equal("rest");
@ -193,7 +199,7 @@ describe("Common structures", function() {
ttl: 100,
type: 2,
version: 1,
objectPayload: Buffer("test"),
objectPayload: Buffer.from("test"),
}), skipPow);
expect(bufferEqual(nonce, res.nonce)).to.be.true;
@ -213,7 +219,7 @@ describe("Common structures", function() {
ttl: 10000000,
type: 2,
version: 1,
objectPayload: Buffer("test"),
objectPayload: Buffer.from("test"),
})).to.throw(Error);
});
@ -233,7 +239,7 @@ describe("Common structures", function() {
ttl: 100,
type: object.MSG,
version: 1,
objectPayload: Buffer("test"),
objectPayload: Buffer.from("test"),
});
encoded = Buffer.concat([encoded, Buffer.alloc(300000)]);
expect(object.decodePayload.bind(null, encoded)).to.throw(/too big/i);
@ -245,7 +251,7 @@ describe("Common structures", function() {
ttl: 100,
type: 2,
version: 1,
objectPayload: Buffer("test"),
objectPayload: Buffer.from("test"),
}))).to.throw(/insufficient/i);
});
@ -283,35 +289,35 @@ describe("Common structures", function() {
describe("var_int", function() {
it("should decode", function() {
var res;
expect(var_int.decode.bind(null, Buffer([]))).to.throw(Error);
expect(var_int.decode.bind(null, Buffer("fd00", "hex"))).to.throw(Error);
expect(var_int.decode.bind(null, Buffer("ff004170706e9b0368", "hex"))).to.throw(Error);
expect(var_int.decode.bind(null, Buffer.alloc(0))).to.throw(Error);
expect(var_int.decode.bind(null, Buffer.from("fd00", "hex"))).to.throw(Error);
expect(var_int.decode.bind(null, Buffer.from("ff004170706e9b0368", "hex"))).to.throw(Error);
res = var_int.decode(Buffer([123]));
res = var_int.decode(Buffer.from("7b", "hex"));
expect(res.value).to.equal(123);
expect(res.length).to.equal(1);
expect(res.rest.toString("hex")).to.equal("")
res = var_int.decode(Buffer("fd123456", "hex"));
res = var_int.decode(Buffer.from("fd123456", "hex"));
expect(res.value).to.equal(0x1234);
expect(res.length).to.equal(3);
expect(res.rest.toString("hex")).to.equal("56");
res = var_int.decode(Buffer("fe1234567890", "hex"));
res = var_int.decode(Buffer.from("fe1234567890", "hex"));
expect(res.value).to.equal(0x12345678);
expect(res.length).to.equal(5);
expect(res.rest.toString("hex")).to.equal("90");
res = var_int.decode(Buffer("ff0000001234567890", "hex"));
res = var_int.decode(Buffer.from("ff0000001234567890", "hex"));
expect(res.value).to.equal(0x1234567890);
expect(res.length).to.equal(9);
expect(res.rest.length).to.equal(0);
});
it("should check for lowest length on decode", function() {
expect(var_int.decode.bind(null, Buffer("fd00fc", "hex"))).to.throw(Error);
expect(var_int.decode.bind(null, Buffer("fe0000ffff", "hex"))).to.throw(Error);
expect(var_int.decode.bind(null, Buffer("ff00000000ffffffff", "hex"))).to.throw(Error);
expect(var_int.decode.bind(null, Buffer.from("fd00fc", "hex"))).to.throw(Error);
expect(var_int.decode.bind(null, Buffer.from("fe0000ffff", "hex"))).to.throw(Error);
expect(var_int.decode.bind(null, Buffer.from("ff00000000ffffffff", "hex"))).to.throw(Error);
});
it("should encode", function() {
@ -319,10 +325,10 @@ describe("Common structures", function() {
expect(var_int.encode(0x1234).toString("hex")).to.equal("fd1234");
expect(var_int.encode(0x12345678).toString("hex")).to.equal("fe12345678");
expect(var_int.encode(0x1234567890).toString("hex")).to.equal("ff0000001234567890");
expect(var_int.encode(Buffer("1234567890", "hex")).toString("hex")).to.equal("ff0000001234567890");
expect(var_int.encode(Buffer.from("1234567890", "hex")).toString("hex")).to.equal("ff0000001234567890");
expect(var_int.encode.bind(null, -123)).to.throw(Error);
expect(var_int.encode.bind(null, 0x4170706e9b0368)).to.throw(Error);
expect(var_int.encode.bind(null, Buffer("123456789012345678", "hex"))).to.throw(Error);
expect(var_int.encode.bind(null, Buffer.from("123456789012345678", "hex"))).to.throw(Error);
expect(var_int.encode.bind(null, "test")).to.throw(Error);
});
});
@ -330,23 +336,23 @@ describe("Common structures", function() {
describe("var_str", function() {
it("should decode", function() {
var res;
res = var_str.decode(Buffer("00", "hex"));
res = var_str.decode(Buffer.from("00", "hex"));
expect(res.str).to.equal("");
expect(res.length).to.equal(1);
expect(res.rest.toString("hex")).to.equal("");
res = var_str.decode(Buffer("0474657374", "hex"));
res = var_str.decode(Buffer.from("0474657374", "hex"));
expect(res.str).to.equal("test");
expect(res.length).to.equal(5);
expect(res.rest.toString("hex")).to.equal("");
res = var_str.decode(Buffer("0474657374ffffff", "hex"));
res = var_str.decode(Buffer.from("0474657374ffffff", "hex"));
expect(res.str).to.equal("test");
expect(res.length).to.equal(5);
expect(res.rest.toString("hex")).to.equal("ffffff");
// Truncated input.
expect(var_str.decode.bind(null, Buffer("04746573", "hex"))).to.throw(Error);
expect(var_str.decode.bind(null, Buffer.from("04746573", "hex"))).to.throw(Error);
});
it("should encode", function() {
@ -358,12 +364,13 @@ describe("Common structures", function() {
describe("var_int_list", function() {
it("should decode", function() {
var res;
res = var_int_list.decode(Buffer("00", "hex"));
res = var_int_list.decode(Buffer.from("00", "hex"));
expect(res.list).to.deep.equal([]);
expect(res.length).to.equal(1);
expect(res.rest.toString("hex")).to.equal("");
res = var_int_list.decode(Buffer("0501fd0400ff0004000000000000fd9c40fe000186a0", "hex"));
res = var_int_list.decode(Buffer.from(
"0501fd0400ff0004000000000000fd9c40fe000186a0", "hex"));
expect(res.length).to.equal(22);
expect(res.list.length).to.equal(5);
expect(res.list[0]).to.equal(1);
@ -373,13 +380,15 @@ describe("Common structures", function() {
expect(res.list[4]).to.equal(100000);
expect(res.rest.toString("hex")).to.equal("");
res = var_int_list.decode(Buffer("0501fd0400ff0004000000000000fd9c40fe000186a0ffffff", "hex"));
res = var_int_list.decode(Buffer.from(
"0501fd0400ff0004000000000000fd9c40fe000186a0ffffff", "hex"));
expect(res.length).to.equal(22);
expect(res.list.length).to.equal(5);
expect(res.rest.toString("hex")).to.equal("ffffff");
// Truncated input.
expect(var_int_list.decode.bind(null, Buffer("0501fd0400ff0004000000000000fd9c40fe000186", "hex"))).to.throw(Error);
expect(var_int_list.decode.bind(null, Buffer.from(
"0501fd0400ff0004000000000000fd9c40fe000186", "hex"))).to.throw(Error);
});
it("should encode", function() {
@ -393,21 +402,22 @@ describe("Common structures", function() {
describe("net_addr", function() {
it("should decode", function() {
var res;
res = net_addr.decode(Buffer("0000000054aaf6c000000001000000000000000100000000000000000000ffff7f00000120fc", "hex"));
res = net_addr.decode(Buffer.from("0000000054aaf6c000000001000000000000000100000000000000000000ffff7f00000120fc", "hex"));
expect(res.time.getTime()).to.equal(1420490432000);
expect(res.stream).to.equal(1);
expect(res.services.get(ServicesBitfield.NODE_NETWORK)).to.be.true;
expect(res.host).to.equal("127.0.0.1");
expect(res.port).to.equal(8444);
expect(net_addr.decode.bind(null, Buffer("000000000000000100000000000000000000ffff7f00000120fc", "hex"))).to.throw(Error);;
expect(net_addr.decode.bind(null, Buffer.from(
"000000000000000100000000000000000000ffff7f00000120fc", "hex"))).to.throw(Error);;
res = net_addr.decode(Buffer("000000000000000100000000000000000000ffff7f00000120fc", "hex"), {short: true});
res = net_addr.decode(Buffer.from("000000000000000100000000000000000000ffff7f00000120fc", "hex"), {short: true});
expect(res.services.get(ServicesBitfield.NODE_NETWORK)).to.be.true;
expect(res.host).to.equal("127.0.0.1");
expect(res.port).to.equal(8444);
res = net_addr.decode(Buffer("000000000000000100000000000000000000000000000001fde8", "hex"), {short: true});
res = net_addr.decode(Buffer.from("000000000000000100000000000000000000000000000001fde8", "hex"), {short: true});
expect(res.services.get(ServicesBitfield.NODE_NETWORK)).to.be.true;
expect(res.host).to.equal("0:0:0:0:0:0:0:1");
expect(res.port).to.equal(65000);
@ -454,7 +464,7 @@ describe("Common structures", function() {
ephemPublicKey.writeUInt16BE(714, 0, true);
ephemPublicKey.writeUInt16BE(32, 2, true);
ephemPublicKey.writeUInt16BE(32, 36, true);
var ciphertext = Buffer("test");
var ciphertext = Buffer.from("test");
var mac = Buffer.alloc(32);
var inopts = {
iv: iv,
@ -475,7 +485,7 @@ describe("Common structures", function() {
describe("service features", function() {
it("should allow to check bits", function() {
expect(ServicesBitfield(Buffer("0000000000000001", "hex")).get(ServicesBitfield.NODE_NETWORK)).to.be.true;
expect(ServicesBitfield(Buffer.from("0000000000000001", "hex")).get(ServicesBitfield.NODE_NETWORK)).to.be.true;
});
it("should allow to set bits", function() {
@ -494,7 +504,7 @@ describe("Common structures", function() {
describe("pubkey features", function() {
it("should allow to check bits", function() {
expect(PubkeyBitfield(Buffer("00000003", "hex")).get([PubkeyBitfield.DOES_ACK, PubkeyBitfield.INCLUDE_DESTINATION])).to.be.true;
expect(PubkeyBitfield(Buffer.from("00000003", "hex")).get([PubkeyBitfield.DOES_ACK, PubkeyBitfield.INCLUDE_DESTINATION])).to.be.true;
});
it("should allow to set bits", function() {
@ -507,14 +517,14 @@ describe("Common structures", function() {
// TODO(Kagami): Add tests for encodePayload/decodePayload as well.
describe("Message types", function() {
it("should get command for encoded message", function() {
var encoded = message.encode("test", Buffer(0));
var encoded = message.encode("test", Buffer.alloc(0));
expect(messages.getCommand(encoded)).to.equal("test");
expect(messages.getCommand(Buffer("test"))).to.be.undefined;
expect(messages.getCommand(Buffer.from("test"))).to.be.undefined;
});
describe("version", function() {
it("should encode and decode", function() {
var nonce = Buffer(8);
var nonce = Buffer.alloc(8);
var encoded = version.encode({
remoteHost: "1.2.3.4",
remotePort: 48444,
@ -549,7 +559,7 @@ describe("Message types", function() {
expect(version.encode.bind(null, {
remoteHost: "1.2.3.4",
remotePort: 8444,
userAgent: Buffer(6000),
userAgent: Buffer.alloc(6000),
})).to.throw(/agent is too long/i);
});
@ -605,7 +615,7 @@ describe("Message types", function() {
{host: "fc00::3:2:1", port: 9},
]).toString("hex")).to.equal("010000000054f04bfe00000001000000000000000100000000000000000000ffff010203040003");
var res = addr.decodePayload(Buffer("090000000054f04b9b00000001000000000000000100000000000000000000ffff7f00000100010000000054f04b9b00000001000000000000000100000000000000000000ffff7f05030100020000000054f04b9b00000001000000000000000100000000000000000000ffff0102030400030000000054f04b9b00000001000000000000000100000000000000000000ffffc0a80f1400040000000054f04b9b00000001000000000000000100000000000000000000ffff0a0a0a0a00050000000054f04b9b00000001000000000000000100000000000000000000ffffac112a0100060000000054f04b9b0000000100000000000000010000000000000000000000000000000100070000000054f04b9b000000010000000000000001fe80000000000000000000010002000300080000000054f04b9b000000010000000000000001fc0000000000000000000003000200010009", "hex"));
var res = addr.decodePayload(Buffer.from("090000000054f04b9b00000001000000000000000100000000000000000000ffff7f00000100010000000054f04b9b00000001000000000000000100000000000000000000ffff7f05030100020000000054f04b9b00000001000000000000000100000000000000000000ffff0102030400030000000054f04b9b00000001000000000000000100000000000000000000ffffc0a80f1400040000000054f04b9b00000001000000000000000100000000000000000000ffff0a0a0a0a00050000000054f04b9b00000001000000000000000100000000000000000000ffffac112a0100060000000054f04b9b0000000100000000000000010000000000000000000000000000000100070000000054f04b9b000000010000000000000001fe80000000000000000000010002000300080000000054f04b9b000000010000000000000001fc0000000000000000000003000200010009", "hex"));
expect(res.addrs).to.have.length(1);
expect(res.addrs[0].host).to.equal("1.2.3.4");
expect(res.addrs[0].port).to.equal(3);
@ -614,8 +624,8 @@ describe("Message types", function() {
describe("inv", function() {
it("should encode and decode", function() {
var vect1 = inv_vect.encode(Buffer("test"));
var vect2 = inv_vect.encode(Buffer("test2"));
var vect1 = inv_vect.encode(Buffer.from("test"));
var vect2 = inv_vect.encode(Buffer.from("test2"));
var vectors = [vect1, vect2];
var encoded = inv.encode(vectors);
expect(message.decode(encoded).command).to.equal("inv");
@ -634,8 +644,8 @@ describe("Message types", function() {
describe("getdata", function() {
it("should encode and decode", function() {
var vect1 = inv_vect.encode(Buffer("test"));
var vect2 = inv_vect.encode(Buffer("test2"));
var vect1 = inv_vect.encode(Buffer.from("test"));
var vect2 = inv_vect.encode(Buffer.from("test2"));
var vectors = [vect1, vect2];
var encoded = getdata.encode(vectors);
expect(message.decode(encoded).command).to.equal("getdata");
@ -664,7 +674,7 @@ describe("Message types", function() {
expect(res.length).to.equal(8);
expect(error.type2str(res.type)).to.equal("warning");
var vector = inv_vect.encode(Buffer("test"));
var vector = inv_vect.encode(Buffer.from("test"));
var res = error.decode(error.encode({
type: error.FATAL,
banTime: 120,
@ -683,9 +693,11 @@ describe("Message types", function() {
// TODO(Kagami): Add tests for encodePayloadAsync/decodePayloadAsync as well.
describe("Object types", function() {
var signPrivateKey = Buffer("71c95d26c716a5e85e9af9efe26fb5f744dc98005a13d05d23ee92c77e038d9f", "hex");
var signPrivateKey = Buffer.from(
"71c95d26c716a5e85e9af9efe26fb5f744dc98005a13d05d23ee92c77e038d9f", "hex");
var signPublicKey = bmcrypto.getPublic(signPrivateKey);
var encPrivateKey = Buffer("9f9969c93c2d186787a7653f70e49be34c03c4a853e6ad0c867db0946bc433c6", "hex");
var encPrivateKey = Buffer.from(
"9f9969c93c2d186787a7653f70e49be34c03c4a853e6ad0c867db0946bc433c6", "hex");
var encPublicKey = bmcrypto.getPublic(encPrivateKey);
var fromV2 = Address({
version: 2,
@ -705,26 +717,26 @@ describe("Object types", function() {
it("should get type of the encoded object message", function() {
var encoded = object.encode({
nonce: Buffer(8),
nonce: Buffer.alloc(8),
ttl: 100,
type: object.BROADCAST,
version: 1,
objectPayload: Buffer("test"),
objectPayload: Buffer.from("test"),
});
expect(objects.getType(encoded)).to.equal(object.BROADCAST);
expect(objects.getType(Buffer(4))).to.be.undefined;
expect(objects.getType(Buffer.alloc(4))).to.be.undefined;
});
it("should get type of the object message payload", function() {
var encoded = object.encodePayload({
nonce: Buffer(8),
nonce: Buffer.alloc(8),
ttl: 333,
type: object.MSG,
version: 1,
objectPayload: Buffer("test"),
objectPayload: Buffer.from("test"),
});
expect(objects.getPayloadType(encoded)).to.equal(object.MSG);
expect(objects.getPayloadType(Buffer(7))).to.be.undefined;
expect(objects.getPayloadType(Buffer.alloc(7))).to.be.undefined;
});
describe("getpubkey", function() {
@ -975,7 +987,7 @@ describe("Object types", function() {
ttl: 111,
from: from,
to: from,
message: Buffer(300000),
message: Buffer.alloc(300000),
skipPow: true,
}).catch(function(err) {
expect(err.message).to.match(/too big/i);
@ -1108,7 +1120,7 @@ describe("Object types", function() {
return broadcast.encodeAsync({
ttl: 101,
from: from,
message: Buffer(300000),
message: Buffer.alloc(300000),
skipPow: true,
}).catch(function(err) {
expect(err.message).to.match(/too big/i);
@ -1138,8 +1150,10 @@ describe("Object types", function() {
describe("WIF", function() {
var wifSign = "5JgQ79vTBusc61xYPtUEHYQ38AXKdDZgQ5rFp7Cbb4ZjXUKFZEV";
var wifEnc = "5K2aL8cnsEWHwHfHnUrPo8QdYyRfoYUBmhAnWY5GTpDLbeyusnE";
var signPrivateKey = Buffer("71c95d26c716a5e85e9af9efe26fb5f744dc98005a13d05d23ee92c77e038d9f", "hex");
var encPrivateKey = Buffer("9f9969c93c2d186787a7653f70e49be34c03c4a853e6ad0c867db0946bc433c6", "hex");
var signPrivateKey = Buffer.from(
"71c95d26c716a5e85e9af9efe26fb5f744dc98005a13d05d23ee92c77e038d9f", "hex");
var encPrivateKey = Buffer.from(
"9f9969c93c2d186787a7653f70e49be34c03c4a853e6ad0c867db0946bc433c6", "hex");
it("should decode", function() {
var key1 = WIF.decode(wifSign);
@ -1169,15 +1183,15 @@ describe("POW", function() {
});
it("should check a POW", function() {
expect(POW.check({nonce: 21997550, target: 297422525267, initialHash: Buffer("8ff2d685db89a0af2e3dbfd3f700ae96ef4d9a1eac72fd778bbb368c7510cddda349e03207e1c4965bd95c6f7265e8f1a481a08afab3874eaafb9ade09a10880", "hex")})).to.be.true;
expect(POW.check({nonce: 3122437, target: 4864647698763, initialHash: Buffer("8ff2d685db89a0af2e3dbfd3f700ae96ef4d9a1eac72fd778bbb368c7510cddda349e03207e1c4965bd95c6f7265e8f1a481a08afab3874eaafb9ade09a10880", "hex")})).to.be.true;
expect(POW.check({nonce: 3122436, target: 4864647698763, initialHash: Buffer("8ff2d685db89a0af2e3dbfd3f700ae96ef4d9a1eac72fd778bbb368c7510cddda349e03207e1c4965bd95c6f7265e8f1a481a08afab3874eaafb9ade09a10880", "hex")})).to.be.false;
expect(POW.check({nonce: 21997550, target: 297422525267, initialHash: Buffer.from("8ff2d685db89a0af2e3dbfd3f700ae96ef4d9a1eac72fd778bbb368c7510cddda349e03207e1c4965bd95c6f7265e8f1a481a08afab3874eaafb9ade09a10880", "hex")})).to.be.true;
expect(POW.check({nonce: 3122437, target: 4864647698763, initialHash: Buffer.from("8ff2d685db89a0af2e3dbfd3f700ae96ef4d9a1eac72fd778bbb368c7510cddda349e03207e1c4965bd95c6f7265e8f1a481a08afab3874eaafb9ade09a10880", "hex")})).to.be.true;
expect(POW.check({nonce: 3122436, target: 4864647698763, initialHash: Buffer.from("8ff2d685db89a0af2e3dbfd3f700ae96ef4d9a1eac72fd778bbb368c7510cddda349e03207e1c4965bd95c6f7265e8f1a481a08afab3874eaafb9ade09a10880", "hex")})).to.be.false;
});
it("should reject promise on bad POW arguments", function(done) {
POW.doAsync({target: 123, initialHash: {}}).catch(function() {
POW.doAsync({target: 123, initialHash: Buffer("test")}).catch(function() {
POW.doAsync({poolSize: -1, target: 123, initialHash: Buffer(64)})
POW.doAsync({target: 123, initialHash: Buffer.from("test")}).catch(function() {
POW.doAsync({poolSize: -1, target: 123, initialHash: Buffer.alloc(64)})
.catch(function() {
done();
});
@ -1189,7 +1203,7 @@ describe("POW", function() {
it("should do a POW", function() {
this.timeout(300000);
var target = typeof window === "undefined" ? 297422525267 : 10688385392246;
var initialHash = Buffer("8ff2d685db89a0af2e3dbfd3f700ae96ef4d9a1eac72fd778bbb368c7510cddda349e03207e1c4965bd95c6f7265e8f1a481a08afab3874eaafb9ade09a10880", "hex");
var initialHash = Buffer.from("8ff2d685db89a0af2e3dbfd3f700ae96ef4d9a1eac72fd778bbb368c7510cddda349e03207e1c4965bd95c6f7265e8f1a481a08afab3874eaafb9ade09a10880", "hex");
return POW.doAsync({target: target, initialHash: initialHash})
.then(function(nonce) {
// FIXME(Kagami): Chromium behaves very strangely on Travis CI:
@ -1318,14 +1332,17 @@ describe("High-level classes", function() {
it("should provide setters for keys and ripe", function() {
var addr = Address();
expect(function(){addr.ripe}).to.throw(Error);
addr.signPrivateKey = Buffer("71c95d26c716a5e85e9af9efe26fb5f744dc98005a13d05d23ee92c77e038d9f", "hex");
addr.signPrivateKey = Buffer.from(
"71c95d26c716a5e85e9af9efe26fb5f744dc98005a13d05d23ee92c77e038d9f", "hex");
expect(addr.signPublicKey.toString("hex")).to.equal("042d391543f574608cbcdfd12a37cc4c74dd36e54510b13a6a1d8b7b1498fb96c92873d33ca17586dace7f5ad0f4532a954061ac06bc5230aed9c8374072546571");
expect(function(){addr.ripe}).to.throw(Error);
addr.encPrivateKey = Buffer("9f9969c93c2d186787a7653f70e49be34c03c4a853e6ad0c867db0946bc433c6", "hex");
addr.encPrivateKey = Buffer.from(
"9f9969c93c2d186787a7653f70e49be34c03c4a853e6ad0c867db0946bc433c6", "hex");
expect(addr.encPublicKey.toString("hex")).to.equal("04c6ed1b56f2da97fec1b762d43364566faf082c1e4918ae1dbb41757cad41b03b2cc5087f341414e63f6eee72a1fbf0b5f346a1bb3ba944cad204ca597db2bfc8");
expect(addr.ripe.toString("hex")).to.equal("003ab6655de4bd8c603eba9b00dd5970725fdd56");
expect(addr.getShortRipe().toString("hex")).to.equal("3ab6655de4bd8c603eba9b00dd5970725fdd56");
addr.encPrivateKey = Buffer("009969c93c2d186787a7653f70e49be34c03c4a853e6ad0c867db0946bc433c6", "hex");
addr.encPrivateKey = Buffer.from(
"009969c93c2d186787a7653f70e49be34c03c4a853e6ad0c867db0946bc433c6", "hex");
expect(addr.getShortRipe().toString("hex")).to.equal("69617ddb1946dc327cadffcf33889fed587fc1e7");
});
@ -1349,8 +1366,10 @@ describe("High-level classes", function() {
expect(addr2.getTag().toString("hex")).to.equal("d6487aaea3d2d022d80abbce2605089523ba2b516b81c03545f19a5c85f15fa2");
var addr3 = Address({
signPrivateKey: Buffer("71c95d26c716a5e85e9af9efe26fb5f744dc98005a13d05d23ee92c77e038d9f", "hex"),
encPrivateKey: Buffer("9f9969c93c2d186787a7653f70e49be34c03c4a853e6ad0c867db0946bc433c6", "hex"),
signPrivateKey: Buffer.from(
"71c95d26c716a5e85e9af9efe26fb5f744dc98005a13d05d23ee92c77e038d9f", "hex"),
encPrivateKey: Buffer.from(
"9f9969c93c2d186787a7653f70e49be34c03c4a853e6ad0c867db0946bc433c6", "hex"),
});
var addr4 = addr3.clone();
expect(addr4.signPrivateKey.toString("hex")).to.equal("71c95d26c716a5e85e9af9efe26fb5f744dc98005a13d05d23ee92c77e038d9f");