@trezor/utxo-lib/lib/transaction/decred.js

Client-side Bitcoin-like JavaScript library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.fromConstructor = fromConstructor;
exports.fromBuffer = fromBuffer;
const tslib_1 = require("tslib");
const varuint = tslib_1.__importStar(require("varuint-bitcoin"));
const bufferutils_1 = require("../bufferutils");
const bcrypto = tslib_1.__importStar(require("../crypto"));
const base_1 = require("./base");
const DECRED_TX_VERSION = 1;
const DECRED_TX_SERIALIZE_FULL = 0;
const DECRED_TX_SERIALIZE_NO_WITNESS = 1;
const DECRED_SCRIPT_VERSION = 0;
function hasWitnesses(tx) {
    return tx.type === DECRED_TX_SERIALIZE_FULL;
}
function byteLength(tx, _ALLOW_WITNESS = true) {
    let byteLength = 4 + varuint.encodingLength(tx.ins.length);
    let nWitness = 0;
    const hasWitnesses = _ALLOW_WITNESS && tx.hasWitnesses();
    byteLength += tx.ins.reduce((sum, input) => {
        sum += 32 + 4 + 1 + 4;
        if (hasWitnesses) {
            nWitness += 1;
            sum += 8 + 4 + 4;
            sum += (0, base_1.varSliceSize)(input.decredWitness.script);
        }
        return sum;
    }, 0);
    if (hasWitnesses) {
        byteLength += varuint.encodingLength(nWitness);
    }
    byteLength += varuint.encodingLength(tx.outs.length);
    byteLength += tx.outs.reduce((sum, output) => {
        sum += 8 + 2;
        sum += (0, base_1.varSliceSize)(output.script);
        return sum;
    }, 0);
    byteLength += 4 + 4;
    return byteLength;
}
function toBuffer(tx, buffer, initialOffset, _ALLOW_WITNESS = true) {
    if (!buffer)
        buffer = Buffer.allocUnsafe(byteLength(tx, _ALLOW_WITNESS));
    const bufferWriter = new bufferutils_1.BufferWriter(buffer, initialOffset || 0);
    bufferWriter.writeUInt16(tx.version);
    bufferWriter.writeUInt16(_ALLOW_WITNESS ? tx.type : DECRED_TX_SERIALIZE_NO_WITNESS);
    bufferWriter.writeVarInt(tx.ins.length);
    tx.ins.forEach(txIn => {
        bufferWriter.writeSlice(txIn.hash);
        bufferWriter.writeUInt32(txIn.index);
        bufferWriter.writeUInt8(txIn.decredTree);
        bufferWriter.writeUInt32(txIn.sequence);
    });
    bufferWriter.writeVarInt(tx.outs.length);
    tx.outs.forEach(txOut => {
        bufferWriter.writeUInt64(txOut.value);
        bufferWriter.writeUInt16(txOut.decredVersion);
        bufferWriter.writeVarSlice(txOut.script);
    });
    bufferWriter.writeUInt32(tx.locktime);
    bufferWriter.writeUInt32(tx.expiry);
    if (_ALLOW_WITNESS && tx.hasWitnesses()) {
        bufferWriter.writeVarInt(tx.ins.length);
        tx.ins.forEach(input => {
            bufferWriter.writeUInt64(input.decredWitness.value);
            bufferWriter.writeUInt32(input.decredWitness.height);
            bufferWriter.writeUInt32(input.decredWitness.blockIndex);
            bufferWriter.writeVarSlice(input.decredWitness.script);
        });
    }
    if (initialOffset !== undefined)
        return buffer.subarray(initialOffset, bufferWriter.offset);
    return buffer;
}
function getHash(tx, forWitness = false) {
    if (forWitness && tx.isCoinbase())
        return Buffer.alloc(32, 0);
    return bcrypto.blake256(toBuffer(tx, undefined, undefined, forWitness));
}
function weight(tx) {
    return tx.byteLength(true);
}
function fromConstructor(options) {
    const tx = new base_1.TransactionBase(options);
    tx.byteLength = byteLength.bind(null, tx);
    tx.toBuffer = toBuffer.bind(null, tx);
    tx.hasWitnesses = hasWitnesses.bind(null, tx);
    tx.getHash = getHash.bind(null, tx);
    tx.weight = weight.bind(null, tx);
    return tx;
}
function fromBuffer(buffer, options) {
    const bufferReader = new bufferutils_1.BufferReader(buffer);
    const tx = fromConstructor(options);
    tx.version = bufferReader.readInt32();
    tx.type = tx.version >> 16;
    tx.version &= 0xffff;
    if (tx.version !== DECRED_TX_VERSION) {
        throw new Error('Unsupported Decred transaction version');
    }
    if (tx.type !== DECRED_TX_SERIALIZE_FULL && tx.type !== DECRED_TX_SERIALIZE_NO_WITNESS) {
        throw new Error('Unsupported Decred transaction type');
    }
    const vinLen = bufferReader.readVarInt();
    for (let i = 0; i < vinLen; ++i) {
        tx.ins.push({
            hash: bufferReader.readSlice(32),
            index: bufferReader.readUInt32(),
            decredTree: bufferReader.readUInt8(),
            sequence: bufferReader.readUInt32(),
            script: base_1.EMPTY_SCRIPT,
            witness: [],
        });
    }
    const voutLen = bufferReader.readVarInt();
    for (let i = 0; i < voutLen; i++) {
        const value = bufferReader.readUInt64String();
        const version = bufferReader.readUInt16();
        if (version !== DECRED_SCRIPT_VERSION)
            throw new Error('Unsupported Decred script version');
        tx.outs.push({
            value,
            decredVersion: version,
            script: bufferReader.readVarSlice(),
        });
    }
    tx.locktime = bufferReader.readUInt32();
    tx.expiry = bufferReader.readUInt32();
    if (tx.type === DECRED_TX_SERIALIZE_FULL) {
        const count = bufferReader.readVarInt();
        if (count !== vinLen)
            throw new Error('Non equal number of ins and witnesses');
        tx.ins.forEach(vin => {
            vin.decredWitness = {
                value: bufferReader.readUInt64String(),
                height: bufferReader.readUInt32(),
                blockIndex: bufferReader.readUInt32(),
                script: bufferReader.readVarSlice(),
            };
        });
    }
    if (options.nostrict)
        return tx;
    if (bufferReader.offset !== buffer.length)
        throw new Error('Transaction has unexpected data');
    return tx;
}
//# sourceMappingURL=decred.js.map