RanchiMall/fcoin
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

utils: start using bbuf.

Browse Source
This commit is contained in:
Christopher Jeffrey 2017-10-30 21:29:49 -07:00
parent e92b1f4cec
commit 41925d495c
No known key found for this signature in database
GPG Key ID: 8962AB9DE6666BBD
83 changed files with 161 additions and 2725 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
browser/wsproxy.js
View File

@ -6,7 +6,7 @@ const EventEmitter = require('events');
const bsock = require('bsock');
const digest = require('bcrypto/lib/digest');
const IP = require('../lib/utils/ip');
const BufferWriter = require('../lib/utils/writer');
const BufferWriter = require('bbuf/lib/writer');
const TARGET = Buffer.from(
'0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',

5
lib/bcoin-browser.js
View File

@ -125,14 +125,9 @@ bcoin.witness = require('./script/witness');
bcoin.utils = require('./utils');
bcoin.base32 = require('./utils/base32');
bcoin.base58 = require('./utils/base58');
bcoin.bloom = require('bfilter/lib/bloom');
bcoin.co = require('./utils/co');
bcoin.encoding = require('./utils/encoding');
bcoin.lock = require('./utils/lock');
bcoin.reader = require('./utils/reader');
bcoin.staticwriter = require('./utils/staticwriter');
bcoin.util = require('./utils/util');
bcoin.writer = require('./utils/writer');
// Wallet
bcoin.wallet = require('./wallet');

5
lib/bcoin.js
View File

@ -160,14 +160,9 @@ bcoin.define('witness', './script/witness');
bcoin.define('utils', './utils');
bcoin.define('base32', './utils/base32');
bcoin.define('base58', './utils/base58');
bcoin.define('bloom', './utils/bloom');
bcoin.define('co', './utils/co');
bcoin.define('encoding', './utils/encoding');
bcoin.define('lock', './utils/lock');
bcoin.define('reader', './utils/reader');
bcoin.define('staticwriter', './utils/staticwriter');
bcoin.define('util', './utils/util');
bcoin.define('writer', './utils/writer');
// Wallet
bcoin.define('wallet', './wallet');

2
lib/blockchain/chain.js
View File

@ -23,7 +23,7 @@ const CoinView = require('../coins/coinview');
const Script = require('../script/script');
const {VerifyError} = require('../protocol/errors');
const co = require('../utils/co');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const thresholdStates = common.thresholdStates;
/**

6
lib/blockchain/chaindb.js
View File

@ -9,10 +9,10 @@
const assert = require('assert');
const BDB = require('bdb');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const Amount = require('../btc/amount');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const Network = require('../protocol/network');
const CoinView = require('../coins/coinview');
const UndoCoins = require('../coins/undocoins');

6
lib/blockchain/chainentry.js
View File

@ -11,9 +11,9 @@ const assert = require('assert');
const BN = require('bcrypto/lib/bn');
const consensus = require('../protocol/consensus');
const digest = require('bcrypto/lib/digest');
const encoding = require('../utils/encoding');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const encoding = require('bbuf/lib/encoding');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const Headers = require('../primitives/headers');
const InvItem = require('../primitives/invitem');
const ZERO = new BN(0);

6
lib/coins/coinentry.js
View File

@ -9,9 +9,9 @@
const assert = require('assert');
const Coin = require('../primitives/coin');
const Output = require('../primitives/output');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const encoding = require('../utils/encoding');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const encoding = require('bbuf/lib/encoding');
const compress = require('./compress');
/*

2
lib/coins/compress.js
View File

@ -13,7 +13,7 @@
const assert = require('assert');
const secp256k1 = require('bcrypto/lib/secp256k1');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const consensus = require('../protocol/consensus');
/*

4
lib/coins/undocoins.js
View File

@ -7,8 +7,8 @@
'use strict';
const assert = require('assert');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const CoinEntry = require('../coins/coinentry');
/**

6
lib/hd/mnemonic.js
View File

@ -12,9 +12,9 @@ const cleanse = require('bcrypto/lib/cleanse');
const random = require('bcrypto/lib/random');
const pbkdf2 = require('bcrypto/lib/pbkdf2');
const sha512 = require('bcrypto/lib/sha512');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('../utils/reader');
const encoding = require('../utils/encoding');
const StaticWriter = require('bbuf/lib/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const encoding = require('bbuf/lib/encoding');
const wordlist = require('./wordlist');
const common = require('./common');
const nfkd = require('./nfkd');

6
lib/hd/private.js
View File

@ -12,10 +12,10 @@ const cleanse = require('bcrypto/lib/cleanse');
const random = require('bcrypto/lib/random');
const secp256k1 = require('bcrypto/lib/secp256k1');
const Network = require('../protocol/network');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('../utils/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const base58 = require('../utils/base58');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const common = require('./common');
const Mnemonic = require('./mnemonic');
const HDPublicKey = require('./public');

6
lib/hd/public.js
View File

@ -11,10 +11,10 @@ const digest = require('bcrypto/lib/digest');
const cleanse = require('bcrypto/lib/cleanse');
const secp256k1 = require('bcrypto/lib/secp256k1');
const Network = require('../protocol/network');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('../utils/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const base58 = require('../utils/base58');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const common = require('./common');
/**

6
lib/mempool/fees.js
View File

@ -12,9 +12,9 @@ const assert = require('assert');
const binary = require('../utils/binary');
const consensus = require('../protocol/consensus');
const policy = require('../protocol/policy');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const encoding = require('../utils/encoding');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const encoding = require('bbuf/lib/encoding');
const Logger = require('../node/logger');
/*

2
lib/mempool/mempool.js
View File

@ -25,7 +25,7 @@ const Coin = require('../primitives/coin');
const TXMeta = require('../primitives/txmeta');
const MempoolEntry = require('./mempoolentry');
const Network = require('../protocol/network');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const layout = require('./layout');
const Fees = require('./fees');
const CoinView = require('../coins/coinview');

4
lib/mempool/mempoolentry.js
View File

@ -9,8 +9,8 @@
const policy = require('../protocol/policy');
const util = require('../utils/util');
const Script = require('../script/script');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const TX = require('../primitives/tx');
/**

2
lib/mining/cpuminer.js
View File

@ -13,7 +13,7 @@ const co = require('../utils/co');
const AsyncObject = require('../utils/asyncobject');
const mine = require('./mine');
const Lock = require('../utils/lock');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
/**
* CPU miner.

4
lib/mining/template.js
View File

@ -10,7 +10,7 @@
const assert = require('assert');
const hash256 = require('bcrypto/lib/hash256');
const merkle = require('bcrypto/lib/merkle');
const StaticWriter = require('../utils/staticwriter');
const StaticWriter = require('bbuf/lib/staticwriter');
const Address = require('../primitives/address');
const TX = require('../primitives/tx');
const Block = require('../primitives/block');
@ -18,7 +18,7 @@ const Input = require('../primitives/input');
const Output = require('../primitives/output');
const consensus = require('../protocol/consensus');
const policy = require('../protocol/policy');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const CoinView = require('../coins/coinview');
const Script = require('../script/script');
const common = require('./common');

4
lib/net/bip150.js
View File

@ -18,9 +18,9 @@ const random = require('bcrypto/lib/random');
const ccmp = require('bcrypto/lib/ccmp');
const packets = require('./packets');
const secp256k1 = require('bcrypto/lib/secp256k1');
const StaticWriter = require('../utils/staticwriter');
const StaticWriter = require('bbuf/lib/staticwriter');
const base58 = require('../utils/base58');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const IP = require('../utils/ip');
const dns = require('./dns');
const Logger = require('../node/logger');

6
lib/net/bip151.js
View File

@ -25,9 +25,9 @@ const AEAD = require('bcrypto/lib/aead');
const hkdf = require('bcrypto/lib/hkdf');
const secp256k1 = require('bcrypto/lib/secp256k1');
const packets = require('./packets');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('../utils/reader');
const encoding = require('../utils/encoding');
const StaticWriter = require('bbuf/lib/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const encoding = require('bbuf/lib/encoding');
const EncinitPacket = packets.EncinitPacket;
const EncackPacket = packets.EncackPacket;

6
lib/net/bip152.js
View File

@ -11,9 +11,9 @@
*/
const assert = require('assert');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const encoding = require('../utils/encoding');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const encoding = require('bbuf/lib/encoding');
const consensus = require('../protocol/consensus');
const digest = require('bcrypto/lib/digest');
const siphash256 = require('bcrypto/lib/siphash').siphash256;

6
lib/net/packets.js
View File

@ -22,9 +22,9 @@ const InvItem = require('../primitives/invitem');
const MemBlock = require('../primitives/memblock');
const MerkleBlock = require('../primitives/merkleblock');
const TX = require('../primitives/tx');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const encoding = require('../utils/encoding');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const encoding = require('bbuf/lib/encoding');
const DUMMY = Buffer.alloc(0);
/**

2
lib/net/peer.js
View File

@ -24,7 +24,7 @@ const BIP150 = require('./bip150');
const BIP152 = require('./bip152');
const Block = require('../primitives/block');
const TX = require('../primitives/tx');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const NetAddress = require('../primitives/netaddress');
const Network = require('../protocol/network');
const Logger = require('../node/logger');

2
lib/net/pool.js
View File

@ -33,7 +33,7 @@ const HostList = require('./hostlist');
const UPNP = require('./upnp');
const InvItem = require('../primitives/invitem');
const packets = require('./packets');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const services = common.services;
const invTypes = InvItem.types;
const packetTypes = packets.types;

2
lib/net/proxysocket.js
View File

@ -10,7 +10,7 @@ const assert = require('assert');
const EventEmitter = require('events');
const bsock = require('bsock');
const digest = require('bcrypto/lib/digest');
const BufferWriter = require('../utils/writer');
const BufferWriter = require('bbuf/lib/writer');
function ProxySocket(uri) {
if (!(this instanceof ProxySocket))

4
lib/net/socks.js
View File

@ -15,8 +15,8 @@ const EventEmitter = require('events');
const net = require('net');
const {format} = require('util');
const IP = require('../utils/ip');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('../utils/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const BufferReader = require('bbuf/lib/reader');
/**
* SOCKS state machine

2
lib/node/http.js
View File

@ -20,7 +20,7 @@ const random = require('bcrypto/lib/random');
const ccmp = require('bcrypto/lib/ccmp');
const Network = require('../protocol/network');
const Validator = require('../utils/validator');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const pkg = require('../pkg');
class HTTP extends Server {

2
lib/node/rpc.js
View File

@ -29,7 +29,7 @@ const Outpoint = require('../primitives/outpoint');
const Output = require('../primitives/output');
const TX = require('../primitives/tx');
const IP = require('../utils/ip');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const consensus = require('../protocol/consensus');
const Validator = require('../utils/validator');
const pkg = require('../pkg');

6
lib/primitives/abstractblock.js
View File

@ -9,10 +9,10 @@
const assert = require('assert');
const digest = require('bcrypto/lib/digest');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const InvItem = require('./invitem');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const consensus = require('../protocol/consensus');
/**

6
lib/primitives/address.js
View File

@ -9,10 +9,10 @@
const assert = require('assert');
const Network = require('../protocol/network');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const digest = require('bcrypto/lib/digest');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const base58 = require('../utils/base58');
const bech32 = require('../utils/bech32');

6
lib/primitives/block.js
View File

@ -9,13 +9,13 @@
const assert = require('assert');
const util = require('../utils/util');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const hash256 = require('bcrypto/lib/hash256');
const merkle = require('bcrypto/lib/merkle');
const consensus = require('../protocol/consensus');
const AbstractBlock = require('./abstractblock');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const TX = require('./tx');
const MerkleBlock = require('./merkleblock');
const Headers = require('./headers');

6
lib/primitives/coin.js
View File

@ -12,9 +12,9 @@ const Amount = require('../btc/amount');
const Output = require('./output');
const Script = require('../script/script');
const Network = require('../protocol/network');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const encoding = require('../utils/encoding');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const encoding = require('bbuf/lib/encoding');
/**
* Represents an unspent output.

6
lib/primitives/headers.js
View File

@ -9,9 +9,9 @@
const util = require('../utils/util');
const AbstractBlock = require('./abstractblock');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('../utils/reader');
const encoding = require('../utils/encoding');
const StaticWriter = require('bbuf/lib/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const encoding = require('bbuf/lib/encoding');
/**
* Represents block headers obtained from the network via `headers`.

4
lib/primitives/input.js
View File

@ -12,8 +12,8 @@ const Network = require('../protocol/network');
const Script = require('../script/script');
const Witness = require('../script/witness');
const Outpoint = require('./outpoint');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('../utils/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const BufferReader = require('bbuf/lib/reader');
/**
* Represents a transaction input.

6
lib/primitives/invitem.js
View File

@ -7,9 +7,9 @@
'use strict';
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const encoding = require('../utils/encoding');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const encoding = require('bbuf/lib/encoding');
/**
* Inv Item

6
lib/primitives/keyring.js
View File

@ -8,11 +8,11 @@
'use strict';
const assert = require('assert');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const digest = require('bcrypto/lib/digest');
const Network = require('../protocol/network');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const base58 = require('../utils/base58');
const Script = require('../script/script');
const Address = require('./address');

2
lib/primitives/memblock.js
View File

@ -11,7 +11,7 @@ const AbstractBlock = require('./abstractblock');
const Block = require('./block');
const Headers = require('./headers');
const Script = require('../script/script');
const BufferReader = require('../utils/reader');
const BufferReader = require('bbuf/lib/reader');
const DUMMY = Buffer.alloc(0);
/**

6
lib/primitives/merkleblock.js
View File

@ -9,9 +9,9 @@
const assert = require('assert');
const util = require('../utils/util');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const encoding = require('../utils/encoding');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const encoding = require('bbuf/lib/encoding');
const hash256 = require('bcrypto/lib/hash256');
const consensus = require('../protocol/consensus');
const AbstractBlock = require('./abstractblock');

2
lib/primitives/mtx.js
View File

@ -16,7 +16,7 @@ const Coin = require('./coin');
const Outpoint = require('./outpoint');
const CoinView = require('../coins/coinview');
const Address = require('./address');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const consensus = require('../protocol/consensus');
const policy = require('../protocol/policy');
const Amount = require('../btc/amount');

4
lib/primitives/netaddress.js
View File

@ -11,8 +11,8 @@ const common = require('../net/common');
const Network = require('../protocol/network');
const util = require('../utils/util');
const IP = require('../utils/ip');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('../utils/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const BufferReader = require('bbuf/lib/reader');
/**
* Represents a network address.

6
lib/primitives/outpoint.js
View File

@ -7,9 +7,9 @@
'use strict';
const assert = require('assert');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('../utils/reader');
const encoding = require('../utils/encoding');
const StaticWriter = require('bbuf/lib/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const encoding = require('bbuf/lib/encoding');
/**
* Represents a COutPoint.

4
lib/primitives/output.js
View File

@ -12,8 +12,8 @@ const Amount = require('../btc/amount');
const Network = require('../protocol/network');
const Address = require('../primitives/address');
const Script = require('../script/script');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('../utils/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const consensus = require('../protocol/consensus');
const policy = require('../protocol/policy');

6
lib/primitives/tx.js
View File

@ -11,12 +11,12 @@ const assert = require('assert');
const digest = require('bcrypto/lib/digest');
const secp256k1 = require('bcrypto/lib/secp256k1');
const util = require('../utils/util');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const Amount = require('../btc/amount');
const Network = require('../protocol/network');
const Script = require('../script/script');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const Input = require('./input');
const Output = require('./output');
const Outpoint = require('./outpoint');

6
lib/primitives/txmeta.js
View File

@ -9,9 +9,9 @@
const assert = require('assert');
const util = require('../utils/util');
const TX = require('./tx');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('../utils/reader');
const encoding = require('../utils/encoding');
const StaticWriter = require('bbuf/lib/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const encoding = require('bbuf/lib/encoding');
/**
* An extended transaction object.

4
lib/script/opcode.js
View File

@ -10,8 +10,8 @@
const assert = require('assert');
const ScriptNum = require('./scriptnum');
const common = require('./common');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const opcodes = common.opcodes;
const opCache = [];

8
lib/script/script.js
View File

@ -13,16 +13,16 @@ const merkle = require('bcrypto/lib/merkle');
const secp256k1 = require('bcrypto/lib/secp256k1');
const consensus = require('../protocol/consensus');
const policy = require('../protocol/policy');
const BufferWriter = require('../utils/writer');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const BufferWriter = require('bbuf/lib/writer');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const Program = require('./program');
const Opcode = require('./opcode');
const Stack = require('./stack');
const ScriptError = require('./scripterror');
const ScriptNum = require('./scriptnum');
const common = require('./common');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const Address = require('../primitives/address');
const opcodes = common.opcodes;
const scriptTypes = common.types;

6
lib/script/witness.js
View File

@ -10,9 +10,9 @@
const assert = require('assert');
const Script = require('./script');
const common = require('./common');
const encoding = require('../utils/encoding');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const encoding = require('bbuf/lib/encoding');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const Address = require('../primitives/address');
const Stack = require('./stack');
const scriptTypes = common.types;

866
lib/utils/encoding.js
View File

@ -1,866 +0,0 @@
/*!
* encoding.js - encoding utils for bcoin
* Copyright (c) 2014-2015, Fedor Indutny (MIT License)
* Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
* https://github.com/bcoin-org/bcoin
*/
'use strict';
/**
* @module utils/encoding
*/
const assert = require('assert');
const {U64, I64} = require('n64');
const UINT128_MAX = U64.UINT64_MAX.shrn(7);
const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
const encoding = exports;
/**
* An empty buffer.
* @const {Buffer}
* @default
*/
encoding.DUMMY = Buffer.from([0]);
/**
* A hash of all zeroes with a `1` at the
* end (used for the SIGHASH_SINGLE bug).
* @const {Buffer}
* @default
*/
encoding.ONE_HASH = Buffer.from(
'0100000000000000000000000000000000000000000000000000000000000000',
'hex'
);
/**
* A hash of all zeroes.
* @const {Buffer}
* @default
*/
encoding.ZERO_HASH = Buffer.from(
'0000000000000000000000000000000000000000000000000000000000000000',
'hex'
);
/**
* A hash of all 0xff.
* @const {Buffer}
* @default
*/
encoding.MAX_HASH = Buffer.from(
'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
'hex'
);
/**
* A hash of all zeroes.
* @const {String}
* @default
*/
encoding.NULL_HASH =
'0000000000000000000000000000000000000000000000000000000000000000';
/**
* A hash of all 0xff.
* @const {String}
* @default
*/
encoding.HIGH_HASH =
'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
/**
* A hash of all zeroes.
* @const {Buffer}
* @default
*/
encoding.ZERO_HASH160 = Buffer.from(
'0000000000000000000000000000000000000000',
'hex'
);
/**
* A hash of all 0xff.
* @const {String}
* @default
*/
encoding.MAX_HASH160 = Buffer.from(
'ffffffffffffffffffffffffffffffffffffffff',
'hex'
);
/**
* A hash of all zeroes.
* @const {String}
* @default
*/
encoding.NULL_HASH160 = '0000000000000000000000000000000000000000';
/**
* A hash of all 0xff.
* @const {String}
* @default
*/
encoding.HIGH_HASH160 = 'ffffffffffffffffffffffffffffffffffffffff';
/**
* A compressed pubkey of all zeroes.
* @const {Buffer}
* @default
*/
encoding.ZERO_KEY = Buffer.from(
'000000000000000000000000000000000000000000000000000000000000000000',
'hex'
);
/**
* A 73 byte signature of all zeroes.
* @const {Buffer}
* @default
*/
encoding.ZERO_SIG = Buffer.from(''
+ '0000000000000000000000000000000000000000000000000000000000000000'
+ '0000000000000000000000000000000000000000000000000000000000000000'
+ '000000000000000000',
'hex'
);
/**
* A 64 byte signature of all zeroes.
* @const {Buffer}
* @default
*/
encoding.ZERO_SIG64 = Buffer.from(''
+ '0000000000000000000000000000000000000000000000000000000000000000'
+ '0000000000000000000000000000000000000000000000000000000000000000',
'hex'
);
/**
* 4 zero bytes.
* @const {Buffer}
* @default
*/
encoding.ZERO_U32 = Buffer.from('00000000', 'hex');
/**
* 8 zero bytes.
* @const {Buffer}
* @default
*/
encoding.ZERO_U64 = Buffer.from('0000000000000000', 'hex');
/**
* Read uint64le as a js number.
* @param {Buffer} data
* @param {Number} off
* @returns {Number}
* @throws on num > MAX_SAFE_INTEGER
*/
encoding.readU64 = function readU64(data, off) {
const hi = data.readUInt32LE(off + 4, true);
const lo = data.readUInt32LE(off, true);
enforce((hi & 0xffe00000) === 0, off, 'Number exceeds 2^53-1');
return hi * 0x100000000 + lo;
};
/**
* Read uint64be as a js number.
* @param {Buffer} data
* @param {Number} off
* @returns {Number}
* @throws on num > MAX_SAFE_INTEGER
*/
encoding.readU64BE = function readU64BE(data, off) {
const hi = data.readUInt32BE(off, true);
const lo = data.readUInt32BE(off + 4, true);
enforce((hi & 0xffe00000) === 0, off, 'Number exceeds 2^53-1');
return hi * 0x100000000 + lo;
};
/**
* Read int64be as a js number.
* @param {Buffer} data
* @param {Number} off
* @returns {Number}
* @throws on num > MAX_SAFE_INTEGER
*/
encoding.readI64 = function readI64(data, off) {
const hi = data.readInt32LE(off + 4, true);
const lo = data.readUInt32LE(off, true);
enforce(isSafe(hi, lo), 'Number exceeds 2^53-1');
return hi * 0x100000000 + lo;
};
/**
* Read int64be as a js number.
* @param {Buffer} data
* @param {Number} off
* @returns {Number}
* @throws on num > MAX_SAFE_INTEGER
*/
encoding.readI64BE = function readI64BE(data, off) {
const hi = data.readInt32BE(off, true);
const lo = data.readUInt32BE(off + 4, true);
enforce(isSafe(hi, lo), 'Number exceeds 2^53-1');
return hi * 0x100000000 + lo;
};
/**
* Write a javascript number as a uint64le.
* @param {Buffer} dst
* @param {Number} num
* @param {Number} off
* @returns {Number} Buffer offset.
* @throws on num > MAX_SAFE_INTEGER
*/
encoding.writeU64 = function writeU64(dst, num, off) {
return write64(dst, num, off, false);
};
/**
* Write a javascript number as a uint64be.
* @param {Buffer} dst
* @param {Number} num
* @param {Number} off
* @returns {Number} Buffer offset.
* @throws on num > MAX_SAFE_INTEGER
*/
encoding.writeU64BE = function writeU64BE(dst, num, off) {
return write64(dst, num, off, true);
};
/**
* Write a javascript number as an int64le.
* @param {Buffer} dst
* @param {Number} num
* @param {Number} off
* @returns {Number} Buffer offset.
* @throws on num > MAX_SAFE_INTEGER
*/
encoding.writeI64 = function writeI64(dst, num, off) {
return write64(dst, num, off, false);
};
/**
* Write a javascript number as an int64be.
* @param {Buffer} dst
* @param {Number} num
* @param {Number} off
* @returns {Number} Buffer offset.
* @throws on num > MAX_SAFE_INTEGER
*/
encoding.writeI64BE = function writeI64BE(dst, num, off) {
return write64(dst, num, off, true);
};
/**
* Read uint64le.
* @param {Buffer} data
* @param {Number} off
* @returns {U64}
*/
encoding.readU64N = function readU64N(data, off) {
return U64.readLE(data, off);
};
/**
* Read uint64be.
* @param {Buffer} data
* @param {Number} off
* @returns {U64}
*/
encoding.readU64BEN = function readU64BEN(data, off) {
return U64.readBE(data, off);
};
/**
* Read int64le.
* @param {Buffer} data
* @param {Number} off
* @returns {I64}
*/
encoding.readI64N = function readI64N(data, off) {
return I64.readLE(data, off);
};
/**
* Read int64be.
* @param {Buffer} data
* @param {Number} off
* @returns {I64}
*/
encoding.readI64BEN = function readI64BEN(data, off) {
return I64.readBE(data, off);
};
/**
* Write uint64le.
* @param {Buffer} dst
* @param {U64} num
* @param {Number} off
* @returns {Number} Buffer offset.
*/
encoding.writeU64N = function writeU64N(dst, num, off) {
enforce(!num.sign, off, 'Signed');
return num.writeLE(dst, off);
};
/**
* Write uint64be.
* @param {Buffer} dst
* @param {U64} num
* @param {Number} off
* @returns {Number} Buffer offset.
*/
encoding.writeU64BEN = function writeU64BEN(dst, num, off) {
enforce(!num.sign, off, 'Signed');
return num.writeBE(dst, off);
};
/**
* Write int64le.
* @param {Buffer} dst
* @param {U64} num
* @param {Number} off
* @returns {Number} Buffer offset.
*/
encoding.writeI64N = function writeI64N(dst, num, off) {
enforce(num.sign, off, 'Not signed');
return num.writeLE(dst, off);
};
/**
* Write int64be.
* @param {Buffer} dst
* @param {I64} num
* @param {Number} off
* @returns {Number} Buffer offset.
*/
encoding.writeI64BEN = function writeI64BEN(dst, num, off) {
enforce(num.sign, off, 'Not signed');
return num.writeBE(dst, off);
};
/**
* Read a varint.
* @param {Buffer} data
* @param {Number} off
* @returns {Object}
*/
encoding.readVarint = function readVarint(data, off) {
let value, size;
check(off < data.length, off);
switch (data[off]) {
case 0xff:
size = 9;
check(off + size <= data.length, off);
value = encoding.readU64(data, off + 1);
enforce(value > 0xffffffff, off, 'Non-canonical varint');
break;
case 0xfe:
size = 5;
check(off + size <= data.length, off);
value = data.readUInt32LE(off + 1, true);
enforce(value > 0xffff, off, 'Non-canonical varint');
break;
case 0xfd:
size = 3;
check(off + size <= data.length, off);
value = data[off + 1] | (data[off + 2] << 8);
enforce(value >= 0xfd, off, 'Non-canonical varint');
break;
default:
size = 1;
value = data[off];
break;
}
return new Varint(size, value);
};
/**
* Write a varint.
* @param {Buffer} dst
* @param {Number} num
* @param {Number} off
* @returns {Number} Buffer offset.
*/
encoding.writeVarint = function writeVarint(dst, num, off) {
if (num < 0xfd) {
dst[off++] = num & 0xff;
return off;
}
if (num <= 0xffff) {
dst[off++] = 0xfd;
dst[off++] = num & 0xff;
dst[off++] = (num >> 8) & 0xff;
return off;
}
if (num <= 0xffffffff) {
dst[off++] = 0xfe;
dst[off++] = num & 0xff;
dst[off++] = (num >> 8) & 0xff;
dst[off++] = (num >> 16) & 0xff;
dst[off++] = num >>> 24;
return off;
}
dst[off++] = 0xff;
off = encoding.writeU64(dst, num, off);
return off;
};
/**
* Calculate size of varint.
* @param {Number} num
* @returns {Number} size
*/
encoding.sizeVarint = function sizeVarint(num) {
if (num < 0xfd)
return 1;
if (num <= 0xffff)
return 3;
if (num <= 0xffffffff)
return 5;
return 9;
};
/**
* Read a varint.
* @param {Buffer} data
* @param {Number} off
* @returns {Object}
*/
encoding.readVarintN = function readVarintN(data, off) {
check(off < data.length, off);
if (data[off] === 0xff) {
const size = 9;
check(off + size <= data.length, off);
const value = encoding.readU64N(data, off + 1);
enforce(value.hi !== 0, off, 'Non-canonical varint');
return new Varint(size, value);
}
const {size, value} = encoding.readVarint(data, off);
return new Varint(size, U64.fromInt(value));
};
/**
* Write a varint.
* @param {Buffer} dst
* @param {U64} num
* @param {Number} off
* @returns {Number} Buffer offset.
*/
encoding.writeVarintN = function writeVarintN(dst, num, off) {
enforce(!num.sign, off, 'Signed');
if (num.hi !== 0) {
dst[off++] = 0xff;
return encoding.writeU64N(dst, num, off);
}
return encoding.writeVarint(dst, num.toInt(), off);
};
/**
* Calculate size of varint.
* @param {U64} num
* @returns {Number} size
*/
encoding.sizeVarintN = function sizeVarintN(num) {
enforce(!num.sign, 0, 'Signed');
if (num.hi !== 0)
return 9;
return encoding.sizeVarint(num.toInt());
};
/**
* Read a varint (type 2).
* @param {Buffer} data
* @param {Number} off
* @returns {Object}
*/
encoding.readVarint2 = function readVarint2(data, off) {
let num = 0;
let size = 0;
for (;;) {
check(off < data.length, off);
const ch = data[off++];
size++;
// Number.MAX_SAFE_INTEGER >>> 7
enforce(num <= 0x3fffffffffff - (ch & 0x7f), off, 'Number exceeds 2^53-1');
// num = (num << 7) | (ch & 0x7f);
num = (num * 0x80) + (ch & 0x7f);
if ((ch & 0x80) === 0)
break;
enforce(num !== MAX_SAFE_INTEGER, off, 'Number exceeds 2^53-1');
num++;
}
return new Varint(size, num);
};
/**
* Write a varint (type 2).
* @param {Buffer} dst
* @param {Number} num
* @param {Number} off
* @returns {Number} Buffer offset.
*/
encoding.writeVarint2 = function writeVarint2(dst, num, off) {
const tmp = [];
let len = 0;
for (;;) {
tmp[len] = (num & 0x7f) | (len ? 0x80 : 0x00);
if (num <= 0x7f)
break;
// num = (num >>> 7) - 1;
num = ((num - (num % 0x80)) / 0x80) - 1;
len++;
}
check(off + len + 1 <= dst.length, off);
do {
dst[off++] = tmp[len];
} while (len--);
return off;
};
/**
* Calculate size of varint (type 2).
* @param {Number} num
* @returns {Number} size
*/
encoding.sizeVarint2 = function sizeVarint2(num) {
let size = 0;
for (;;) {
size++;
if (num <= 0x7f)
break;
// num = (num >>> 7) - 1;
num = ((num - (num % 0x80)) / 0x80) - 1;
}
return size;
};
/**
* Read a varint (type 2).
* @param {Buffer} data
* @param {Number} off
* @returns {Object}
*/
encoding.readVarint2N = function readVarint2N(data, off) {
const num = new U64();
let size = 0;
for (;;) {
check(off < data.length, off);
const ch = data[off++];
size++;
enforce(num.lte(UINT128_MAX), off, 'Number exceeds 2^64-1');
num.ishln(7).iorn(ch & 0x7f);
if ((ch & 0x80) === 0)
break;
enforce(!num.eq(U64.UINT64_MAX), off, 'Number exceeds 2^64-1');
num.iaddn(1);
}
return new Varint(size, num);
};
/**
* Write a varint (type 2).
* @param {Buffer} dst
* @param {U64} num
* @param {Number} off
* @returns {Number} Buffer offset.
*/
encoding.writeVarint2N = function writeVarint2N(dst, num, off) {
enforce(!num.sign, off, 'Signed');
if (num.hi === 0)
return encoding.writeVarint2(dst, num.toInt(), off);
num = num.clone();
const tmp = [];
let len = 0;
for (;;) {
tmp[len] = num.andln(0x7f) | (len ? 0x80 : 0x00);
if (num.lten(0x7f))
break;
num.ishrn(7).isubn(1);
len++;
}
enforce(off + len + 1 <= dst.length, off, 'Out of bounds write');
do {
dst[off++] = tmp[len];
} while (len--);
return off;
};
/**
* Calculate size of varint (type 2).
* @param {U64} num
* @returns {Number} size
*/
encoding.sizeVarint2N = function sizeVarint2N(num) {
enforce(!num.sign, 0, 'Signed');
if (num.hi === 0)
return encoding.sizeVarint2(num.toInt());
num = num.clone();
let size = 0;
for (;;) {
size++;
if (num.lten(0x7f))
break;
num.ishrn(7).isubn(1);
}
return size;
};
/**
* Serialize number as a u8.
* @param {Number} num
* @returns {Buffer}
*/
encoding.u8 = function u8(num) {
const data = Buffer.allocUnsafe(1);
data[0] = num >>> 0;
return data;
};
/**
* Serialize number as a u32le.
* @param {Number} num
* @returns {Buffer}
*/
encoding.u32 = function u32(num) {
const data = Buffer.allocUnsafe(4);
data.writeUInt32LE(num, 0, true);
return data;
};
/**
* Get size of varint-prefixed bytes.
* @param {Buffer} data
* @returns {Number}
*/
encoding.sizeVarBytes = function sizeVarBytes(data) {
return encoding.sizeVarint(data.length) + data.length;
};
/**
* Get size of varint-prefixed length.
* @param {Number} len
* @returns {Number}
*/
encoding.sizeVarlen = function sizeVarlen(len) {
return encoding.sizeVarint(len) + len;
};
/**
* Get size of varint-prefixed string.
* @param {String} str
* @returns {Number}
*/
encoding.sizeVarString = function sizeVarString(str, enc) {
if (typeof str !== 'string')
return encoding.sizeVarBytes(str);
const len = Buffer.byteLength(str, enc);
return encoding.sizeVarint(len) + len;
};
/**
* Reverse a hex-string (used because of
* bitcoind's affinity for uint256le).
* @param {String} str - Hex string.
* @returns {String} Reversed hex string.
*/
encoding.revHex = function revHex(str) {
assert(typeof str === 'string');
assert(str.length > 0);
assert(str.length % 2 === 0);
let out = '';
for (let i = str.length - 2; i >= 0; i -= 2)
out += str[i] + str[i + 1];
return out;
};
/**
* EncodingError
* @constructor
* @param {Number} offset
* @param {String} reason
*/
encoding.EncodingError = function EncodingError(offset, reason, start) {
if (!(this instanceof EncodingError))
return new EncodingError(offset, reason, start);
Error.call(this);
this.type = 'EncodingError';
this.message = `${reason} (offset=${offset}).`;
if (Error.captureStackTrace)
Error.captureStackTrace(this, start || EncodingError);
};
Object.setPrototypeOf(encoding.EncodingError.prototype, Error.prototype);
/*
* Helpers
*/
function isSafe(hi, lo) {
if (hi < 0) {
hi = ~hi;
if (lo === 0)
hi += 1;
}
return (hi & 0xffe00000) === 0;
}
function write64(dst, num, off, be) {
let neg = false;
if (num < 0) {
num = -num;
neg = true;
}
let hi = (num * (1 / 0x100000000)) | 0;
let lo = num | 0;
if (neg) {
if (lo === 0) {
hi = (~hi + 1) | 0;
} else {
hi = ~hi;
lo = ~lo + 1;
}
}
if (be) {
off = dst.writeInt32BE(hi, off, true);
off = dst.writeInt32BE(lo, off, true);
} else {
off = dst.writeInt32LE(lo, off, true);
off = dst.writeInt32LE(hi, off, true);
}
return off;
}
function Varint(size, value) {
this.size = size;
this.value = value;
}
function check(value, offset) {
if (!value)
throw new encoding.EncodingError(offset, 'Out of bounds read', check);
}
function enforce(value, offset, reason) {
if (!value)
throw new encoding.EncodingError(offset, reason, enforce);
}

2
lib/utils/hashwriter.js
View File

@ -7,7 +7,7 @@
'use strict';
const assert = require('assert');
const encoding = require('./encoding');
const encoding = require('bbuf/lib/encoding');
const POOL0 = Buffer.allocUnsafe(0);
const POOL8 = Buffer.allocUnsafe(1);

4
lib/utils/index.js
View File

@ -17,7 +17,6 @@ exports.base58 = require('./base58');
exports.bech32 = require('./bech32');
exports.binary = require('./binary');
exports.co = require('./co');
exports.encoding = require('./encoding');
exports.enforce = require('./enforce');
exports.fixed = require('./fixed');
exports.Heap = require('./heap');
@ -26,8 +25,5 @@ exports.List = require('./list');
exports.Lock = require('./lock');
exports.LRU = require('./lru');
exports.MappedLock = require('./mappedlock');
exports.BufferReader = require('./reader');
exports.StaticWriter = require('./staticwriter');
exports.util = require('./util');
exports.Validator = require('./validator');
exports.BufferWriter = require('./writer');

602
lib/utils/reader.js
View File

@ -1,602 +0,0 @@
/*!
* reader.js - buffer reader for bcoin
* Copyright (c) 2014-2015, Fedor Indutny (MIT License)
* Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
* https://github.com/bcoin-org/bcoin
*/
'use strict';
const assert = require('assert');
const encoding = require('./encoding');
const EMPTY = Buffer.alloc(0);
/**
* An object that allows reading of buffers in a sane manner.
* @alias module:utils.BufferReader
* @constructor
* @param {Buffer} data
* @param {Boolean?} zeroCopy - Do not reallocate buffers when
* slicing. Note that this can lead to memory leaks if not used
* carefully.
*/
function BufferReader(data, zeroCopy) {
if (!(this instanceof BufferReader))
return new BufferReader(data, zeroCopy);
assert(Buffer.isBuffer(data), 'Must pass a Buffer.');
this.data = data;
this.offset = 0;
this.zeroCopy = zeroCopy || false;
this.stack = [];
}
/**
* Assertion.
* @param {Boolean} value
*/
BufferReader.prototype.assert = function assert(value) {
if (!value)
throw new encoding.EncodingError(this.offset, 'Out of bounds read', assert);
};
/**
* Assertion.
* @param {Boolean} value
* @param {String} reason
*/
BufferReader.prototype.enforce = function enforce(value, reason) {
if (!value)
throw new encoding.EncodingError(this.offset, reason, enforce);
};
/**
* Get total size of passed-in Buffer.
* @returns {Buffer}
*/
BufferReader.prototype.getSize = function getSize() {
return this.data.length;
};
/**
* Calculate number of bytes left to read.
* @returns {Number}
*/
BufferReader.prototype.left = function left() {
this.assert(this.offset <= this.data.length);
return this.data.length - this.offset;
};
/**
* Seek to a position to read from by offset.
* @param {Number} off - Offset (positive or negative).
*/
BufferReader.prototype.seek = function seek(off) {
this.assert(this.offset + off >= 0);
this.assert(this.offset + off <= this.data.length);
this.offset += off;
return off;
};
/**
* Mark the current starting position.
*/
BufferReader.prototype.start = function start() {
this.stack.push(this.offset);
return this.offset;
};
/**
* Stop reading. Pop the start position off the stack
* and calculate the size of the data read.
* @returns {Number} Size.
* @throws on empty stack.
*/
BufferReader.prototype.end = function end() {
assert(this.stack.length > 0);
const start = this.stack.pop();
return this.offset - start;
};
/**
* Stop reading. Pop the start position off the stack
* and return the data read.
* @param {Bolean?} zeroCopy - Do a fast buffer
* slice instead of allocating a new buffer (warning:
* may cause memory leaks if not used with care).
* @returns {Buffer} Data read.
* @throws on empty stack.
*/
BufferReader.prototype.endData = function endData(zeroCopy) {
assert(this.stack.length > 0);
const start = this.stack.pop();
const end = this.offset;
const size = end - start;
const data = this.data;
if (size === data.length)
return data;
if (this.zeroCopy || zeroCopy)
return data.slice(start, end);
const ret = Buffer.allocUnsafe(size);
data.copy(ret, 0, start, end);
return ret;
};
/**
* Destroy the reader. Remove references to the data.
*/
BufferReader.prototype.destroy = function destroy() {
this.data = EMPTY;
this.offset = 0;
this.stack.length = 0;
};
/**
* Read uint8.
* @returns {Number}
*/
BufferReader.prototype.readU8 = function readU8() {
this.assert(this.offset + 1 <= this.data.length);
const ret = this.data[this.offset];
this.offset += 1;
return ret;
};
/**
* Read uint16le.
* @returns {Number}
*/
BufferReader.prototype.readU16 = function readU16() {
this.assert(this.offset + 2 <= this.data.length);
const ret = this.data.readUInt16LE(this.offset, true);
this.offset += 2;
return ret;
};
/**
* Read uint16be.
* @returns {Number}
*/
BufferReader.prototype.readU16BE = function readU16BE() {
this.assert(this.offset + 2 <= this.data.length);
const ret = this.data.readUInt16BE(this.offset, true);
this.offset += 2;
return ret;
};
/**
* Read uint32le.
* @returns {Number}
*/
BufferReader.prototype.readU32 = function readU32() {
this.assert(this.offset + 4 <= this.data.length);
const ret = this.data.readUInt32LE(this.offset, true);
this.offset += 4;
return ret;
};
/**
* Read uint32be.
* @returns {Number}
*/
BufferReader.prototype.readU32BE = function readU32BE() {
this.assert(this.offset + 4 <= this.data.length);
const ret = this.data.readUInt32BE(this.offset, true);
this.offset += 4;
return ret;
};
/**
* Read uint64le as a js number.
* @returns {Number}
* @throws on num > MAX_SAFE_INTEGER
*/
BufferReader.prototype.readU64 = function readU64() {
this.assert(this.offset + 8 <= this.data.length);
const ret = encoding.readU64(this.data, this.offset);
this.offset += 8;
return ret;
};
/**
* Read uint64be as a js number.
* @returns {Number}
* @throws on num > MAX_SAFE_INTEGER
*/
BufferReader.prototype.readU64BE = function readU64BE() {
this.assert(this.offset + 8 <= this.data.length);
const ret = encoding.readU64BE(this.data, this.offset);
this.offset += 8;
return ret;
};
/**
* Read int8.
* @returns {Number}
*/
BufferReader.prototype.readI8 = function readI8() {
this.assert(this.offset + 1 <= this.data.length);
const ret = this.data.readInt8(this.offset, true);
this.offset += 1;
return ret;
};
/**
* Read int16le.
* @returns {Number}
*/
BufferReader.prototype.readI16 = function readI16() {
this.assert(this.offset + 2 <= this.data.length);
const ret = this.data.readInt16LE(this.offset, true);
this.offset += 2;
return ret;
};
/**
* Read int16be.
* @returns {Number}
*/
BufferReader.prototype.readI16BE = function readI16BE() {
this.assert(this.offset + 2 <= this.data.length);
const ret = this.data.readInt16BE(this.offset, true);
this.offset += 2;
return ret;
};
/**
* Read int32le.
* @returns {Number}
*/
BufferReader.prototype.readI32 = function readI32() {
this.assert(this.offset + 4 <= this.data.length);
const ret = this.data.readInt32LE(this.offset, true);
this.offset += 4;
return ret;
};
/**
* Read int32be.
* @returns {Number}
*/
BufferReader.prototype.readI32BE = function readI32BE() {
this.assert(this.offset + 4 <= this.data.length);
const ret = this.data.readInt32BE(this.offset, true);
this.offset += 4;
return ret;
};
/**
* Read int64le as a js number.
* @returns {Number}
* @throws on num > MAX_SAFE_INTEGER
*/
BufferReader.prototype.readI64 = function readI64() {
this.assert(this.offset + 8 <= this.data.length);
const ret = encoding.readI64(this.data, this.offset);
this.offset += 8;
return ret;
};
/**
* Read int64be as a js number.
* @returns {Number}
* @throws on num > MAX_SAFE_INTEGER
*/
BufferReader.prototype.readI64BE = function readI64BE() {
this.assert(this.offset + 8 <= this.data.length);
const ret = encoding.readI64BE(this.data, this.offset);
this.offset += 8;
return ret;
};
/**
* Read uint64le.
* @returns {U64}
*/
BufferReader.prototype.readU64N = function readU64N() {
this.assert(this.offset + 8 <= this.data.length);
const ret = encoding.readU64N(this.data, this.offset);
this.offset += 8;
return ret;
};
/**
* Read uint64be.
* @returns {U64}
*/
BufferReader.prototype.readU64BEN = function readU64BEN() {
this.assert(this.offset + 8 <= this.data.length);
const ret = encoding.readU64BEN(this.data, this.offset);
this.offset += 8;
return ret;
};
/**
* Read int64le.
* @returns {I64}
*/
BufferReader.prototype.readI64N = function readI64N() {
this.assert(this.offset + 8 <= this.data.length);
const ret = encoding.readI64N(this.data, this.offset);
this.offset += 8;
return ret;
};
/**
* Read int64be.
* @returns {I64}
*/
BufferReader.prototype.readI64BEN = function readI64BEN() {
this.assert(this.offset + 8 <= this.data.length);
const ret = encoding.readI64BEN(this.data, this.offset);
this.offset += 8;
return ret;
};
/**
* Read float le.
* @returns {Number}
*/
BufferReader.prototype.readFloat = function readFloat() {
this.assert(this.offset + 4 <= this.data.length);
const ret = this.data.readFloatLE(this.offset, true);
this.offset += 4;
return ret;
};
/**
* Read float be.
* @returns {Number}
*/
BufferReader.prototype.readFloatBE = function readFloatBE() {
this.assert(this.offset + 4 <= this.data.length);
const ret = this.data.readFloatBE(this.offset, true);
this.offset += 4;
return ret;
};
/**
* Read double float le.
* @returns {Number}
*/
BufferReader.prototype.readDouble = function readDouble() {
this.assert(this.offset + 8 <= this.data.length);
const ret = this.data.readDoubleLE(this.offset, true);
this.offset += 8;
return ret;
};
/**
* Read double float be.
* @returns {Number}
*/
BufferReader.prototype.readDoubleBE = function readDoubleBE() {
this.assert(this.offset + 8 <= this.data.length);
const ret = this.data.readDoubleBE(this.offset, true);
this.offset += 8;
return ret;
};
/**
* Read a varint.
* @returns {Number}
*/
BufferReader.prototype.readVarint = function readVarint() {
const {size, value} = encoding.readVarint(this.data, this.offset);
this.offset += size;
return value;
};
/**
* Read a varint.
* @returns {U64}
*/
BufferReader.prototype.readVarintN = function readVarintN() {
const {size, value} = encoding.readVarintN(this.data, this.offset);
this.offset += size;
return value;
};
/**
* Read a varint (type 2).
* @returns {Number}
*/
BufferReader.prototype.readVarint2 = function readVarint2() {
const {size, value} = encoding.readVarint2(this.data, this.offset);
this.offset += size;
return value;
};
/**
* Read a varint (type 2).
* @returns {U64}
*/
BufferReader.prototype.readVarint2N = function readVarint2N() {
const {size, value} = encoding.readVarint2N(this.data, this.offset);
this.offset += size;
return value;
};
/**
* Read N bytes (will do a fast slice if zero copy).
* @param {Number} size
* @param {Bolean?} zeroCopy - Do a fast buffer
* slice instead of allocating a new buffer (warning:
* may cause memory leaks if not used with care).
* @returns {Buffer}
*/
BufferReader.prototype.readBytes = function readBytes(size, zeroCopy) {
assert(size >= 0);
this.assert(this.offset + size <= this.data.length);
let ret;
if (this.zeroCopy || zeroCopy) {
ret = this.data.slice(this.offset, this.offset + size);
} else {
ret = Buffer.allocUnsafe(size);
this.data.copy(ret, 0, this.offset, this.offset + size);
}
this.offset += size;
return ret;
};
/**
* Read a varint number of bytes (will do a fast slice if zero copy).
* @param {Bolean?} zeroCopy - Do a fast buffer
* slice instead of allocating a new buffer (warning:
* may cause memory leaks if not used with care).
* @returns {Buffer}
*/
BufferReader.prototype.readVarBytes = function readVarBytes(zeroCopy) {
return this.readBytes(this.readVarint(), zeroCopy);
};
/**
* Read a string.
* @param {String} enc - Any buffer-supported encoding.
* @param {Number} size
* @returns {String}
*/
BufferReader.prototype.readString = function readString(enc, size) {
assert(size >= 0);
this.assert(this.offset + size <= this.data.length);
const ret = this.data.toString(enc, this.offset, this.offset + size);
this.offset += size;
return ret;
};
/**
* Read a 32-byte hash.
* @param {String} enc - `"hex"` or `null`.
* @returns {Hash|Buffer}
*/
BufferReader.prototype.readHash = function readHash(enc) {
if (enc)
return this.readString(enc, 32);
return this.readBytes(32);
};
/**
* Read string of a varint length.
* @param {String} enc - Any buffer-supported encoding.
* @param {Number?} limit - Size limit.
* @returns {String}
*/
BufferReader.prototype.readVarString = function readVarString(enc, limit) {
const size = this.readVarint();
this.enforce(!limit || size <= limit, 'String exceeds limit.');
return this.readString(enc, size);
};
/**
* Read a null-terminated string.
* @param {String} enc - Any buffer-supported encoding.
* @returns {String}
*/
BufferReader.prototype.readNullString = function readNullString(enc) {
this.assert(this.offset + 1 <= this.data.length);
let i = this.offset;
for (; i < this.data.length; i++) {
if (this.data[i] === 0)
break;
}
this.assert(i !== this.data.length);
const ret = this.readString(enc, i - this.offset);
this.offset = i + 1;
return ret;
};
/**
* Create a checksum from the last start position.
* @param {Function} hash
* @returns {Number} Checksum.
*/
BufferReader.prototype.createChecksum = function createChecksum(hash) {
let start = 0;
if (this.stack.length > 0)
start = this.stack[this.stack.length - 1];
const data = this.data.slice(start, this.offset);
return hash(data).readUInt32LE(0, true);
};
/**
* Verify a 4-byte checksum against a calculated checksum.
* @param {Function} hash
* @returns {Number} checksum
* @throws on bad checksum
*/
BufferReader.prototype.verifyChecksum = function verifyChecksum(hash) {
const chk = this.createChecksum(hash);
const checksum = this.readU32();
this.enforce(chk === checksum, 'Checksum mismatch.');
return checksum;
};
/*
* Expose
*/
module.exports = BufferReader;

460
lib/utils/staticwriter.js
View File

@ -1,460 +0,0 @@
/*!
* staticwriter.js - buffer writer for bcoin
* Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
* https://github.com/bcoin-org/bcoin
*/
'use strict';
const assert = require('assert');
const encoding = require('./encoding');
const EMPTY = Buffer.alloc(0);
const POOLSIZE = 100 << 10;
let POOL = null;
/**
* Statically allocated buffer writer.
* @alias module:utils.StaticWriter
* @constructor
* @param {Number} size
*/
function StaticWriter(size) {
if (!(this instanceof StaticWriter))
return new StaticWriter(size);
this.data = size ? Buffer.allocUnsafe(size) : EMPTY;
this.offset = 0;
}
/**
* Allocate writer from preallocated 100kb pool.
* @param {Number} size
* @returns {StaticWriter}
*/
StaticWriter.pool = function pool(size) {
if (size <= POOLSIZE) {
if (!POOL)
POOL = Buffer.allocUnsafeSlow(POOLSIZE);
const bw = new StaticWriter(0);
bw.data = POOL.slice(0, size);
return bw;
}
return new StaticWriter(size);
};
/**
* Allocate and render the final buffer.
* @returns {Buffer} Rendered buffer.
*/
StaticWriter.prototype.render = function render() {
const data = this.data;
assert(this.offset === data.length);
this.destroy();
return data;
};
/**
* Get size of data written so far.
* @returns {Number}
*/
StaticWriter.prototype.getSize = function getSize() {
return this.offset;
};
/**
* Seek to relative offset.
* @param {Number} offset
*/
StaticWriter.prototype.seek = function seek(offset) {
this.offset += offset;
};
/**
* Destroy the buffer writer.
*/
StaticWriter.prototype.destroy = function destroy() {
this.data = EMPTY;
this.offset = 0;
};
/**
* Write uint8.
* @param {Number} value
*/
StaticWriter.prototype.writeU8 = function writeU8(value) {
this.offset = this.data.writeUInt8(value, this.offset, true);
};
/**
* Write uint16le.
* @param {Number} value
*/
StaticWriter.prototype.writeU16 = function writeU16(value) {
this.offset = this.data.writeUInt16LE(value, this.offset, true);
};
/**
* Write uint16be.
* @param {Number} value
*/
StaticWriter.prototype.writeU16BE = function writeU16BE(value) {
this.offset = this.data.writeUInt16BE(value, this.offset, true);
};
/**
* Write uint32le.
* @param {Number} value
*/
StaticWriter.prototype.writeU32 = function writeU32(value) {
this.offset = this.data.writeUInt32LE(value, this.offset, true);
};
/**
* Write uint32be.
* @param {Number} value
*/
StaticWriter.prototype.writeU32BE = function writeU32BE(value) {
this.offset = this.data.writeUInt32BE(value, this.offset, true);
};
/**
* Write uint64le.
* @param {Number} value
*/
StaticWriter.prototype.writeU64 = function writeU64(value) {
this.offset = encoding.writeU64(this.data, value, this.offset);
};
/**
* Write uint64be.
* @param {Number} value
*/
StaticWriter.prototype.writeU64BE = function writeU64BE(value) {
this.offset = encoding.writeU64BE(this.data, value, this.offset);
};
/**
* Write uint64le.
* @param {U64} value
*/
StaticWriter.prototype.writeU64N = function writeU64N(value) {
this.offset = encoding.writeU64N(this.data, value, this.offset);
};
/**
* Write uint64be.
* @param {U64} value
*/
StaticWriter.prototype.writeU64BEN = function writeU64BEN(value) {
this.offset = encoding.writeU64BEN(this.data, value, this.offset);
};
/**
* Write int8.
* @param {Number} value
*/
StaticWriter.prototype.writeI8 = function writeI8(value) {
this.offset = this.data.writeInt8(value, this.offset, true);
};
/**
* Write int16le.
* @param {Number} value
*/
StaticWriter.prototype.writeI16 = function writeI16(value) {
this.offset = this.data.writeInt16LE(value, this.offset, true);
};
/**
* Write int16be.
* @param {Number} value
*/
StaticWriter.prototype.writeI16BE = function writeI16BE(value) {
this.offset = this.data.writeInt16BE(value, this.offset, true);
};
/**
* Write int32le.
* @param {Number} value
*/
StaticWriter.prototype.writeI32 = function writeI32(value) {
this.offset = this.data.writeInt32LE(value, this.offset, true);
};
/**
* Write int32be.
* @param {Number} value
*/
StaticWriter.prototype.writeI32BE = function writeI32BE(value) {
this.offset = this.data.writeInt32BE(value, this.offset, true);
};
/**
* Write int64le.
* @param {Number} value
*/
StaticWriter.prototype.writeI64 = function writeI64(value) {
this.offset = encoding.writeI64(this.data, value, this.offset);
};
/**
* Write int64be.
* @param {Number} value
*/
StaticWriter.prototype.writeI64BE = function writeI64BE(value) {
this.offset = encoding.writeI64BE(this.data, value, this.offset);
};
/**
* Write int64le.
* @param {I64} value
*/
StaticWriter.prototype.writeI64N = function writeI64N(value) {
this.offset = encoding.writeI64N(this.data, value, this.offset);
};
/**
* Write int64be.
* @param {I64} value
*/
StaticWriter.prototype.writeI64BEN = function writeI64BEN(value) {
this.offset = encoding.writeI64BEN(this.data, value, this.offset);
};
/**
* Write float le.
* @param {Number} value
*/
StaticWriter.prototype.writeFloat = function writeFloat(value) {
this.offset = this.data.writeFloatLE(value, this.offset, true);
};
/**
* Write float be.
* @param {Number} value
*/
StaticWriter.prototype.writeFloatBE = function writeFloatBE(value) {
this.offset = this.data.writeFloatBE(value, this.offset, true);
};
/**
* Write double le.
* @param {Number} value
*/
StaticWriter.prototype.writeDouble = function writeDouble(value) {
this.offset = this.data.writeDoubleLE(value, this.offset, true);
};
/**
* Write double be.
* @param {Number} value
*/
StaticWriter.prototype.writeDoubleBE = function writeDoubleBE(value) {
this.offset = this.data.writeDoubleBE(value, this.offset, true);
};
/**
* Write a varint.
* @param {Number} value
*/
StaticWriter.prototype.writeVarint = function writeVarint(value) {
this.offset = encoding.writeVarint(this.data, value, this.offset);
};
/**
* Write a varint.
* @param {U64} value
*/
StaticWriter.prototype.writeVarintN = function writeVarintN(value) {
this.offset = encoding.writeVarintN(this.data, value, this.offset);
};
/**
* Write a varint (type 2).
* @param {Number} value
*/
StaticWriter.prototype.writeVarint2 = function writeVarint2(value) {
this.offset = encoding.writeVarint2(this.data, value, this.offset);
};
/**
* Write a varint (type 2).
* @param {U64} value
*/
StaticWriter.prototype.writeVarint2N = function writeVarint2N(value) {
this.offset = encoding.writeVarint2N(this.data, value, this.offset);
};
/**
* Write bytes.
* @param {Buffer} value
*/
StaticWriter.prototype.writeBytes = function writeBytes(value) {
if (value.length === 0)
return;
value.copy(this.data, this.offset);
this.offset += value.length;
};
/**
* Write bytes with a varint length before them.
* @param {Buffer} value
*/
StaticWriter.prototype.writeVarBytes = function writeVarBytes(value) {
this.writeVarint(value.length);
this.writeBytes(value);
};
/**
* Copy bytes.
* @param {Buffer} value
* @param {Number} start
* @param {Number} end
*/
StaticWriter.prototype.copy = function copy(value, start, end) {
const len = end - start;
if (len === 0)
return;
value.copy(this.data, this.offset, start, end);
this.offset += len;
};
/**
* Write string to buffer.
* @param {String} value
* @param {String?} enc - Any buffer-supported encoding.
*/
StaticWriter.prototype.writeString = function writeString(value, enc) {
if (value.length === 0)
return;
const size = Buffer.byteLength(value, enc);
this.data.write(value, this.offset, enc);
this.offset += size;
};
/**
* Write a 32 byte hash.
* @param {Hash} value
*/
StaticWriter.prototype.writeHash = function writeHash(value) {
if (typeof value !== 'string') {
assert(value.length === 32);
this.writeBytes(value);
return;
}
assert(value.length === 64);
this.data.write(value, this.offset, 'hex');
this.offset += 32;
};
/**
* Write a string with a varint length before it.
* @param {String}
* @param {String?} enc - Any buffer-supported encoding.
*/
StaticWriter.prototype.writeVarString = function writeVarString(value, enc) {
if (value.length === 0) {
this.writeVarint(0);
return;
}
const size = Buffer.byteLength(value, enc);
this.writeVarint(size);
this.data.write(value, this.offset, enc);
this.offset += size;
};
/**
* Write a null-terminated string.
* @param {String|Buffer}
* @param {String?} enc - Any buffer-supported encoding.
*/
StaticWriter.prototype.writeNullString = function writeNullString(value, enc) {
this.writeString(value, enc);
this.writeU8(0);
};
/**
* Calculate and write a checksum for the data written so far.
* @param {Function} hash
*/
StaticWriter.prototype.writeChecksum = function writeChecksum(hash) {
const data = this.data.slice(0, this.offset);
hash(data).copy(this.data, this.offset, 0, 4);
this.offset += 4;
};
/**
* Fill N bytes with value.
* @param {Number} value
* @param {Number} size
*/
StaticWriter.prototype.fill = function fill(value, size) {
assert(size >= 0);
if (size === 0)
return;
this.data.fill(value, this.offset, this.offset + size);
this.offset += size;
};
/*
* Expose
*/
module.exports = StaticWriter;

622
lib/utils/writer.js
View File

@ -1,622 +0,0 @@
/*!
* writer.js - buffer writer for bcoin
* Copyright (c) 2014-2015, Fedor Indutny (MIT License)
* Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
* https://github.com/bcoin-org/bcoin
*/
'use strict';
const assert = require('assert');
const encoding = require('./encoding');
/*
* Constants
*/
const SEEK = 0;
const UI8 = 1;
const UI16 = 2;
const UI16BE = 3;
const UI32 = 4;
const UI32BE = 5;
const UI64 = 6;
const UI64BE = 7;
const UI64N = 8;
const UI64BEN = 9;
const I8 = 10;
const I16 = 11;
const I16BE = 12;
const I32 = 13;
const I32BE = 14;
const I64 = 15;
const I64BE = 16;
const I64N = 17;
const I64BEN = 18;
const FL = 19;
const FLBE = 20;
const DBL = 21;
const DBLBE = 22;
const VARINT = 23;
const VARINTN = 24;
const VARINT2 = 25;
const VARINT2N = 26;
const BYTES = 27;
const STR = 28;
const CHECKSUM = 29;
const FILL = 30;
/**
* An object that allows writing of buffers in a
* sane manner. This buffer writer is extremely
* optimized since it does not actually write
* anything until `render` is called. It makes
* one allocation: at the end, once it knows the
* size of the buffer to be allocated. Because
* of this, it can also act as a size calculator
* which is useful for guaging block size
* without actually serializing any data.
* @alias module:utils.BufferWriter
* @constructor
*/
function BufferWriter() {
if (!(this instanceof BufferWriter))
return new BufferWriter();
this.ops = [];
this.offset = 0;
}
/**
* Allocate and render the final buffer.
* @returns {Buffer} Rendered buffer.
*/
BufferWriter.prototype.render = function render() {
const data = Buffer.allocUnsafe(this.offset);
let off = 0;
for (const op of this.ops) {
switch (op.type) {
case SEEK:
off += op.value;
break;
case UI8:
off = data.writeUInt8(op.value, off, true);
break;
case UI16:
off = data.writeUInt16LE(op.value, off, true);
break;
case UI16BE:
off = data.writeUInt16BE(op.value, off, true);
break;
case UI32:
off = data.writeUInt32LE(op.value, off, true);
break;
case UI32BE:
off = data.writeUInt32BE(op.value, off, true);
break;
case UI64:
off = encoding.writeU64(data, op.value, off);
break;
case UI64BE:
off = encoding.writeU64BE(data, op.value, off);
break;
case UI64N:
off = encoding.writeU64N(data, op.value, off);
break;
case UI64BEN:
off = encoding.writeU64BEN(data, op.value, off);
break;
case I8:
off = data.writeInt8(op.value, off, true);
break;
case I16:
off = data.writeInt16LE(op.value, off, true);
break;
case I16BE:
off = data.writeInt16BE(op.value, off, true);
break;
case I32:
off = data.writeInt32LE(op.value, off, true);
break;
case I32BE:
off = data.writeInt32BE(op.value, off, true);
break;
case I64:
off = encoding.writeI64(data, op.value, off);
break;
case I64BE:
off = encoding.writeI64BE(data, op.value, off);
break;
case I64N:
off = encoding.writeI64N(data, op.value, off);
break;
case I64BEN:
off = encoding.writeI64BEN(data, op.value, off);
break;
case FL:
off = data.writeFloatLE(op.value, off, true);
break;
case FLBE:
off = data.writeFloatBE(op.value, off, true);
break;
case DBL:
off = data.writeDoubleLE(op.value, off, true);
break;
case DBLBE:
off = data.writeDoubleBE(op.value, off, true);
break;
case VARINT:
off = encoding.writeVarint(data, op.value, off);
break;
case VARINTN:
off = encoding.writeVarintN(data, op.value, off);
break;
case VARINT2:
off = encoding.writeVarint2(data, op.value, off);
break;
case VARINT2N:
off = encoding.writeVarint2N(data, op.value, off);
break;
case BYTES:
off += op.value.copy(data, off);
break;
case STR:
off += data.write(op.value, off, op.enc);
break;
case CHECKSUM:
off += op.value(data.slice(0, off)).copy(data, off, 0, 4);
break;
case FILL:
data.fill(op.value, off, off + op.size);
off += op.size;
break;
default:
assert(false, 'Bad type.');
break;
}
}
assert(off === data.length);
this.destroy();
return data;
};
/**
* Get size of data written so far.
* @returns {Number}
*/
BufferWriter.prototype.getSize = function getSize() {
return this.offset;
};
/**
* Seek to relative offset.
* @param {Number} offset
*/
BufferWriter.prototype.seek = function seek(offset) {
this.offset += offset;
this.ops.push(new WriteOp(SEEK, offset));
};
/**
* Destroy the buffer writer. Remove references to `ops`.
*/
BufferWriter.prototype.destroy = function destroy() {
this.ops.length = 0;
this.offset = 0;
};
/**
* Write uint8.
* @param {Number} value
*/
BufferWriter.prototype.writeU8 = function writeU8(value) {
this.offset += 1;
this.ops.push(new WriteOp(UI8, value));
};
/**
* Write uint16le.
* @param {Number} value
*/
BufferWriter.prototype.writeU16 = function writeU16(value) {
this.offset += 2;
this.ops.push(new WriteOp(UI16, value));
};
/**
* Write uint16be.
* @param {Number} value
*/
BufferWriter.prototype.writeU16BE = function writeU16BE(value) {
this.offset += 2;
this.ops.push(new WriteOp(UI16BE, value));
};
/**
* Write uint32le.
* @param {Number} value
*/
BufferWriter.prototype.writeU32 = function writeU32(value) {
this.offset += 4;
this.ops.push(new WriteOp(UI32, value));
};
/**
* Write uint32be.
* @param {Number} value
*/
BufferWriter.prototype.writeU32BE = function writeU32BE(value) {
this.offset += 4;
this.ops.push(new WriteOp(UI32BE, value));
};
/**
* Write uint64le.
* @param {Number} value
*/
BufferWriter.prototype.writeU64 = function writeU64(value) {
this.offset += 8;
this.ops.push(new WriteOp(UI64, value));
};
/**
* Write uint64be.
* @param {Number} value
*/
BufferWriter.prototype.writeU64BE = function writeU64BE(value) {
this.offset += 8;
this.ops.push(new WriteOp(UI64BE, value));
};
/**
* Write uint64le.
* @param {U64} value
*/
BufferWriter.prototype.writeU64N = function writeU64N(value) {
this.offset += 8;
this.ops.push(new WriteOp(UI64N, value));
};
/**
* Write uint64be.
* @param {U64} value
*/
BufferWriter.prototype.writeU64BEN = function writeU64BEN(value) {
this.offset += 8;
this.ops.push(new WriteOp(UI64BEN, value));
};
/**
* Write int8.
* @param {Number} value
*/
BufferWriter.prototype.writeI8 = function writeI8(value) {
this.offset += 1;
this.ops.push(new WriteOp(I8, value));
};
/**
* Write int16le.
* @param {Number} value
*/
BufferWriter.prototype.writeI16 = function writeI16(value) {
this.offset += 2;
this.ops.push(new WriteOp(I16, value));
};
/**
* Write int16be.
* @param {Number} value
*/
BufferWriter.prototype.writeI16BE = function writeI16BE(value) {
this.offset += 2;
this.ops.push(new WriteOp(I16BE, value));
};
/**
* Write int32le.
* @param {Number} value
*/
BufferWriter.prototype.writeI32 = function writeI32(value) {
this.offset += 4;
this.ops.push(new WriteOp(I32, value));
};
/**
* Write int32be.
* @param {Number} value
*/
BufferWriter.prototype.writeI32BE = function writeI32BE(value) {
this.offset += 4;
this.ops.push(new WriteOp(I32BE, value));
};
/**
* Write int64le.
* @param {Number} value
*/
BufferWriter.prototype.writeI64 = function writeI64(value) {
this.offset += 8;
this.ops.push(new WriteOp(I64, value));
};
/**
* Write int64be.
* @param {Number} value
*/
BufferWriter.prototype.writeI64BE = function writeI64BE(value) {
this.offset += 8;
this.ops.push(new WriteOp(I64BE, value));
};
/**
* Write int64le.
* @param {I64} value
*/
BufferWriter.prototype.writeI64N = function writeI64N(value) {
this.offset += 8;
this.ops.push(new WriteOp(I64N, value));
};
/**
* Write int64be.
* @param {I64} value
*/
BufferWriter.prototype.writeI64BEN = function writeI64BEN(value) {
this.offset += 8;
this.ops.push(new WriteOp(I64BEN, value));
};
/**
* Write float le.
* @param {Number} value
*/
BufferWriter.prototype.writeFloat = function writeFloat(value) {
this.offset += 4;
this.ops.push(new WriteOp(FL, value));
};
/**
* Write float be.
* @param {Number} value
*/
BufferWriter.prototype.writeFloatBE = function writeFloatBE(value) {
this.offset += 4;
this.ops.push(new WriteOp(FLBE, value));
};
/**
* Write double le.
* @param {Number} value
*/
BufferWriter.prototype.writeDouble = function writeDouble(value) {
this.offset += 8;
this.ops.push(new WriteOp(DBL, value));
};
/**
* Write double be.
* @param {Number} value
*/
BufferWriter.prototype.writeDoubleBE = function writeDoubleBE(value) {
this.offset += 8;
this.ops.push(new WriteOp(DBLBE, value));
};
/**
* Write a varint.
* @param {Number} value
*/
BufferWriter.prototype.writeVarint = function writeVarint(value) {
this.offset += encoding.sizeVarint(value);
this.ops.push(new WriteOp(VARINT, value));
};
/**
* Write a varint.
* @param {U64} value
*/
BufferWriter.prototype.writeVarintN = function writeVarintN(value) {
this.offset += encoding.sizeVarintN(value);
this.ops.push(new WriteOp(VARINTN, value));
};
/**
* Write a varint (type 2).
* @param {Number} value
*/
BufferWriter.prototype.writeVarint2 = function writeVarint2(value) {
this.offset += encoding.sizeVarint2(value);
this.ops.push(new WriteOp(VARINT2, value));
};
/**
* Write a varint (type 2).
* @param {U64} value
*/
BufferWriter.prototype.writeVarint2N = function writeVarint2N(value) {
this.offset += encoding.sizeVarint2N(value);
this.ops.push(new WriteOp(VARINT2N, value));
};
/**
* Write bytes.
* @param {Buffer} value
*/
BufferWriter.prototype.writeBytes = function writeBytes(value) {
if (value.length === 0)
return;
this.offset += value.length;
this.ops.push(new WriteOp(BYTES, value));
};
/**
* Write bytes with a varint length before them.
* @param {Buffer} value
*/
BufferWriter.prototype.writeVarBytes = function writeVarBytes(value) {
this.offset += encoding.sizeVarint(value.length);
this.ops.push(new WriteOp(VARINT, value.length));
if (value.length === 0)
return;
this.offset += value.length;
this.ops.push(new WriteOp(BYTES, value));
};
/**
* Copy bytes.
* @param {Buffer} value
* @param {Number} start
* @param {Number} end
*/
BufferWriter.prototype.copy = function copy(value, start, end) {
assert(end >= start);
value = value.slice(start, end);
this.writeBytes(value);
};
/**
* Write string to buffer.
* @param {String} value
* @param {String?} enc - Any buffer-supported encoding.
*/
BufferWriter.prototype.writeString = function writeString(value, enc) {
if (value.length === 0)
return;
this.offset += Buffer.byteLength(value, enc);
this.ops.push(new WriteOp(STR, value, enc));
};
/**
* Write a 32 byte hash.
* @param {Hash} value
*/
BufferWriter.prototype.writeHash = function writeHash(value) {
if (typeof value !== 'string') {
assert(value.length === 32);
this.writeBytes(value);
return;
}
assert(value.length === 64);
this.writeString(value, 'hex');
};
/**
* Write a string with a varint length before it.
* @param {String}
* @param {String?} enc - Any buffer-supported encoding.
*/
BufferWriter.prototype.writeVarString = function writeVarString(value, enc) {
if (value.length === 0) {
this.ops.push(new WriteOp(VARINT, 0));
return;
}
const size = Buffer.byteLength(value, enc);
this.offset += encoding.sizeVarint(size);
this.offset += size;
this.ops.push(new WriteOp(VARINT, size));
this.ops.push(new WriteOp(STR, value, enc));
};
/**
* Write a null-terminated string.
* @param {String|Buffer}
* @param {String?} enc - Any buffer-supported encoding.
*/
BufferWriter.prototype.writeNullString = function writeNullString(value, enc) {
this.writeString(value, enc);
this.writeU8(0);
};
/**
* Calculate and write a checksum for the data written so far.
* @param {Function} hash
*/
BufferWriter.prototype.writeChecksum = function writeChecksum(hash) {
this.offset += 4;
this.ops.push(new WriteOp(CHECKSUM, hash));
};
/**
* Fill N bytes with value.
* @param {Number} value
* @param {Number} size
*/
BufferWriter.prototype.fill = function fill(value, size) {
assert(size >= 0);
if (size === 0)
return;
this.offset += size;
this.ops.push(new WriteOp(FILL, value, null, size));
};
/*
* Helpers
*/
function WriteOp(type, value, enc, size) {
this.type = type;
this.value = value;
this.enc = enc;
this.size = size;
}
/*
* Expose
*/
module.exports = BufferWriter;

6
lib/wallet/account.js
View File

@ -8,9 +8,9 @@
const assert = require('assert');
const binary = require('../utils/binary');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const encoding = require('../utils/encoding');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const encoding = require('bbuf/lib/encoding');
const Path = require('./path');
const common = require('./common');
const Script = require('../script/script');

2
lib/wallet/client.js
View File

@ -11,7 +11,7 @@ const assert = require('assert');
const {NodeClient} = require('bclient');
const TX = require('../primitives/tx');
const hash256 = require('bcrypto/lib/hash256');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const parsers = {
'block connect': (entry, txs) => parseBlock(entry, txs),

6
lib/wallet/masterkey.js
View File

@ -16,9 +16,9 @@ const aes = require('bcrypto/lib/aes');
const sha256 = require('bcrypto/lib/sha256');
const pbkdf2 = require('bcrypto/lib/pbkdf2');
const scrypt = require('bcrypto/lib/scrypt');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const encoding = require('../utils/encoding');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const encoding = require('bbuf/lib/encoding');
const HD = require('../hd/hd');
const Mnemonic = HD.Mnemonic;

6
lib/wallet/path.js
View File

@ -7,9 +7,9 @@
'use strict';
const assert = require('assert');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const encoding = require('../utils/encoding');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const encoding = require('bbuf/lib/encoding');
const Address = require('../primitives/address');
/**

6
lib/wallet/records.js
View File

@ -12,9 +12,9 @@
const assert = require('assert');
const util = require('../utils/util');
const encoding = require('../utils/encoding');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const encoding = require('bbuf/lib/encoding');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const TX = require('../primitives/tx');
/**

2
lib/wallet/rpc.js
View File

@ -21,7 +21,7 @@ const MTX = require('../primitives/mtx');
const Outpoint = require('../primitives/outpoint');
const Output = require('../primitives/output');
const TX = require('../primitives/tx');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const pkg = require('../pkg');
const Validator = require('../utils/validator');
const Lock = require('../utils/lock');

6
lib/wallet/txdb.js
View File

@ -9,15 +9,15 @@
const assert = require('assert');
const util = require('../utils/util');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const Amount = require('../btc/amount');
const CoinView = require('../coins/coinview');
const Coin = require('../primitives/coin');
const Outpoint = require('../primitives/outpoint');
const records = require('./records');
const layout = require('./layout').txdb;
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const policy = require('../protocol/policy');
const TXRecord = records.TXRecord;

6
lib/wallet/wallet.js
View File

@ -10,12 +10,12 @@
const assert = require('assert');
const EventEmitter = require('events');
const Network = require('../protocol/network');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const Lock = require('../utils/lock');
const digest = require('bcrypto/lib/digest');
const cleanse = require('bcrypto/lib/cleanse');
const BufferReader = require('../utils/reader');
const StaticWriter = require('../utils/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const base58 = require('../utils/base58');
const TXDB = require('./txdb');
const Path = require('./path');

4
lib/wallet/walletdb.js
View File

@ -13,7 +13,7 @@ const BDB = require('bdb');
const AsyncObject = require('../utils/asyncobject');
const Lock = require('../utils/lock');
const MappedLock = require('../utils/mappedlock');
const encoding = require('../utils/encoding');
const encoding = require('bbuf/lib/encoding');
const ccmp = require('bcrypto/lib/ccmp');
const aes = require('bcrypto/lib/aes');
const Network = require('../protocol/network');
@ -26,7 +26,7 @@ const Logger = require('../node/logger');
const Outpoint = require('../primitives/outpoint');
const layouts = require('./layout');
const records = require('./records');
const StaticWriter = require('../utils/staticwriter');
const StaticWriter = require('bbuf/lib/staticwriter');
const NullClient = require('./nullclient');
const layout = layouts.walletdb;
const ChainState = records.ChainState;

2
lib/workers/framer.js
View File

@ -7,7 +7,7 @@
'use strict';
const StaticWriter = require('../utils/staticwriter');
const StaticWriter = require('bbuf/lib/staticwriter');
/**
* Framer

4
lib/workers/packets.js
View File

@ -11,8 +11,8 @@
*/
const assert = require('assert');
const BufferReader = require('../utils/reader');
const encoding = require('../utils/encoding');
const BufferReader = require('bbuf/lib/reader');
const encoding = require('bbuf/lib/encoding');
const Script = require('../script/script');
const Witness = require('../script/witness');
const Output = require('../primitives/output');

2
migrate/chaindb0to1.js
View File

@ -2,7 +2,7 @@
const bcoin = require('../');
const assert = require('assert');
const BufferWriter = require('../lib/utils/writer');
const BufferWriter = require('bbuf/lib/writer');
let file = process.argv[2];
assert(typeof file === 'string', 'Please pass in a database path.');

6
migrate/chaindb1to2.js
View File

@ -2,11 +2,11 @@
const assert = require('assert');
const BDB = require('bdb');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const networks = require('../lib/protocol/networks');
const co = require('../lib/utils/co');
const BufferWriter = require('../lib/utils/writer');
const BufferReader = require('../lib/utils/reader');
const BufferWriter = require('bbuf/lib/writer');
const BufferReader = require('bbuf/lib/reader');
const OldCoins = require('./coins-old');
const Coins = require('../lib/coins/coins');
const UndoCoins = require('../lib/coins/undocoins');

6
migrate/chaindb2to3.js
View File

@ -17,12 +17,12 @@ if (process.argv.indexOf('-h') !== -1
const assert = require('assert');
const BDB = require('bdb');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const co = require('../lib/utils/co');
const digest = require('bcrypto/lib/digest');
const BN = require('bcrypto/lib/bn');
const StaticWriter = require('../lib/utils/staticwriter');
const BufferReader = require('../lib/utils/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const OldCoins = require('./coins/coins');
const OldUndoCoins = require('./coins/undocoins');
const CoinEntry = require('../lib/coins/coinentry');

6
migrate/coins-old.js
View File

@ -10,11 +10,11 @@
const assert = require('assert');
const util = require('../lib/utils/util');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const Coin = require('../lib/primitives/coin');
const Output = require('../lib/primitives/output');
const BufferReader = require('../lib/utils/reader');
const BufferWriter = require('../lib/utils/writer');
const BufferReader = require('bbuf/lib/reader');
const BufferWriter = require('bbuf/lib/writer');
const {compress, decompress} = require('./compress-old');
/**

4
migrate/ensure-tip-index.js
View File

@ -2,8 +2,8 @@
const assert = require('assert');
const BDB = require('bdb');
const encoding = require('../lib/utils/encoding');
const BufferReader = require('../lib/utils/reader');
const encoding = require('bbuf/lib/encoding');
const BufferReader = require('bbuf/lib/reader');
const digest = require('bcrypto/lib/digest');
const BN = require('bcrypto/lib/bn');
const DUMMY = Buffer.from([0]);

6
migrate/walletdb2to3.js
View File

@ -3,14 +3,14 @@
const assert = require('assert');
const bcoin = require('../');
const walletdb = require('../lib/wallet/walletdb');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const Path = require('../lib/wallet/path');
const MasterKey = require('../lib/wallet/masterkey');
const Account = require('../lib/wallet/account');
const Wallet = require('../lib/wallet/wallet');
const KeyRing = require('../lib/primitives/keyring');
const BufferReader = require('../lib/utils/reader');
const BufferWriter = require('../lib/utils/writer');
const BufferReader = require('bbuf/lib/reader');
const BufferWriter = require('bbuf/lib/writer');
const layout = walletdb.layout;
let file = process.argv[2];
let batch;

4
migrate/walletdb3to4.js
View File

@ -2,9 +2,9 @@
const assert = require('assert');
const bcoin = require('../');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const WalletDB = require('../lib/wallet/walletdb');
const BufferReader = require('../lib/utils/reader');
const BufferReader = require('bbuf/lib/reader');
const TX = require('../lib/primitives/tx');
const Coin = require('../lib/primitives/coin');
let file = process.argv[2];

6
migrate/walletdb5to6.js
View File

@ -2,9 +2,9 @@
const assert = require('assert');
const bcoin = require('../');
const encoding = require('../lib/utils/encoding');
const BufferWriter = require('../lib/utils/writer');
const BufferReader = require('../lib/utils/reader');
const encoding = require('bbuf/lib/encoding');
const BufferWriter = require('bbuf/lib/writer');
const BufferReader = require('bbuf/lib/reader');
let file = process.argv[2];
let batch;

2
scripts/gen.js
View File

@ -1,7 +1,7 @@
'use strict';
const consensus = require('../lib/protocol/consensus');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const TX = require('../lib/primitives/tx');
const Block = require('../lib/primitives/block');
const Script = require('../lib/script/script');

2
test/block-test.js
View File

@ -10,7 +10,7 @@ const Block = require('../lib/primitives/block');
const MerkleBlock = require('../lib/primitives/merkleblock');
const consensus = require('../lib/protocol/consensus');
const Script = require('../lib/script/script');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const bip152 = require('../lib/net/bip152');
const CompactBlock = bip152.CompactBlock;
const TXRequest = bip152.TXRequest;

2
test/chain-test.js
View File

@ -5,7 +5,7 @@
const assert = require('./util/assert');
const consensus = require('../lib/protocol/consensus');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const Coin = require('../lib/primitives/coin');
const Script = require('../lib/script/script');
const Chain = require('../lib/blockchain/chain');

4
test/coins-test.js
View File

@ -9,8 +9,8 @@ const Input = require('../lib/primitives/input');
const Outpoint = require('../lib/primitives/outpoint');
const CoinView = require('../lib/coins/coinview');
const CoinEntry = require('../lib/coins/coinentry');
const StaticWriter = require('../lib/utils/staticwriter');
const BufferReader = require('../lib/utils/reader');
const StaticWriter = require('bbuf/lib/staticwriter');
const BufferReader = require('bbuf/lib/reader');
const common = require('./util/common');
const tx1 = common.readTX('tx1');

2
test/http-test.js
View File

@ -5,7 +5,7 @@
const assert = require('./util/assert');
const consensus = require('../lib/protocol/consensus');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const co = require('../lib/utils/co');
const Address = require('../lib/primitives/address');
const Script = require('../lib/script/script');

4
test/input-test.js
View File

@ -4,10 +4,10 @@
'use strict';
const Input = require('../lib/primitives/input');
const BufferReader = require('../lib/utils/reader');
const BufferReader = require('bbuf/lib/reader');
const assert = require('./util/assert');
const common = require('./util/common');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
// Take input rawbytes from the raw data format
// p2pkh

2
test/mempool-test.js
View File

@ -4,7 +4,7 @@
'use strict';
const assert = require('./util/assert');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const random = require('bcrypto/lib/random');
const MempoolEntry = require('../lib/mempool/mempoolentry');
const Mempool = require('../lib/mempool/mempool');

2
test/script-test.js
View File

@ -9,7 +9,7 @@ const Witness = require('../lib/script/witness');
const Stack = require('../lib/script/stack');
const Opcode = require('../lib/script/opcode');
const TX = require('../lib/primitives/tx');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const {fromFloat} = require('../lib/utils/fixed');
const scripts = require('./data/script-tests.json');

2
test/tx-test.js
View File

@ -5,7 +5,7 @@
const {inspect} = require('util');
const assert = require('./util/assert');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const random = require('bcrypto/lib/random');
const consensus = require('../lib/protocol/consensus');
const TX = require('../lib/primitives/tx');

4
test/util/common.js
View File

@ -10,8 +10,8 @@ const {CompactBlock} = require('../../lib/net/bip152');
const TX = require('../../lib/primitives/tx');
const Output = require('../../lib/primitives/output');
const CoinView = require('../../lib/coins/coinview');
const BufferReader = require('../../lib/utils/reader');
const BufferWriter = require('../../lib/utils/writer');
const BufferReader = require('bbuf/lib/reader');
const BufferWriter = require('bbuf/lib/writer');
const common = exports;

2
test/utils-test.js
View File

@ -6,7 +6,7 @@
const assert = require('./util/assert');
const {U64, I64} = require('n64');
const base58 = require('../lib/utils/base58');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const Amount = require('../lib/btc/amount');
const Validator = require('../lib/utils/validator');
const fixed = require('../lib/utils/fixed');

2
test/wallet-test.js
View File

@ -6,7 +6,7 @@
const assert = require('./util/assert');
const consensus = require('../lib/protocol/consensus');
const util = require('../lib/utils/util');
const encoding = require('../lib/utils/encoding');
const encoding = require('bbuf/lib/encoding');
const digest = require('bcrypto/lib/digest');
const random = require('bcrypto/lib/random');
const WalletDB = require('../lib/wallet/walletdb');