Fixed #449

Added blockService

Author: rg911

e2e/service/BlockService.spec.ts

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2019 NEM
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { assert, expect } from 'chai';
+import { ReceiptRepository } from '../../src/infrastructure/ReceiptRepository';
+import { TransactionRepository } from '../../src/infrastructure/TransactionRepository';
+import { Account } from '../../src/model/account/Account';
+import { NetworkType } from '../../src/model/blockchain/NetworkType';
+import { PlainMessage } from '../../src/model/message/PlainMessage';
+import { NetworkCurrencyMosaic } from '../../src/model/mosaic/NetworkCurrencyMosaic';
+import { Deadline } from '../../src/model/transaction/Deadline';
+import { TransferTransaction } from '../../src/model/transaction/TransferTransaction';
+import { UInt64 } from '../../src/model/UInt64';
+import { BlockService } from '../../src/service/BlockService';
+import { IntegrationTestHelper } from '../infrastructure/IntegrationTestHelper';
+
+describe('BlockService', () => {
+    const helper = new IntegrationTestHelper();
+    let generationHash: string;
+    let account: Account;
+    let account2: Account;
+    let account3: Account;
+    let networkType: NetworkType;
+    let transactionHash: string;
+    let blockService: BlockService;
+    let transactionRepository: TransactionRepository;
+    let receiptRepository: ReceiptRepository;
+
+    before(() => {
+        return helper.start().then(() => {
+            account = helper.account;
+            account2 = helper.account2;
+            account3 = helper.account3;
+            generationHash = helper.generationHash;
+            networkType = helper.networkType;
+            transactionRepository = helper.repositoryFactory.createTransactionRepository();
+            receiptRepository = helper.repositoryFactory.createReceiptRepository();
+            blockService = new BlockService(helper.repositoryFactory.createBlockRepository(), receiptRepository);
+        });
+    });
+    before(() => {
+        return helper.listener.open();
+    });
+
+    after(() => {
+        helper.listener.close();
+    });
+
+    /**
+     * =========================
+     * Setup test data
+     * =========================
+     */
+    describe('Create a transfer', () => {
+        it('Announce TransferTransaction', () => {
+            const transferTransaction = TransferTransaction.create(
+                Deadline.create(),
+                account2.address,
+                [NetworkCurrencyMosaic.createAbsolute(1)],
+                PlainMessage.create('test-message'),
+                networkType,
+                helper.maxFee,
+            );
+
+            const signedTransaction = transferTransaction.signWith(account, generationHash);
+            transactionHash = signedTransaction.hash;
+            return helper.announce(signedTransaction);
+        });
+    });
+
+    /**
+     * =========================
+     * Test
+     * =========================
+     */
+
+    describe('Validate transansaction', () => {
+        it('call block service', () => {
+            return transactionRepository.getTransaction(transactionHash).subscribe(
+                (transaction) => {
+                    const transactionInfo = transaction.transactionInfo;
+                    if (transactionInfo && transactionInfo.height !== undefined) {
+                        const validationResult = blockService.validateTransactionInBlock(transactionHash, transactionInfo.height);
+                        expect(validationResult).to.be.true;
+                    }
+                    assert(false, `Transaction (hash: ${transactionHash}) not found`);
+                },
+            );
+        });
+    });
+
+    describe('Validate receipt', () => {
+        it('call block service', () => {
+            return receiptRepository.getBlockReceipts(UInt64.fromUint(1)).subscribe(
+                (statement) => {
+                    const receipt = statement.transactionStatements[0];
+                    const validationResult = blockService.validateReceiptInBlock(receipt.generateHash(), UInt64.fromUint(1));
+                    expect(validationResult).to.be.true;
+                },
+            );
+        });
+    });
+
+});

src/service/BlockService.ts

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2020 NEM
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { sha3_256 } from 'js-sha3';
+import { combineLatest, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { BlockRepository } from '../infrastructure/BlockRepository';
+import { ReceiptRepository } from '../infrastructure/ReceiptRepository';
+import { MerklePathItem } from '../model/blockchain/MerklePathItem';
+import { UInt64 } from '../model/UInt64';
+
+/**
+ * Transaction Service
+ */
+export class BlockService {
+
+    /**
+     * Constructor
+     * @param blockRepository
+     * @param receiptRepository
+     */
+    constructor(private readonly blockRepository: BlockRepository, private readonly receiptRepository: ReceiptRepository) {
+    }
+
+    /**
+     * Validate transaction hash in block
+     * @param leaf transaction hash
+     * @param height block height
+     */
+    public validateTransactionInBlock(leaf: string, height: UInt64): Observable<boolean> {
+        const rootHashObservable = this.blockRepository.getBlockByHeight(height);
+        const merklePathItemObservable = this.blockRepository.getMerkleTransaction(height, leaf);
+        return combineLatest(rootHashObservable, merklePathItemObservable).pipe(
+            map((combined) => this.validateInBlock(leaf, combined[1].merklePath, combined[0].blockTransactionsHash)),
+        );
+    }
+
+    /**
+     * Validate receipt hash in block
+     * @param leaf receipt hash
+     * @param height block height
+     */
+    public validateReceiptInBlock(leaf: string, height: UInt64): Observable<boolean> {
+        const rootHashObservable = this.blockRepository.getBlockByHeight(height);
+        const merklePathItemObservable = this.receiptRepository.getMerkleReceipts(height, leaf);
+        return combineLatest(rootHashObservable, merklePathItemObservable).pipe(
+            map((combined) => this.validateInBlock(leaf, combined[1].merklePath, combined[0].blockReceiptsHash)),
+        );
+    }
+
+    /**
+     * @internal
+     * Validate leaf against merkle tree in block
+     * @param leaf Leaf hash in merkle tree
+     * @param merklePathItem Merkle path item array
+     * @param rootHash Block root hash
+     */
+    private validateInBlock(leaf: string, merklePathItem: MerklePathItem[] = [], rootHash: string): boolean {
+        if (merklePathItem.length === 0) {
+                return leaf.toUpperCase() === rootHash.toUpperCase();
+        }
+        const rootToCompare = merklePathItem.reduce((proofHash, pathItem) => {
+                const hasher = sha3_256.create();
+                // Left
+                if (pathItem.position === 1) {
+                    return hasher.update(Buffer.from(pathItem.hash + proofHash, 'hex')).hex();
+                } else {
+                    // Right
+                    return hasher.update(Buffer.from(proofHash + pathItem.hash, 'hex')).hex();
+                }
+            }, leaf);
+        return rootToCompare.toUpperCase() === rootHash.toUpperCase();
+    }
+}

src/service/service.ts

@@ -20,3 +20,4 @@ export * from './AggregateTransactionService';
 export * from './MetadataTransactionService';
 export * from './MosaicRestrictionTransactionService';
 export * from './TransactionService';
+export * from './BlockService';