lukechilds
/
bitcoincashjs
mirror of https://github.com/lukechilds/bitcoincashjs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

make address more consistent with rest of lib

patch-2
Ryan X. Charles 11 years ago
parent
cd6c2b2410
commit
3871e43dd8
3 changed files with 109 additions and 153 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 106
      lib/address.js
  2. 4
      lib/constants.js
  3. 146
      test/test.address.js

106
lib/address.js
View File

@ -1,78 +1,64 @@
var base58check = require('./base58check'); var base58check = require('./base58check');
var constants = require('./constants'); var constants = require('./constants');
function Address(str) { function Address(hash, network, type) {
if (!str) { this.hash = hash;
this.buf = undefined; this.network = network;
return; this.type = type;
}
if (typeof str !== 'string')
throw new Error('address: Input must be a string, or undefined');
this.fromString(str);
};
Address.prototype.getNetwork = function() {
if (this.buf[0] === constants.mainnet.pubkeyHash || this.buf[0] === constants.mainnet.p2sh)
return 'mainnet';
else if (this.buf[0] === constants.testnet.pubkeyHash || this.buf[0] === constants.testnet.p2sh)
return 'testnet';
else
return 'unknown';
}; };
Address.prototype.getHash = function() { Address.prototype.fromString = function(str) {
var pubkeyHash = this.buf.slice(1); var buf = base58check.decode(str);
if (pubkeyHash.length === 20) if (buf.length !== 1 + 20)
return pubkeyHash; throw new Error('address: Address buffers must be exactly 21 bytes');
else var version = buf[0];
throw new Error('address: Hash must be exactly 20 bytes'); if (version === constants['mainnet']['pubkeyhash']) {
}; this.network = 'mainnet';
this.type = 'pubkeyhash';
} else if (version === constants['mainnet']['p2sh']) {
this.network = 'mainnet';
this.type = 'p2sh';
} else if (version === constants['testnet']['pubkeyhash']) {
this.network = 'testnet';
this.type = 'pubkeyhash';
} else if (version === constants['testnet']['p2sh']) {
this.network = 'testnet';
this.type = 'p2sh';
} else {
this.network = 'unknown';
this.type = 'unknown';
}
Address.prototype.getType = function() { this.hash = buf.slice(1);
if (this.buf[0] === constants.mainnet.pubkeyHash || this.buf[0] === constants.testnet.pubkeyHash) }
return 'pubkeyHash';
else if (this.buf[0] === constants.mainnet.p2sh || this.buf[0] === constants.testnet.p2sh)
return 'p2sh';
else
return 'unknown';
};
Address.prototype.isValid = function() { Address.prototype.isValid = function() {
if (Buffer.isBuffer(this.buf) && this.buf.length === 1 + 20) try {
this.validate();
return true; return true;
else } catch (e) {
return false; return false;
}
}; };
Address.prototype.setBuf = function(buf, network, type) { Address.prototype.toBuffer = function() {
var version; version = new Buffer([constants[this.network][this.type]]);
if (!Buffer.isBuffer(buf)) var buf = Buffer.concat([version, this.hash]);
throw new Error('address: buf must be a buffer'); return buf;
if (buf.length !== 20)
throw new Error('address: buf must be 20 bytes');
if (typeof network === 'undefined')
throw new Error('address: Must specify network ("mainnet" or "testnet")');
if (typeof type === 'undefined')
throw new Error('address: Must specify type ("pubkeyHash" or "p2sh")');
if (network !== 'mainnet' && network !== 'testnet')
throw new Error('address: Unknown network');
if (type !== 'pubkeyHash' && type !== 'p2sh')
throw new Error('address: Unknown type');
version = new Buffer([constants[network][type]]);
this.buf = Buffer.concat([version, buf]);
}; };
Address.prototype.fromString = function(str) {
var buf = base58check.decode(str);
if (buf.length !== 1 + 20)
throw new Error('address: Addresses must be exactly 21 bytes');
this.buf = buf;
}
Address.prototype.toString = function() { Address.prototype.toString = function() {
return base58check.encode(this.buf); return base58check.encode(this.toBuffer());
};
Address.prototype.validate = function() {
if (!Buffer.isBuffer(this.hash) || this.hash.length !== 20)
throw new Error('address: hash must be a buffer of 20 bytes');
if (this.network !== 'mainnet' && this.network !== 'testnet')
throw new Error('address: network must be "mainnet" or "testnet"');
if (this.type !== 'pubkeyhash' && this.type !== 'p2sh')
throw new Error('address: type must be "pubkeyhash" or "p2sh"');
return this;
}; };
module.exports = Address; module.exports = Address;

