@neo-one/node-core-esnext-esm/src/Block.js

import { common, crypto, InvalidFormatError, IOHelper, } from '@neo-one/client-common-esnext-esm';
import { BlockBase } from './BlockBase';
import { MerkleTree } from './crypto';
import { VerifyError } from './errors';
import { Header } from './Header';
import { ScriptContainerType } from './ScriptContainer';
import { deserializeTransactionWireBase, TransactionType, } from './transaction';
import { BinaryReader, utils } from './utils';
export class Block extends BlockBase {
    constructor({ version, previousHash, timestamp, index, consensusData, nextConsensus, script, hash, transactions, merkleRoot = MerkleTree.computeRoot(transactions.map((transaction) => transaction.hash)), }) {
        super({
            version,
            previousHash,
            merkleRoot,
            timestamp,
            index,
            consensusData,
            nextConsensus,
            script,
            hash,
        });
        this.sizeExclusive = utils.lazy(() => IOHelper.sizeOfArray(this.transactions, (transaction) => transaction.size));
        this.headerInternal = utils.lazy(() => new Header({
            version: this.version,
            previousHash: this.previousHash,
            merkleRoot: this.merkleRoot,
            timestamp: this.timestamp,
            index: this.index,
            consensusData: this.consensusData,
            nextConsensus: this.nextConsensus,
            script: this.script,
        }));
        this.transactions = transactions;
    }
    static async calculateNetworkFee(context, transactions) {
        const fees = await Promise.all(transactions.map(async (transaction) => transaction.getNetworkFee(context)));
        return fees.reduce((acc, fee) => acc.add(fee), utils.ZERO);
    }
    static deserializeWireBase(options) {
        const { reader } = options;
        const blockBase = super.deserializeBlockBaseWireBase(options);
        const transactions = reader.readArray(() => deserializeTransactionWireBase(options), 0x10000);
        if (transactions.length === 0) {
            throw new InvalidFormatError('Expected at least one transcaction in the block');
        }
        const merkleRoot = MerkleTree.computeRoot(transactions.map((transaction) => transaction.hash));
        if (!common.uInt256Equal(merkleRoot, blockBase.merkleRoot)) {
            throw new InvalidFormatError('Invalid merkle root');
        }
        return new this({
            version: blockBase.version,
            previousHash: blockBase.previousHash,
            merkleRoot: blockBase.merkleRoot,
            timestamp: blockBase.timestamp,
            index: blockBase.index,
            consensusData: blockBase.consensusData,
            nextConsensus: blockBase.nextConsensus,
            script: blockBase.script,
            transactions,
        });
    }
    static deserializeWire(options) {
        return this.deserializeWireBase({
            context: options.context,
            reader: new BinaryReader(options.buffer),
        });
    }
    get header() {
        return this.headerInternal();
    }
    clone({ transactions, script, }) {
        return new Block({
            version: this.version,
            previousHash: this.previousHash,
            merkleRoot: this.merkleRoot,
            timestamp: this.timestamp,
            index: this.index,
            consensusData: this.consensusData,
            nextConsensus: this.nextConsensus,
            transactions,
            script,
        });
    }
    async getNetworkFee(context) {
        return Block.calculateNetworkFee(context, this.transactions);
    }
    getSystemFee(context) {
        return this.transactions.reduce((acc, transaction) => acc.add(transaction.getSystemFee(context)), utils.ZERO);
    }
    async verify(options) {
        const { completely = false } = options;
        if (this.transactions.length === 0 ||
            this.transactions[0].type !== TransactionType.Miner ||
            this.transactions.slice(1).some((transaction) => transaction.type === TransactionType.Miner)) {
            throw new VerifyError('Invalid miner transaction in block.');
        }
        await Promise.all([this.verifyBase(options), completely ? this.verifyComplete(options) : Promise.resolve()]);
    }
    serializeWireBase(writer) {
        super.serializeWireBase(writer);
        writer.writeArray(this.transactions, (transaction) => transaction.serializeWireBase(writer));
    }
    async serializeJSON(context) {
        const blockBaseJSON = super.serializeBlockBaseJSON(context);
        return {
            version: blockBaseJSON.version,
            hash: blockBaseJSON.hash,
            previousblockhash: blockBaseJSON.previousblockhash,
            merkleroot: blockBaseJSON.merkleroot,
            time: blockBaseJSON.time,
            index: blockBaseJSON.index,
            nonce: blockBaseJSON.nonce,
            nextconsensus: blockBaseJSON.nextconsensus,
            script: blockBaseJSON.script,
            tx: await Promise.all(this.transactions.map((transaction) => transaction.serializeJSON(context))),
            size: blockBaseJSON.size,
            confirmations: blockBaseJSON.confirmations,
        };
    }
    async verifyBase({ genesisBlock, tryGetBlock, tryGetHeader, verifyScript, }) {
        if (common.uInt256Equal(this.hash, genesisBlock.hash)) {
            return;
        }
        const existingBlock = await tryGetBlock({ hashOrIndex: this.hash });
        if (existingBlock !== undefined) {
            return;
        }
        const previousHeader = await tryGetHeader({
            hashOrIndex: this.previousHash,
        });
        if (previousHeader === undefined) {
            throw new VerifyError('Previous header does not exist.');
        }
        if (previousHeader.index + 1 !== this.index) {
            throw new VerifyError('Previous index + 1 does not match index.');
        }
        if (previousHeader.timestamp >= this.timestamp) {
            throw new VerifyError('Previous timestamp is greater than block.');
        }
        const { failureMessage } = await verifyScript({
            scriptContainer: { type: ScriptContainerType.Block, value: this },
            hash: previousHeader.nextConsensus,
            witness: this.script,
        });
        if (failureMessage !== undefined) {
            throw new VerifyError(failureMessage);
        }
    }
    async verifyComplete(options) {
        await Promise.all([
            this.verifyConsensus(options),
            this.verifyTransactions(options),
            this.verifyNetworkFee(options),
        ]);
    }
    async verifyConsensus({ getValidators }) {
        const validators = await getValidators(this.transactions);
        if (!common.uInt160Equal(this.nextConsensus, crypto.getConsensusAddress(validators))) {
            throw new VerifyError('Invalid next consensus address');
        }
    }
    async verifyTransactions(options) {
        const results = await Promise.all(this.transactions.map(async (transaction) => transaction.verify({
            isSpent: options.isSpent,
            getAsset: options.getAsset,
            getOutput: options.getOutput,
            tryGetAccount: options.tryGetAccount,
            calculateClaimAmount: options.calculateClaimAmount,
            standbyValidators: options.standbyValidators,
            getAllValidators: options.getAllValidators,
            verifyScript: options.verifyScript,
            currentHeight: options.currentHeight,
            governingToken: options.governingToken,
            utilityToken: options.utilityToken,
            fees: options.fees,
            registerValidatorFee: options.registerValidatorFee,
        })));
        const failureResults = results.filter((verifyResults) => verifyResults.some(({ failureMessage }) => failureMessage !== undefined));
        if (failureResults.length > 0) {
            const failureResult = failureResults[0].find(({ failureMessage }) => failureMessage !== undefined);
            if (failureResult !== undefined && failureResult.failureMessage !== undefined) {
                throw new VerifyError(failureResult.failureMessage);
            }
        }
    }
    async verifyNetworkFee(options) {
        const networkFee = await this.getNetworkFee({
            getOutput: options.getOutput,
            governingToken: options.governingToken,
            utilityToken: options.utilityToken,
            fees: options.fees,
            registerValidatorFee: options.registerValidatorFee,
        });
        const minerTransaction = this.transactions.find((transaction) => transaction.type === TransactionType.Miner);
        if (minerTransaction === undefined) {
            throw new VerifyError('Missing miner transaction');
        }
        const minerTransactionNetworkFee = minerTransaction.outputs.reduce((acc, output) => acc.add(output.value), utils.ZERO);
        if (!networkFee.eq(minerTransactionNetworkFee)) {
            throw new VerifyError('Miner output does not equal network fee.');
        }
    }
}

