@protokol/notarization-transactions/dist/handlers/notarization-handler.js

Transaction Types For Notarization Support

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.NotarizationTransactionHandler = void 0;
const core_kernel_1 = require("@arkecosystem/core-kernel");
const core_transactions_1 = require("@arkecosystem/core-transactions");
const crypto_1 = require("@arkecosystem/crypto");
const notarization_crypto_1 = require("@protokol/notarization-crypto");
const enums_1 = require("../enums");
const errors_1 = require("../errors");
const events_1 = require("../events");
const pluginName = require("../../package.json").name;
class NotarizationTransactionHandler extends core_transactions_1.Handlers.TransactionHandler {
    async isActivated() {
        return crypto_1.Managers.configManager.getMilestone().aip11 === true;
    }
    getConstructor() {
        return notarization_crypto_1.Transactions.NotarizationTransaction;
    }
    dependencies() {
        return [];
    }
    walletAttributes() {
        return [];
    }
    dynamicFee({ addonBytes, satoshiPerByte, transaction, height, }) {
        const feeType = this.configuration.get("feeType");
        if (feeType === enums_1.FeeType.Static) {
            return this.getConstructor().staticFee({ height });
        }
        if (feeType === enums_1.FeeType.None) {
            return crypto_1.Utils.BigNumber.ZERO;
        }
        return super.dynamicFee({ addonBytes, satoshiPerByte, transaction, height });
    }
    async bootstrap() {
        var _a;
        const blocks = {};
        for await (const transaction of this.transactionHistoryService.streamByCriteria(this.getDefaultCriteria())) {
            core_kernel_1.Utils.assert.defined((_a = transaction.asset) === null || _a === void 0 ? void 0 : _a.notarization);
            if (!blocks[transaction.blockId]) {
                blocks[transaction.blockId] = (await this.blockHistoryService.findOneByCriteria({
                    id: transaction.blockId,
                })).timestamp;
            }
            const { hash } = transaction.asset.notarization;
            await this.notarizationCache.put(hash, this.buildNotarization(hash, blocks[transaction.blockId]), -1);
        }
    }
    emitEvents(transaction, emitter) {
        emitter.dispatch(events_1.NotarizationApplicationEvents.Notarization, transaction.data);
    }
    async throwIfCannotBeApplied(transaction, wallet) {
        var _a;
        const feeType = this.configuration.get("feeType");
        if (feeType === enums_1.FeeType.Static) {
            const staticFee = this.getConstructor().staticFee();
            if (!transaction.data.fee.isEqualTo(staticFee)) {
                throw new errors_1.StaticFeeMismatchError(staticFee.toFixed());
            }
        }
        core_kernel_1.Utils.assert.defined((_a = transaction.data.asset) === null || _a === void 0 ? void 0 : _a.notarization);
        return super.throwIfCannotBeApplied(transaction, wallet);
    }
    async apply(transaction) {
        await super.apply(transaction);
        // Line is already checked inside throwIfCannotBeApplied run by super.apply method
        // AppUtils.assert.defined<NotarizationInterfaces.INotarizationAsset>(transaction.data.asset?.notarization);
        const { hash } = transaction.data.asset.notarization;
        await this.notarizationCache.put(hash, this.buildNotarization(hash, transaction.timestamp), -1);
    }
    async revert(transaction) {
        await super.revert(transaction);
        const notarizationAsset = transaction.data.asset.notarization;
        await this.notarizationCache.forget(notarizationAsset.hash);
    }
    async applyToRecipient(transaction) { }
    async revertForRecipient(transaction) { }
    getDefaultCriteria() {
        return {
            typeGroup: this.getConstructor().typeGroup,
            type: this.getConstructor().type,
        };
    }
    buildNotarization(hash, timestamp) {
        return { hash, timestamp };
    }
}
__decorate([
    core_kernel_1.Container.inject(core_kernel_1.Container.Identifiers.TransactionHistoryService),
    __metadata("design:type", Object)
], NotarizationTransactionHandler.prototype, "transactionHistoryService", void 0);
__decorate([
    core_kernel_1.Container.inject(core_kernel_1.Container.Identifiers.BlockHistoryService),
    __metadata("design:type", Object)
], NotarizationTransactionHandler.prototype, "blockHistoryService", void 0);
__decorate([
    core_kernel_1.Container.inject(core_kernel_1.Container.Identifiers.TransactionPoolQuery),
    __metadata("design:type", Object)
], NotarizationTransactionHandler.prototype, "poolQuery", void 0);
__decorate([
    core_kernel_1.Container.inject(core_kernel_1.Container.Identifiers.CacheService),
    core_kernel_1.Container.tagged("cache", pluginName),
    __metadata("design:type", Object)
], NotarizationTransactionHandler.prototype, "notarizationCache", void 0);
__decorate([
    core_kernel_1.Container.inject(core_kernel_1.Container.Identifiers.PluginConfiguration),
    core_kernel_1.Container.tagged("plugin", pluginName),
    __metadata("design:type", core_kernel_1.Providers.PluginConfiguration)
], NotarizationTransactionHandler.prototype, "configuration", void 0);
exports.NotarizationTransactionHandler = NotarizationTransactionHandler;
//# sourceMappingURL=notarization-handler.js.map