4
lib/constants.js
View File

@ -1,5 +1,5 @@
exports.mainnet = { exports.mainnet = {
pubkeyHash: 0x00, pubkeyhash: 0x00,
privkey: 0x80, privkey: 0x80,
p2sh: 0x05, p2sh: 0x05,
bip32pubkey: 0x0488b21e, bip32pubkey: 0x0488b21e,
@ -7,7 +7,7 @@ exports.mainnet = {
}; };
exports.testnet = { exports.testnet = {
pubkeyHash: 0x6f, pubkeyhash: 0x6f,
privkey: 0xef, privkey: 0xef,
p2sh: 0xc4, p2sh: 0xc4,
bip32pubkey: 0x043587cf, bip32pubkey: 0x043587cf,

146
test/test.address.js
View File

@ -4,147 +4,117 @@ var Address = require('../lib/address');
describe('address', function() { describe('address', function() {
var pubkeyhash = new Buffer('3c3fa3d4adcaf8f52d5b1843975e122548269937', 'hex'); var pubkeyhash = new Buffer('3c3fa3d4adcaf8f52d5b1843975e122548269937', 'hex');
var str = '1Cs8a3b7R5n4G9c8Cgbp9iW8BXbhv3SFt6'; var str = '16VZnHwRhwrExfeHFHGjwrgEMq8VcYPs9r';
it('should create a new address object', function() { it('should create a new address object', function() {
var address = new Address(); var address = new Address();
should.exist(address); should.exist(address);
}); });
it('should throw an error when input is not a string', function() { describe('#fromString', function() {
(function() {
var address = new Address(5);
}).should.throw('address: Input must be a string, or undefined');
});
describe('#getNetwork', function() {
it('should return mainnet for pubkeyhash', function() { it('should derive from this known address string mainnet', function() {
var address = new Address(); var address = new Address();
address.buf = Buffer.concat([new Buffer([constants.mainnet.pubkeyHash]), pubkeyhash]); address.fromString(str);
address.getNetwork().should.equal('mainnet'); address.toBuffer().slice(1).toString('hex').should.equal(pubkeyhash.toString('hex'));
}); });
it('should return mainnet for p2sh', function() { it('should derive from this known address string testnet', function() {
var address = new Address(); var address = new Address();
address.buf = Buffer.concat([new Buffer([constants.mainnet.p2sh]), pubkeyhash]); address.fromString(str);
address.getNetwork().should.equal('mainnet'); address.network = 'testnet';
address.fromString(address.toString());
address.toString().should.equal('mm1X5M2QWyHVjn7txrF7mmtZDpjCXzoa98');
}); });
it('should return testnet for pubkeyhash', function() { it('should derive from this known address string mainnet p2sh', function() {
var address = new Address(); var address = new Address();
address.buf = Buffer.concat([new Buffer([constants.testnet.pubkeyHash]), pubkeyhash]); address.fromString(str);
address.getNetwork().should.equal('testnet'); address.network = 'mainnet';
address.type = 'p2sh';
address.fromString(address.toString());
address.toString().should.equal('37BahqRsFrAd3qLiNNwLNV3AWMRD7itxTo');
}); });
it('should return testnet for p2sh', function() { it('should derive from this known address string testnet p2sh', function() {
var address = new Address(); var address = new Address();
address.buf = Buffer.concat([new Buffer([constants.testnet.p2sh]), pubkeyhash]); address.fromString(str);
address.getNetwork().should.equal('testnet'); address.network = 'testnet';
address.type = 'p2sh';
address.fromString(address.toString());
address.toString().should.equal('2MxjnmaMtsJfyFcyG3WZCzS2RihdNuWqeX4');
}); });
it('should return unknown', function() {
var address = new Address();
address.buf = Buffer.concat([new Buffer([0x55]), pubkeyhash]);
address.getNetwork().should.equal('unknown');
}); });
it('should throw an error if there is no buffer', function() { describe('#isValid', function() {
var address = new Address();
(function() {
address.getNetwork();
}).should.throw();
});
it('should describe this valid address as valid', function() {
var address = new Address();
address.fromString('37BahqRsFrAd3qLiNNwLNV3AWMRD7itxTo');
address.isValid().should.equal(true);
}); });
describe('#getHash', function() { it('should describe this address with unknown network as invalid', function() {
it('should return the hash', function() {
var address = new Address(); var address = new Address();
address.buf = Buffer.concat([new Buffer([0x00]), pubkeyhash]); address.fromString('37BahqRsFrAd3qLiNNwLNV3AWMRD7itxTo');
address.getHash().toString('hex').should.equal(pubkeyhash.toString('hex')); address.network = 'unknown';
address.isValid().should.equal(false);
}); });
it('should throw an error if the buffer is an invalid length', function() { it('should describe this address with unknown type as invalid', function() {
var address = new Address(); var address = new Address();
address.buf = Buffer.concat([new Buffer([0x00]), pubkeyhash.slice(-1)]); address.fromString('37BahqRsFrAd3qLiNNwLNV3AWMRD7itxTo');
(function() { address.type = 'unknown';
address.getHash(); address.isValid().should.equal(false);
}).should.throw('address: Hash must be exactly 20 bytes');
}); });
}); });
describe('#getType', function() { describe('#toBuffer', function() {
it('should get the type of 2MxjnmaMtsJfyFcyG3WZCzS2RihdNuWqeX4 correctly', function() { it('should output this known hash', function() {
var addr = new Address(); var address = new Address();
addr.fromString('2MxjnmaMtsJfyFcyG3WZCzS2RihdNuWqeX4'); address.fromString(str);
addr.getNetwork().should.equal('testnet'); address.toBuffer().slice(1).toString('hex').should.equal(pubkeyhash.toString('hex'));
addr.getType().should.equal('p2sh');
}); });
}); });
describe('#setBuf', function() { describe('#toString', function() {
it('should convert this pubkeyhash on mainnet and type pubkeyHash to known address', function() { it('should output the same thing that was input', function() {
var address = new Address(); var address = new Address();
address.setBuf(pubkeyhash, 'mainnet', 'pubkeyHash'); address.fromString(str);
address.toString().should.equal('16VZnHwRhwrExfeHFHGjwrgEMq8VcYPs9r'); address.toString().should.equal(str);
}); });
it('should convert this pubkeyhash on mainnet and type p2sh to known address', function() {
var address = new Address();
address.setBuf(pubkeyhash, 'mainnet', 'p2sh');
address.toString().should.equal('37BahqRsFrAd3qLiNNwLNV3AWMRD7itxTo');
}); });
it('should convert this pubkeyhash on testnet and type pubkeyHash to known address', function() { describe('#validate', function() {
var address = new Address();
address.setBuf(pubkeyhash, 'testnet', 'pubkeyHash');
address.toString().should.equal('mm1X5M2QWyHVjn7txrF7mmtZDpjCXzoa98');
});
it('should convert this pubkeyhash on testnet and type p2sh to known address', function() { it('should not throw an error on this valid address', function() {
var address = new Address(); var address = new Address();
address.setBuf(pubkeyhash, 'testnet', 'p2sh'); address.fromString(str);
address.toString().should.equal('2MxjnmaMtsJfyFcyG3WZCzS2RihdNuWqeX4'); should.exist(address.validate());
}); });
it('should throw an error for an unknown type', function() { it('should throw an error on this invalid network', function() {
var address = new Address(); var address = new Address();
address.fromString(str);
address.network = 'unknown';
(function() { (function() {
address.setBuf(pubkeyhash, 'testnet', 'p2sh2'); address.validate();
}).should.throw(); }).should.throw('address: network must be "mainnet" or "testnet"');
}); });
it('should throw an error for an unknown network', function() { it('should throw an error on this invalid type', function() {
var address = new Address(); var address = new Address();
address.fromString(str);
address.type = 'unknown';
(function() { (function() {
address.setBuf(pubkeyhash, 'testnet2', 'p2sh'); address.validate();
}).should.throw(); }).should.throw('address: type must be "pubkeyhash" or "p2sh"');
});
});
describe('#fromString', function() {
it('should decode 1Cs8a3b7R5n4G9c8Cgbp9iW8BXbhv3SFt6 correctly', function() {
var addr = new Address();
addr.fromString('1Cs8a3b7R5n4G9c8Cgbp9iW8BXbhv3SFt6');
addr.getHash().toString('hex').should.equal('82248027cfb0fe085b750f359fd1e43234e46c7f');
});
});
describe('#toString', function() {
it('should return 1Cs8a3b7R5n4G9c8Cgbp9iW8BXbhv3SFt6', function() {
var addr = new Address();
addr.fromString('1Cs8a3b7R5n4G9c8Cgbp9iW8BXbhv3SFt6');
addr.toString().should.equal('1Cs8a3b7R5n4G9c8Cgbp9iW8BXbhv3SFt6');
}); });
}); });

Write Preview
Loading…
Cancel
Save