//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["Block.ts"],"names":[],"mappings":"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","file":"neo-one-node-core/src/Block.js","sourcesContent":["import {\n  BinaryWriter,\n  BlockJSON,\n  common,\n  crypto,\n  ECPoint,\n  InvalidFormatError,\n  IOHelper,\n  TransactionJSON,\n  UInt160,\n  UInt256,\n} from '@neo-one/client-common-esnext-esm';\nimport BN from 'bn.js';\nimport { Account, AccountKey } from './Account';\nimport { Asset, AssetKey } from './Asset';\nimport { BlockBase } from './BlockBase';\nimport { MerkleTree } from './crypto';\nimport { VerifyError } from './errors';\nimport { Header, HeaderKey } from './Header';\nimport { ScriptContainerType } from './ScriptContainer';\nimport {\n  DeserializeWireBaseOptions,\n  DeserializeWireOptions,\n  SerializableJSON,\n  SerializableWire,\n  SerializeJSONContext,\n} from './Serializable';\nimport {\n  deserializeTransactionWireBase,\n  FeeContext,\n  Input,\n  Output,\n  OutputKey,\n  RegisterTransaction,\n  Transaction,\n  TransactionType,\n} from './transaction';\nimport { BinaryReader, utils } from './utils';\nimport { Validator } from './Validator';\nimport { VerifyScript } from './vm';\nimport { Witness } from './Witness';\n\nexport interface BlockAdd {\n  readonly version?: number;\n  readonly previousHash: UInt256;\n  readonly merkleRoot?: UInt256;\n  readonly timestamp: number;\n  readonly index: number;\n  readonly consensusData: BN;\n  readonly nextConsensus: UInt160;\n  readonly script?: Witness;\n  readonly hash?: UInt256;\n  readonly transactions: ReadonlyArray<Transaction>;\n}\n\nexport interface BlockKey {\n  readonly hashOrIndex: UInt256 | number;\n}\n\nexport interface BlockVerifyOptions {\n  readonly genesisBlock: Block;\n  readonly tryGetBlock: (block: BlockKey) => Promise<Block | undefined>;\n  readonly tryGetHeader: (header: HeaderKey) => Promise<Header | undefined>;\n  readonly isSpent: (key: OutputKey) => Promise<boolean>;\n  readonly getAsset: (key: AssetKey) => Promise<Asset>;\n  readonly getOutput: (key: OutputKey) => Promise<Output>;\n  readonly tryGetAccount: (key: AccountKey) => Promise<Account | undefined>;\n  readonly getValidators: (transactions: ReadonlyArray<Transaction>) => Promise<ReadonlyArray<ECPoint>>;\n  readonly standbyValidators: ReadonlyArray<ECPoint>;\n  readonly getAllValidators: () => Promise<ReadonlyArray<Validator>>;\n  readonly calculateClaimAmount: (inputs: ReadonlyArray<Input>) => Promise<BN>;\n  readonly verifyScript: VerifyScript;\n  readonly currentHeight: number;\n  readonly governingToken: RegisterTransaction;\n  readonly utilityToken: RegisterTransaction;\n  readonly fees: { [K in TransactionType]?: BN };\n  readonly registerValidatorFee: BN;\n  readonly completely?: boolean;\n}\n\nexport class Block extends BlockBase implements SerializableWire<Block>, SerializableJSON<BlockJSON> {\n  public static async calculateNetworkFee(context: FeeContext, transactions: ReadonlyArray<Transaction>): Promise<BN> {\n    const fees = await Promise.all(transactions.map(async (transaction) => transaction.getNetworkFee(context)));\n\n    return fees.reduce((acc, fee) => acc.add(fee), utils.ZERO);\n  }\n\n  public static deserializeWireBase(options: DeserializeWireBaseOptions): Block {\n    const { reader } = options;\n    const blockBase = super.deserializeBlockBaseWireBase(options);\n    const transactions = reader.readArray(() => deserializeTransactionWireBase(options), 0x10000);\n\n    if (transactions.length === 0) {\n      throw new InvalidFormatError('Expected at least one transcaction in the block');\n    }\n\n    const merkleRoot = MerkleTree.computeRoot(transactions.map((transaction) => transaction.hash));\n\n    if (!common.uInt256Equal(merkleRoot, blockBase.merkleRoot)) {\n      throw new InvalidFormatError('Invalid merkle root');\n    }\n\n    return new this({\n      version: blockBase.version,\n      previousHash: blockBase.previousHash,\n      merkleRoot: blockBase.merkleRoot,\n      timestamp: blockBase.timestamp,\n      index: blockBase.index,\n      consensusData: blockBase.consensusData,\n      nextConsensus: blockBase.nextConsensus,\n      script: blockBase.script,\n      transactions,\n    });\n  }\n\n  public static deserializeWire(options: DeserializeWireOptions): Block {\n    return this.deserializeWireBase({\n      context: options.context,\n      reader: new BinaryReader(options.buffer),\n    });\n  }\n\n  public readonly transactions: ReadonlyArray<Transaction>;\n  protected readonly sizeExclusive = utils.lazy(() =>\n    IOHelper.sizeOfArray(this.transactions, (transaction) => transaction.size),\n  );\n  private readonly headerInternal = utils.lazy(\n    () =>\n      new Header({\n        version: this.version,\n        previousHash: this.previousHash,\n        merkleRoot: this.merkleRoot,\n        timestamp: this.timestamp,\n        index: this.index,\n        consensusData: this.consensusData,\n        nextConsensus: this.nextConsensus,\n        script: this.script,\n      }),\n  );\n\n  public constructor({\n    version,\n    previousHash,\n    timestamp,\n    index,\n    consensusData,\n    nextConsensus,\n    script,\n    hash,\n    transactions,\n    merkleRoot = MerkleTree.computeRoot(transactions.map((transaction) => transaction.hash)),\n  }: BlockAdd) {\n    super({\n      version,\n      previousHash,\n      merkleRoot,\n      timestamp,\n      index,\n      consensusData,\n      nextConsensus,\n      script,\n      hash,\n    });\n\n    this.transactions = transactions;\n  }\n\n  public get header(): Header {\n    return this.headerInternal();\n  }\n\n  public clone({\n    transactions,\n    script,\n  }: {\n    readonly transactions: ReadonlyArray<Transaction>;\n    readonly script: Witness;\n  }): Block {\n    return new Block({\n      version: this.version,\n      previousHash: this.previousHash,\n      merkleRoot: this.merkleRoot,\n      timestamp: this.timestamp,\n      index: this.index,\n      consensusData: this.consensusData,\n      nextConsensus: this.nextConsensus,\n      transactions,\n      script,\n    });\n  }\n\n  public async getNetworkFee(context: FeeContext): Promise<BN> {\n    return Block.calculateNetworkFee(context, this.transactions);\n  }\n\n  public getSystemFee(context: FeeContext): BN {\n    return this.transactions.reduce((acc, transaction) => acc.add(transaction.getSystemFee(context)), utils.ZERO);\n  }\n\n  public async verify(options: BlockVerifyOptions): Promise<void> {\n    const { completely = false } = options;\n\n    if (\n      this.transactions.length === 0 ||\n      this.transactions[0].type !== TransactionType.Miner ||\n      this.transactions.slice(1).some((transaction) => transaction.type === TransactionType.Miner)\n    ) {\n      throw new VerifyError('Invalid miner transaction in block.');\n    }\n\n    await Promise.all([this.verifyBase(options), completely ? this.verifyComplete(options) : Promise.resolve()]);\n  }\n\n  public serializeWireBase(writer: BinaryWriter): void {\n    super.serializeWireBase(writer);\n    writer.writeArray(this.transactions, (transaction) => transaction.serializeWireBase(writer));\n  }\n\n  public async serializeJSON(context: SerializeJSONContext): Promise<BlockJSON> {\n    const blockBaseJSON = super.serializeBlockBaseJSON(context);\n\n    return {\n      version: blockBaseJSON.version,\n      hash: blockBaseJSON.hash,\n      previousblockhash: blockBaseJSON.previousblockhash,\n      merkleroot: blockBaseJSON.merkleroot,\n      time: blockBaseJSON.time,\n      index: blockBaseJSON.index,\n      nonce: blockBaseJSON.nonce,\n      nextconsensus: blockBaseJSON.nextconsensus,\n      script: blockBaseJSON.script,\n      tx: await Promise.all(\n        this.transactions.map(\n          (transaction) => transaction.serializeJSON(context) as TransactionJSON | PromiseLike<TransactionJSON>,\n        ),\n      ),\n      size: blockBaseJSON.size,\n      confirmations: blockBaseJSON.confirmations,\n    };\n  }\n\n  private async verifyBase({\n    genesisBlock,\n    tryGetBlock,\n    tryGetHeader,\n    verifyScript,\n  }: BlockVerifyOptions): Promise<void> {\n    if (common.uInt256Equal(this.hash, genesisBlock.hash)) {\n      return;\n    }\n\n    const existingBlock = await tryGetBlock({ hashOrIndex: this.hash });\n    if (existingBlock !== undefined) {\n      return;\n    }\n\n    const previousHeader = await tryGetHeader({\n      hashOrIndex: this.previousHash,\n    });\n\n    if (previousHeader === undefined) {\n      throw new VerifyError('Previous header does not exist.');\n    }\n\n    if (previousHeader.index + 1 !== this.index) {\n      throw new VerifyError('Previous index + 1 does not match index.');\n    }\n\n    if (previousHeader.timestamp >= this.timestamp) {\n      throw new VerifyError('Previous timestamp is greater than block.');\n    }\n\n    const { failureMessage } = await verifyScript({\n      scriptContainer: { type: ScriptContainerType.Block, value: this },\n      hash: previousHeader.nextConsensus,\n      witness: this.script,\n    });\n\n    if (failureMessage !== undefined) {\n      throw new VerifyError(failureMessage);\n    }\n  }\n\n  private async verifyComplete(options: BlockVerifyOptions): Promise<void> {\n    await Promise.all([\n      this.verifyConsensus(options),\n      this.verifyTransactions(options),\n      this.verifyNetworkFee(options),\n    ]);\n  }\n\n  private async verifyConsensus({ getValidators }: BlockVerifyOptions): Promise<void> {\n    const validators = await getValidators(this.transactions);\n    if (!common.uInt160Equal(this.nextConsensus, crypto.getConsensusAddress(validators))) {\n      throw new VerifyError('Invalid next consensus address');\n    }\n  }\n\n  private async verifyTransactions(options: BlockVerifyOptions): Promise<void> {\n    const results = await Promise.all(\n      this.transactions.map(async (transaction) =>\n        transaction.verify({\n          isSpent: options.isSpent,\n          getAsset: options.getAsset,\n          getOutput: options.getOutput,\n          tryGetAccount: options.tryGetAccount,\n          calculateClaimAmount: options.calculateClaimAmount,\n          standbyValidators: options.standbyValidators,\n          getAllValidators: options.getAllValidators,\n          verifyScript: options.verifyScript,\n          currentHeight: options.currentHeight,\n          governingToken: options.governingToken,\n          utilityToken: options.utilityToken,\n          fees: options.fees,\n          registerValidatorFee: options.registerValidatorFee,\n        }),\n      ),\n    );\n    const failureResults = results.filter((verifyResults) =>\n      verifyResults.some(({ failureMessage }) => failureMessage !== undefined),\n    );\n    if (failureResults.length > 0) {\n      const failureResult = failureResults[0].find(({ failureMessage }) => failureMessage !== undefined);\n      if (failureResult !== undefined && failureResult.failureMessage !== undefined) {\n        throw new VerifyError(failureResult.failureMessage);\n      }\n    }\n  }\n\n  private async verifyNetworkFee(options: BlockVerifyOptions): Promise<void> {\n    const networkFee = await this.getNetworkFee({\n      getOutput: options.getOutput,\n      governingToken: options.governingToken,\n      utilityToken: options.utilityToken,\n      fees: options.fees,\n      registerValidatorFee: options.registerValidatorFee,\n    });\n\n    const minerTransaction = this.transactions.find((transaction) => transaction.type === TransactionType.Miner);\n\n    if (minerTransaction === undefined) {\n      throw new VerifyError('Missing miner transaction');\n    }\n\n    const minerTransactionNetworkFee = minerTransaction.outputs.reduce(\n      (acc, output) => acc.add(output.value),\n      utils.ZERO,\n    );\n\n    if (!networkFee.eq(minerTransactionNetworkFee)) {\n      throw new VerifyError('Miner output does not equal network fee.');\n    }\n  }\n}\n"]}