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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const client_common_1 = require("@neo-one/client-common");
const utils_1 = require("@neo-one/utils");
const lodash_1 = tslib_1.__importDefault(require("lodash"));
const AssetType_1 = require("../AssetType");
const constants_1 = require("../constants");
const errors_1 = require("../errors");
const ScriptContainer_1 = require("../ScriptContainer");
const utils_2 = require("../utils");
const Witness_1 = require("../Witness");
const attribute_1 = require("./attribute");
const common_1 = require("./common");
const Input_1 = require("./Input");
const Output_1 = require("./Output");
const TransactionType_1 = require("./TransactionType");
const getUtilityValue = ({ outputs, utilityToken, }) => outputs
    .filter((output) => client_common_1.common.uInt256Equal(output.asset, utilityToken.hash))
    .reduce((acc, output) => acc.add(output.value), utils_2.utils.ZERO);
function TransactionBase(Base) {
    class TransactionBaseClass extends Base {
        constructor() {
            super(...arguments);
            this.equals = utils_2.utils.equals(this.constructor, this, (other) => client_common_1.common.uInt256Equal(this.hash, other.hash));
            this.toKeyString = utils_2.utils.toKeyString(TransactionBase, () => this.hashHex);
            this.getSortedScriptHashesForVerifying = utils_2.utils.lazyAsync(async (options) => {
                const hashes = await this.getScriptHashesForVerifying(options);
                return [...hashes].sort();
            });
            this.sizeInternal = utils_2.utils.lazy(() => client_common_1.IOHelper.sizeOfUInt8 +
                client_common_1.IOHelper.sizeOfArray(this.attributes, (attribute) => attribute.size) +
                client_common_1.IOHelper.sizeOfArray(this.inputs, (input) => input.size) +
                client_common_1.IOHelper.sizeOfArray(this.outputs, (output) => output.size) +
                client_common_1.IOHelper.sizeOfArray(this.scripts, (script) => script.size) +
                this.sizeExclusive());
            this.networkFee = utils_2.utils.lazyAsync(async (context) => {
                const { getOutput, utilityToken } = context;
                const outputsForInputs = await Promise.all(this.inputs.map(getOutput));
                const inputValue = getUtilityValue({
                    outputs: outputsForInputs,
                    utilityToken,
                });
                const outputValue = getUtilityValue({
                    outputs: this.outputs,
                    utilityToken,
                });
                const result = inputValue.sub(outputValue).sub(this.getSystemFee(context));
                return result.lt(utils_2.utils.ZERO) ? utils_2.utils.ZERO : result;
            });
            this.getReferencesInternal = utils_2.utils.lazyAsync(async ({ getOutput }) => Promise.all(this.inputs.map(async (input) => getOutput(input))));
            this.getTransactionResultsInternal = utils_2.utils.lazyAsync(async ({ getOutput }) => {
                const inputOutputs = await this.getReferences({ getOutput });
                const mutableResults = {};
                const addOutputs = (outputs, negative) => {
                    outputs.forEach((output) => {
                        const key = client_common_1.common.uInt256ToHex(output.asset);
                        let result = mutableResults[key];
                        if (result === undefined) {
                            mutableResults[key] = result = utils_2.utils.ZERO;
                        }
                        mutableResults[key] = result.add(negative === true ? output.value.neg() : output.value);
                    });
                };
                addOutputs(inputOutputs);
                addOutputs(this.outputs, true);
                return lodash_1.default.pickBy(mutableResults, (value) => value !== undefined && !value.eq(utils_2.utils.ZERO));
            });
            this.baseGetScriptHashesForVerifyingInternal = utils_2.utils.lazyAsync(async ({ getOutput, getAsset }) => {
                const [inputHashes, outputHashes] = await Promise.all([
                    Promise.all(this.inputs.map(async (input) => {
                        const output = await getOutput(input);
                        return client_common_1.common.uInt160ToHex(output.address);
                    })),
                    Promise.all(this.outputs.map(async (output) => {
                        const asset = await getAsset({ hash: output.asset });
                        if (client_common_1.hasFlag(asset.type, AssetType_1.AssetType.DutyFlag)) {
                            return client_common_1.common.uInt160ToHex(output.address);
                        }
                        return undefined;
                    })).then((hashes) => hashes.filter(utils_1.utils.notNull)),
                ]);
                const attributeHashes = this.attributes
                    .map((attribute) => attribute instanceof attribute_1.UInt160Attribute && attribute.usage === attribute_1.AttributeUsage.Script
                    ? client_common_1.common.uInt160ToHex(attribute.value)
                    : undefined)
                    .filter(utils_1.utils.notNull);
                return new Set([...inputHashes, ...outputHashes, ...attributeHashes]);
            });
            this.sizeExclusive = () => 0;
        }
        static deserializeTransactionBaseStartWireBase({ reader, }) {
            const type = client_common_1.assertTransactionType(reader.readUInt8());
            const version = reader.readUInt8();
            return { type, version };
        }
        static deserializeTransactionBaseEndWireBase(options) {
            const { reader } = options;
            const attributes = reader.readArray(() => attribute_1.deserializeAttributeWireBase(options), client_common_1.MAX_TRANSACTION_ATTRIBUTES);
            const inputs = reader.readArray(() => Input_1.Input.deserializeWireBase(options));
            const outputs = reader.readArray(() => Output_1.Output.deserializeWireBase(options), utils_2.utils.USHORT_MAX_NUMBER + 1);
            const scripts = reader.readArray(() => Witness_1.Witness.deserializeWireBase(options));
            return { attributes, inputs, outputs, scripts };
        }
        static deserializeWireBase(_options) {
            throw new Error('Not Implemented');
        }
        static deserializeWire(options) {
            return this.deserializeWireBase({
                context: options.context,
                reader: new utils_2.BinaryReader(options.buffer),
            });
        }
        get size() {
            return this.sizeInternal();
        }
        async serializeTransactionBaseJSON(context) {
            const [networkFee, transactionData] = await Promise.all([
                this.getNetworkFee(context.feeContext),
                context.tryGetTransactionData(this),
            ]);
            return {
                txid: client_common_1.common.uInt256ToString(this.hashHex),
                size: this.size,
                version: this.version,
                attributes: this.attributes.map((attribute) => attribute.serializeJSON(context)),
                vin: this.inputs.map((input) => input.serializeJSON(context)),
                vout: this.outputs.map((output, index) => output.serializeJSON(context, index)),
                scripts: this.scripts.map((script) => script.serializeJSON(context)),
                sys_fee: client_common_1.JSONHelper.writeFixed8(this.getSystemFee(context.feeContext)),
                net_fee: client_common_1.JSONHelper.writeFixed8(networkFee),
                data: transactionData === undefined
                    ? undefined
                    : {
                        blockHash: client_common_1.common.uInt256ToString(transactionData.blockHash),
                        blockIndex: transactionData.startHeight,
                        transactionIndex: transactionData.index,
                        globalIndex: client_common_1.JSONHelper.writeUInt64(transactionData.globalIndex),
                    },
            };
        }
        async serializeJSON(_context) {
            throw new Error('Not Implemented');
        }
        async getNetworkFee(context) {
            return this.networkFee(context);
        }
        getSystemFee({ fees }) {
            const fee = fees[this.type];
            return fee === undefined ? utils_2.utils.ZERO : fee;
        }
        async getReferences(options) {
            return this.getReferencesInternal(options);
        }
        async getTransactionResults(options) {
            return this.getTransactionResultsInternal(options);
        }
        async getScriptHashesForVerifying(options) {
            return this.baseGetScriptHashesForVerifyingInternal(options);
        }
        async verify(options) {
            if (this.size > constants_1.MAX_TRANSACTION_SIZE) {
                throw new errors_1.VerifyError('Transaction too large.');
            }
            const { memPool = [] } = options;
            if (common_1.hasDuplicateInputs(this.inputs)) {
                throw new errors_1.VerifyError('Duplicate inputs');
            }
            if (memPool.some((tx) => !tx.equals(this) && common_1.hasIntersectingInputs(tx.inputs, this.inputs))) {
                throw new errors_1.VerifyError('Input already exists in mempool');
            }
            if (this.attributes.filter((attribute) => attribute.usage === attribute_1.AttributeUsage.ECDH02 || attribute.usage === attribute_1.AttributeUsage.ECDH03).length > 1) {
                throw new errors_1.VerifyError('Too many ECDH attributes.');
            }
            const [results] = await Promise.all([
                this.verifyScripts(options),
                this.verifyDoubleSpend(options),
                this.verifyOutputs(options),
                this.verifyTransactionResults(options),
            ]);
            return results;
        }
        async verifyDoubleSpend({ isSpent }) {
            const isDoubleSpend = await Promise.all(this.inputs.map(isSpent));
            if (isDoubleSpend.some((value) => value)) {
                throw new errors_1.VerifyError('Transaction is a double spend');
            }
        }
        async verifyOutputs({ getAsset, currentHeight }) {
            const outputsGrouped = Object.entries(lodash_1.default.groupBy(this.outputs, (output) => client_common_1.common.uInt256ToHex(output.asset)));
            const hasInvalidOutputs = await Promise.all(outputsGrouped.map(async ([assetHex, outputs]) => {
                const asset = await getAsset({ hash: client_common_1.common.hexToUInt256(assetHex) });
                if (asset.expiration <= currentHeight + 1 &&
                    asset.type !== AssetType_1.AssetType.GoverningToken &&
                    asset.type !== AssetType_1.AssetType.UtilityToken) {
                    return true;
                }
                return outputs.some((output) => !output.value.mod(utils_2.utils.TEN.pow(utils_2.utils.EIGHT.subn(asset.precision))).eq(utils_2.utils.ZERO));
            }));
            if (hasInvalidOutputs.some((value) => value)) {
                throw new errors_1.VerifyError('Transaction has invalid output');
            }
        }
        async verifyTransactionResults({ getOutput, utilityToken, governingToken, fees, registerValidatorFee, }) {
            const results = await this.getTransactionResults({ getOutput });
            const resultsDestroy = Object.entries(results).filter(([_key, value]) => value.gt(utils_2.utils.ZERO));
            if (resultsDestroy.length > 1 ||
                (resultsDestroy.length === 1 &&
                    !client_common_1.common.uInt256Equal(client_common_1.common.hexToUInt256(resultsDestroy[0][0]), utilityToken.hash))) {
                throw new errors_1.VerifyError('Invalid destroyed output.');
            }
            const feeContext = {
                getOutput,
                governingToken,
                utilityToken,
                fees,
                registerValidatorFee,
            };
            const systemFee = this.getSystemFee(feeContext);
            if (systemFee.gt(utils_2.utils.ZERO) && (resultsDestroy.length === 0 || resultsDestroy[0][1].lt(systemFee))) {
                throw new errors_1.VerifyError('Not enough output value for system fee.');
            }
            const resultsIssue = Object.entries(results).filter(([__, value]) => value.lt(utils_2.utils.ZERO));
            switch (this.type) {
                case TransactionType_1.TransactionType.Miner:
                case TransactionType_1.TransactionType.Claim:
                    if (resultsIssue.some(([assetHex]) => !client_common_1.common.uInt256Equal(client_common_1.common.hexToUInt256(assetHex), utilityToken.hash))) {
                        throw new errors_1.VerifyError('Invalid miner/claim result');
                    }
                    break;
                case TransactionType_1.TransactionType.Issue:
                    if (resultsIssue.some(([assetHex, __]) => client_common_1.common.uInt256Equal(client_common_1.common.hexToUInt256(assetHex), utilityToken.hash))) {
                        throw new errors_1.VerifyError('Invalid issue result');
                    }
                    break;
                default:
                    if (resultsIssue.length > 0) {
                        throw new errors_1.VerifyError('Invalid results.');
                    }
            }
        }
        async verifyScripts({ getAsset, getOutput, verifyScript, }) {
            const hashesArr = await this.getSortedScriptHashesForVerifying({
                getAsset,
                getOutput,
            });
            if (hashesArr.length !== this.scripts.length) {
                throw new errors_1.VerifyError(`Invalid witnesses. Found ${hashesArr.length} hashes and ${this.scripts.length} scripts.`);
            }
            const hashes = hashesArr.map((value) => client_common_1.common.hexToUInt160(value));
            return Promise.all(lodash_1.default.zip(hashes, this.scripts).map(async ([hash, witness]) => verifyScript({
                scriptContainer: {
                    type: ScriptContainer_1.ScriptContainerType.Transaction,
                    value: this,
                },
                hash: hash,
                witness: witness,
            })));
        }
    }
    TransactionBaseClass.WitnessConstructor = Witness_1.Witness;
    return TransactionBaseClass;
}
exports.TransactionBase = TransactionBase;

//# sourceMappingURL=TransactionBase.js.map