@neo-one/node-core/transaction/StateTransaction.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const client_common_1 = require("@neo-one/client-common");
const utils_1 = require("../utils");
const state_1 = require("./state");
const TransactionBase_1 = require("./TransactionBase");
const TransactionType_1 = require("./TransactionType");
class StateTransaction extends TransactionBase_1.TransactionBase(client_common_1.TransactionBaseModel) {
    constructor({ version, attributes, inputs, outputs, scripts, hash, descriptors }) {
        super({
            version,
            type: TransactionType_1.TransactionType.State,
            attributes,
            inputs,
            outputs,
            scripts,
            hash,
        });
        this.sizeExclusive = utils_1.utils.lazy(() => client_common_1.IOHelper.sizeOfArray(this.descriptors, (descriptor) => descriptor.size));
        this.descriptors = descriptors;
        if (this.version !== 0) {
            throw new client_common_1.InvalidFormatError(`Expected version to be 0. Received: ${this.version}`);
        }
        const getScriptHashesForVerifying = super.getScriptHashesForVerifying.bind(this);
        this.stateGetScriptHashesForVerifyingInternal = utils_1.utils.lazyAsync(async (options) => {
            const mutableHashes = await getScriptHashesForVerifying(options);
            this.descriptors.forEach((descriptor) => {
                descriptor.getScriptHashesForVerifying().forEach((scriptHash) => {
                    mutableHashes.add(scriptHash);
                });
            });
            return mutableHashes;
        });
    }
    static deserializeWireBase(options) {
        const { reader } = options;
        const { type, version } = super.deserializeTransactionBaseStartWireBase(options);
        if (type !== TransactionType_1.TransactionType.State) {
            throw new client_common_1.InvalidFormatError(`Expected transaction type ${TransactionType_1.TransactionType.State}. Received: ${type}`);
        }
        const descriptors = reader.readArray(() => state_1.StateDescriptor.deserializeWireBase(options));
        const { attributes, inputs, outputs, scripts } = super.deserializeTransactionBaseEndWireBase(options);
        return new this({
            version,
            attributes,
            inputs,
            outputs,
            scripts,
            descriptors,
        });
    }
    getSystemFee(context) {
        return this.descriptors.reduce((value, descriptor) => value.add(descriptor.getSystemFee(context)), utils_1.utils.ZERO);
    }
    async getScriptHashesForVerifying(options) {
        return this.stateGetScriptHashesForVerifyingInternal(options);
    }
    clone({ scripts = this.scripts, attributes = this.attributes, inputs = this.inputs, outputs = this.outputs, }) {
        return new this.constructor({
            version: this.version,
            attributes,
            inputs,
            outputs,
            scripts,
            descriptors: this.descriptors,
        });
    }
    serializeExclusiveBase(writer) {
        writer.writeArray(this.descriptors, (descriptor) => {
            descriptor.serializeWireBase(writer);
        });
    }
    async serializeJSON(context) {
        const transactionBaseJSON = await super.serializeTransactionBaseJSON(context);
        return Object.assign(Object.assign({}, transactionBaseJSON), { type: 'StateTransaction', descriptors: this.descriptors.map((descriptor) => descriptor.serializeJSON(context)) });
    }
    async verify(options) {
        const [results] = await Promise.all([super.verify(options), this.verifyInternal(options)]);
        return results;
    }
    async verifyInternal(options) {
        await Promise.all(this.descriptors.map(async (descriptor) => descriptor.verify(options)));
    }
}
exports.StateTransaction = StateTransaction;

//# sourceMappingURL=StateTransaction.js.map