@neo-one/node-core/utils/BinaryReader.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const client_common_1 = require("@neo-one/client-common");
const bn_js_1 = require("bn.js");
const lodash_1 = tslib_1.__importDefault(require("lodash"));
class BinaryReader {
    constructor(buffer, index = 0) {
        this.buffer = buffer;
        this.mutableIndex = index;
    }
    get index() {
        return this.mutableIndex;
    }
    get remaining() {
        return this.buffer.length - this.mutableIndex;
    }
    get remainingBuffer() {
        return this.buffer.slice(this.mutableIndex);
    }
    hasMore() {
        return this.mutableIndex < this.buffer.byteLength;
    }
    clone() {
        return new BinaryReader(this.buffer, this.mutableIndex);
    }
    readBytes(numBytes) {
        this.checkRead(numBytes);
        const result = this.buffer.slice(this.mutableIndex, this.mutableIndex + numBytes);
        this.mutableIndex += numBytes;
        return result;
    }
    readInt8() {
        this.checkRead(1);
        const result = this.buffer.readInt8(this.mutableIndex);
        this.mutableIndex += 1;
        return result;
    }
    readUInt8() {
        this.checkRead(1);
        const result = this.buffer.readUInt8(this.mutableIndex);
        this.mutableIndex += 1;
        return result;
    }
    readBoolean() {
        return this.readBytes(1)[0] !== 0;
    }
    readInt16LE() {
        this.checkRead(2);
        const result = this.buffer.readInt16LE(this.mutableIndex);
        this.mutableIndex += 2;
        return result;
    }
    readUInt16LE() {
        this.checkRead(2);
        const result = this.buffer.readUInt16LE(this.mutableIndex);
        this.mutableIndex += 2;
        return result;
    }
    readUInt16BE() {
        this.checkRead(2);
        const result = this.buffer.readUInt16BE(this.mutableIndex);
        this.mutableIndex += 2;
        return result;
    }
    readInt32LE() {
        this.checkRead(4);
        const result = this.buffer.readInt32LE(this.mutableIndex);
        this.mutableIndex += 4;
        return result;
    }
    readUInt32LE() {
        this.checkRead(4);
        const result = this.buffer.readUInt32LE(this.mutableIndex);
        this.mutableIndex += 4;
        return result;
    }
    readUInt64LE() {
        return new bn_js_1.BN(this.readBytes(8), 'le');
    }
    readInt64LE() {
        const buffer = this.readBytes(8);
        return new bn_js_1.BN(buffer, 'le').fromTwos(buffer.length * 8);
    }
    readUInt160() {
        return client_common_1.common.bufferToUInt160(this.readBytes(client_common_1.common.UINT160_BUFFER_BYTES));
    }
    readUInt256() {
        return client_common_1.common.bufferToUInt256(this.readBytes(client_common_1.common.UINT256_BUFFER_BYTES));
    }
    readFixed8() {
        return this.readInt64LE();
    }
    readFixedString(length) {
        const values = lodash_1.default.takeWhile([...this.readBytes(length)], (value) => value !== 0);
        return Buffer.from(values).toString('utf8');
    }
    readArray(read, max = 0x1000000) {
        const count = this.readVarUIntLE(new bn_js_1.BN(max)).toNumber();
        return lodash_1.default.range(count).map(read);
    }
    readObject(read, max = 0x1000000) {
        const count = this.readVarUIntLE(new bn_js_1.BN(max)).toNumber();
        return lodash_1.default.range(count).reduce((acc) => {
            const { key, value } = read();
            return Object.assign(Object.assign({}, acc), { [key]: value });
        }, {});
    }
    readVarBytesLE(max = 0x1000000) {
        return this.readBytes(this.readVarUIntLE(new bn_js_1.BN(max)).toNumber());
    }
    readVarUIntLE(max = new bn_js_1.BN('18446744073709551615', 10)) {
        const fb = this.readUInt8();
        let value;
        switch (fb) {
            case 0xfd:
                value = new bn_js_1.BN(this.readUInt16LE());
                break;
            case 0xfe:
                value = new bn_js_1.BN(this.readUInt32LE());
                break;
            case 0xff:
                value = this.readUInt64LE();
                break;
            default:
                value = new bn_js_1.BN(fb);
        }
        if (value.gt(max)) {
            throw new client_common_1.InvalidFormatError(`Integer too large: ${value.toString(10)} > ${max.toString(10)}`);
        }
        return value;
    }
    readVarString(max = 0x1000000) {
        return this.readVarBytesLE(max).toString('utf8');
    }
    readECPoint() {
        const firstByte = this.readBytes(1);
        if (firstByte[0] === client_common_1.common.ECPOINT_INFINITY_BYTE) {
            return client_common_1.common.ECPOINT_INFINITY;
        }
        return client_common_1.common.bufferToECPoint(Buffer.concat([firstByte, this.readBytes(client_common_1.common.ECPOINT_BUFFER_BYTES - 1)]));
    }
    checkRead(numBytes) {
        if (this.remaining < numBytes) {
            throw new client_common_1.InvalidFormatError(`Insufficient bytes remaining (${this.remaining}): ${numBytes}`);
        }
    }
}
exports.BinaryReader = BinaryReader;

//# sourceMappingURL=BinaryReader.js.map