Merge branch 'master' into task/g4_check_act_has_all_sosignatories

Author: Grégory Saive

e2e/infrastructure/TransactionHttp.spec.ts

@@ -874,4 +874,15 @@ describe('TransactionHttp', () => {
                 });
         });
     });
+
+    describe('getTransactionEffectiveFee', () => {
+        it('should return effective paid fee given transactionHash', (done) => {
+            transactionHttp.getTransactionEffectiveFee(transactionHash)
+                .subscribe((effectiveFee) => {
+                    expect(effectiveFee).to.not.be.undefined;
+                    expect(effectiveFee).to.be.equal(0);
+                    done();
+                });
+        });
+    });
 });

e2e/infrastructure/TransactionUtils.ts

@@ -28,6 +28,7 @@ import { MultisigCosignatoryModification } from '../../src/model/transaction/Mul
 import { MultisigCosignatoryModificationType } from '../../src/model/transaction/MultisigCosignatoryModificationType';
 import {PlainMessage} from '../../src/model/transaction/PlainMessage';
 import {TransferTransaction} from '../../src/model/transaction/TransferTransaction';
+import {UInt64} from '../../src/model/UInt64';
 import {CosignatoryAccount, MultisigAccount, NIS2_URL, TestingAccount} from '../../test/conf/conf.spec';
 
 export class TransactionUtils {

src/infrastructure/BlockchainHttp.ts

@@ -26,7 +26,7 @@ import {UInt64} from '../model/UInt64';
 import {BlockchainRepository} from './BlockchainRepository';
 import {Http} from './Http';
 import {QueryParams} from './QueryParams';
-import {CreateTransactionFromDTO} from './transaction/CreateTransactionFromDTO';
+import {CreateTransactionFromDTO, extractBeneficiary} from './transaction/CreateTransactionFromDTO';
 
 /**
  * Blockchain http repository.
@@ -70,8 +70,12 @@ export class BlockchainHttp extends Http implements BlockchainRepository {
                 new UInt64(blockDTO.block.height),
                 new UInt64(blockDTO.block.timestamp),
                 new UInt64(blockDTO.block.difficulty),
+                blockDTO.block.feeMultiplier,
                 blockDTO.block.previousBlockHash,
                 blockDTO.block.blockTransactionsHash,
+                blockDTO.block.blockReceiptsHash,
+                blockDTO.block.stateHash,
+                extractBeneficiary(blockDTO, networkType),
             );
         }));
     }
@@ -116,8 +120,12 @@ export class BlockchainHttp extends Http implements BlockchainRepository {
                     new UInt64(blockDTO.block.height),
                     new UInt64(blockDTO.block.timestamp),
                     new UInt64(blockDTO.block.difficulty),
+                    blockDTO.block.feeMultiplier,
                     blockDTO.block.previousBlockHash,
                     blockDTO.block.blockTransactionsHash,
+                    blockDTO.block.blockReceiptsHash,
+                    blockDTO.block.stateHash,
+                    extractBeneficiary(blockDTO, networkType),
                 );
             });
         }));

src/infrastructure/Listener.ts

@@ -20,6 +20,7 @@ import * as WebSocket from 'ws';
 import {Address} from '../model/account/Address';
 import {PublicAccount} from '../model/account/PublicAccount';
 import {BlockInfo} from '../model/blockchain/BlockInfo';
+import {NetworkType} from '../model/blockchain/NetworkType';
 import {NamespaceId} from '../model/namespace/NamespaceId';
 import {AggregateTransaction} from '../model/transaction/AggregateTransaction';
 import {AggregateTransactionCosignature} from '../model/transaction/AggregateTransactionCosignature';
@@ -33,7 +34,7 @@ import {Transaction} from '../model/transaction/Transaction';
 import {TransactionStatusError} from '../model/transaction/TransactionStatusError';
 import {TransferTransaction} from '../model/transaction/TransferTransaction';
 import {UInt64} from '../model/UInt64';
-import {CreateTransactionFromDTO} from './transaction/CreateTransactionFromDTO';
+import {CreateTransactionFromDTO, extractBeneficiary} from './transaction/CreateTransactionFromDTO';
 
 enum ListenerChannelName {
     block = 'block',
@@ -135,8 +136,12 @@ export class Listener {
                                 new UInt64(message.block.height),
                                 new UInt64(message.block.timestamp),
                                 new UInt64(message.block.difficulty),
+                                message.block.feeMultiplier,
                                 message.block.previousBlockHash,
                                 message.block.blockTransactionsHash,
+                                message.block.blockReceiptsHash,
+                                message.block.stateHash,
+                                extractBeneficiary(message, networkType), // passing `message` as `blockDTO`
                             ),
                         });
                     } else if (message.status) {

src/infrastructure/TransactionHttp.ts

@@ -14,17 +14,18 @@
  * limitations under the License.
  */
 
-import {TransactionRoutesApi} from 'nem2-library';
+import {BlockchainRoutesApi, TransactionRoutesApi} from 'nem2-library';
 import * as requestPromise from 'request-promise-native';
 import {from as observableFrom, Observable, throwError as observableThrowError} from 'rxjs';
-import {catchError, map} from 'rxjs/operators';
+import {catchError, map, mergeMap} from 'rxjs/operators';
 import {PublicAccount} from '../model/account/PublicAccount';
 import {CosignatureSignedTransaction} from '../model/transaction/CosignatureSignedTransaction';
 import {Deadline} from '../model/transaction/Deadline';
 import {SignedTransaction} from '../model/transaction/SignedTransaction';
 import { SyncAnnounce } from '../model/transaction/SyncAnnounce';
 import {Transaction} from '../model/transaction/Transaction';
 import {TransactionAnnounceResponse} from '../model/transaction/TransactionAnnounceResponse';
+import {TransactionInfo} from '../model/transaction/TransactionInfo';
 import {TransactionStatus} from '../model/transaction/TransactionStatus';
 import {TransactionType} from '../model/transaction/TransactionType';
 import {UInt64} from '../model/UInt64';
@@ -44,13 +45,20 @@ export class TransactionHttp extends Http implements TransactionRepository {
      */
     private transactionRoutesApi: TransactionRoutesApi;
 
+    /**
+     * @internal
+     * Nem2 Library blockchain routes api
+     */
+    private blockchainRoutesApi: BlockchainRoutesApi;
+
     /**
      * Constructor
      * @param url
      */
     constructor(private readonly url: string) {
         super(url);
         this.transactionRoutesApi = new TransactionRoutesApi(this.apiClient);
+        this.blockchainRoutesApi = new BlockchainRoutesApi(this.apiClient);
     }
 
     /**
@@ -190,4 +198,29 @@ export class TransactionHttp extends Http implements TransactionRepository {
             return observableThrowError(err);
         }));
     }
+
+    /**
+     * Gets a transaction's effective paid fee
+     * @param transactionId - Transaction id or hash.
+     * @returns Observable<number>
+     */
+    public getTransactionEffectiveFee(transactionId: string): Observable<number> {
+        return observableFrom(this.transactionRoutesApi.getTransaction(transactionId)).pipe(
+            mergeMap((transactionDTO) => {
+                // parse transaction to take advantage of `size` getter overload
+                const transaction = CreateTransactionFromDTO(transactionDTO);
+                const uintHeight = (transaction.transactionInfo as TransactionInfo).height;
+
+                // now read block details
+                return observableFrom(this.blockchainRoutesApi.getBlockByHeight(uintHeight.compact())).pipe(
+                map((blockDTO) => {
+
+                    // @see https://nemtech.github.io/concepts/transaction.html#fees
+                    // effective_fee = feeMultiplier x transaction::size
+                    return blockDTO.block.feeMultiplier * transaction.size;
+                }));
+            }), catchError((err) => {
+                return observableThrowError(err);
+            }));
+    }
 }

src/infrastructure/TransactionRepository.ts

@@ -56,6 +56,13 @@ export interface TransactionRepository {
      */
     getTransactionsStatuses(transactionHashes: string[]): Observable<TransactionStatus[]>;
 
+    /**
+     * Gets a transaction's effective paid fee
+     * @param transactionId - Transaction id or hash.
+     * @returns Observable<number>
+     */
+    getTransactionEffectiveFee(transactionId: string): Observable<number>;
+
     /**
      * Send a signed transaction
      * @param signedTransaction - Signed transaction