Merge pull request #837 from symbol/dev

Release v2.0.0

.eslintrc.js

@@ -1,8 +1,8 @@
 module.exports = {
  parser: '@typescript-eslint/parser', // Specifies the ESLint parser
+ plugins: ['@typescript-eslint/eslint-plugin'],
  extends: [
  'plugin:@typescript-eslint/recommended', // Uses the recommended rules from the @typescript-eslint/eslint-plugin
- 'prettier/@typescript-eslint', // Uses eslint-config-prettier to disable ESLint rules from @typescript-eslint/eslint-plugin that would conflict with prettier
  'plugin:prettier/recommended', // Enables eslint-plugin-prettier and eslint-config-prettier. This will display prettier errors as ESLint errors. Make sure this is always the last configuration in the extends array.
  ],
  parserOptions: {

.travis.yml

@@ -1,8 +1,9 @@
 dist: bionic
 language: node_js
 node_js:
- - 10
  - 12
+ - lts/*
+ - node
 services:
  - docker
 env:

CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to this project will be documented in this file.
 
 The changelog format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [2.0.0] - 01-Mar-2022
+
+**Milestone**: Symbol Mainnet
+Package | Version | Link
+---|---|---
+SDK Core| v2.0.0 | [symbol-sdk](https://www.npmjs.com/package/symbol-sdk)
+Catbuffer | v1.0.1 | [catbuffer-typescript](https://www.npmjs.com/package/catbuffer-typescript)
+Client Library | v1.0.3 | [symbol-openapi-typescript-fetch-client](https://www.npmjs.com/package/symbol-openapi-typescript-fetch-client)
+
+- **[BREAKING CHANGE]** The type of `value` field in `AccountMetadataTransaction`, `MosaicMetadataTransaction`, `NamespaceMetadataTransaction` classes is changed from `string` to `Uint8Array`.
+- fix: Fixed metadata value non-ascii utf8 encoding issue [#834](https://github.com/symbol/symbol-sdk-typescript-javascript/issues/834)
+- fix: Upgraded Node to 12.22.1.
+- fix: Upgraded typescript to 4.5.4.
+- fix: Upgraded RXJS to 7.4.0.
+
 ## [1.0.3] - 16-Nov-2021
 
 **Milestone**: Symbol Mainnet

e2e/infrastructure/AccountHttp.spec.ts

@@ -16,6 +16,7 @@
 
 import { deepEqual } from 'assert';
 import { expect } from 'chai';
+import { firstValueFrom } from 'rxjs';
 import { take, toArray } from 'rxjs/operators';
 import { AccountRepository, MultisigRepository, NamespaceRepository, Order, RepositoryCallError } from '../../src/infrastructure';
 import { AccountPaginationStreamer } from '../../src/infrastructure/paginationStreamer';
@@ -164,79 +165,77 @@ describe('AccountHttp', () => {
 
  describe('getAccountInfo', () => {
  it('should return account data given a NEM Address', async () => {
- const accountInfo = await accountRepository.getAccountInfo(accountAddress).toPromise();
+ const accountInfo = await firstValueFrom(accountRepository.getAccountInfo(accountAddress));
  expect(accountInfo.publicKey).to.be.equal(accountPublicKey);
 
- const merkleInfo = await accountRepository.getAccountInfoMerkle(accountInfo.address).toPromise();
+ const merkleInfo = await firstValueFrom(accountRepository.getAccountInfoMerkle(accountInfo.address));
  expect(merkleInfo.raw).to.not.be.undefined;
  });
  });
 
  describe('getAccountsInfo', () => {
  it('should return account data given a NEM Address', async () => {
- const accountsInfo = await accountRepository.getAccountsInfo([accountAddress]).toPromise();
+ const accountsInfo = await firstValueFrom(accountRepository.getAccountsInfo([accountAddress]));
  expect(accountsInfo[0].publicKey).to.be.equal(accountPublicKey);
  });
  });
 
  describe('searchAccount', () => {
  it('should return account info', async () => {
- const info = await accountRepository.search({}).toPromise();
+ const info = await firstValueFrom(accountRepository.search({}));
  expect(info.data.length).to.be.greaterThan(0);
  });
  });
 
  describe('searchAccount with streamer', () => {
  it('should return account info', async () => {
  const streamer = new AccountPaginationStreamer(accountRepository);
- const infoStreamer = await streamer
- .search({ pageSize: 20, order: Order.Asc, orderBy: AccountOrderBy.Id })
- .pipe(take(20), toArray())
- .toPromise();
- const info = await accountRepository.search({ pageSize: 20, order: Order.Asc, orderBy: AccountOrderBy.Id }).toPromise();
+ const infoStreamer = await firstValueFrom(
+ streamer.search({ pageSize: 20, order: Order.Asc, orderBy: AccountOrderBy.Id }).pipe(take(20), toArray()),
+ );
+ const info = await firstValueFrom(accountRepository.search({ pageSize: 20, order: Order.Asc, orderBy: AccountOrderBy.Id }));
  expect(infoStreamer.length).to.be.greaterThan(0);
  deepEqual(infoStreamer[0], info.data[0]);
  });
  });
 
  describe('transactions', () => {
  it('should not return accounts when account does not exist', () => {
- return accountRepository
- .getAccountInfo(Account.generateNewAccount(networkType).address)
- .toPromise()
- .then(
- () => {
- return Promise.reject('should fail!');
- },
- (err) => {
- const error: RepositoryCallError = JSON.parse(err.message);
- expect(error.statusCode).to.be.eq(404);
- expect(error.statusMessage).to.be.eq('Not Found');
- return Promise.resolve();
- },
- );
+ return firstValueFrom(accountRepository.getAccountInfo(Account.generateNewAccount(networkType).address)).then(
+ () => {
+ return Promise.reject('should fail!');
+ },
+ (err) => {
+ const error: RepositoryCallError = JSON.parse(err.message);
+ expect(error.statusCode).to.be.eq(404);
+ expect(error.statusMessage).to.be.eq('Not Found');
+ return Promise.resolve();
+ },
+ );
  });
  });
 
  describe('getAddressNames', () => {
  it('should call getAddressNames successfully', async () => {
- const addressNames = await namespaceRepository.getAccountsNames([accountAddress]).toPromise();
+ const addressNames = await firstValueFrom(namespaceRepository.getAccountsNames([accountAddress]));
  expect(addressNames.length).to.be.greaterThan(0);
  });
  });
 
  describe('getMultisigAccountGraphInfo', () => {
  it('should call getMultisigAccountGraphInfo successfully', async () => {
  await new Promise((resolve) => setTimeout(resolve, 3000));
- const multisigAccountGraphInfo = await multisigRepository
- .getMultisigAccountGraphInfo(multisigAccount.publicAccount.address)
-  .toPromise();
+ const multisigAccountGraphInfo = await firstValueFrom(
+ multisigRepository.getMultisigAccountGraphInfo(multisigAccount.publicAccount.address),
+ );
  expect(multisigAccountGraphInfo.multisigEntries.get(0)![0].accountAddress.plain()).to.be.equal(multisigAccount.address.plain());
  });
  });
  describe('getMultisigAccountInfo', () => {
  it('should call getMultisigAccountInfo successfully', async () => {
- const multisigAccountInfo = await multisigRepository.getMultisigAccountInfo(multisigAccount.publicAccount.address).toPromise();
+ const multisigAccountInfo = await firstValueFrom(
+ multisigRepository.getMultisigAccountInfo(multisigAccount.publicAccount.address),
+ );
  expect(multisigAccountInfo.accountAddress.plain()).to.be.equal(multisigAccount.address.plain());
  });
  });

e2e/infrastructure/BlockHttp.spec.ts

@@ -16,6 +16,7 @@
 
 import { deepEqual } from 'assert';
 import { expect } from 'chai';
+import { firstValueFrom } from 'rxjs';
 import { mergeMap, take, toArray } from 'rxjs/operators';
 import { Order } from '../../src/infrastructure';
 import { BlockRepository } from '../../src/infrastructure/BlockRepository';
@@ -84,7 +85,7 @@ describe('BlockHttp', () => {
 
  describe('getBlockByHeight', () => {
  it('should return block info given height', async () => {
- const blockInfo = await blockRepository.getBlockByHeight(UInt64.fromUint(1)).toPromise();
+ const blockInfo = await firstValueFrom(blockRepository.getBlockByHeight(UInt64.fromUint(1)));
  expect(blockInfo.height.lower).to.be.equal(1);
  expect(blockInfo.height.higher).to.be.equal(0);
  expect(blockInfo.timestamp.lower).to.be.equal(0);
@@ -96,56 +97,54 @@ describe('BlockHttp', () => {
 
  describe('searchBlock', () => {
  it('should return block info given height and limit', async () => {
- const blocksInfo = await blockRepository.search({}).toPromise();
+ const blocksInfo = await firstValueFrom(blockRepository.search({}));
  expect(blocksInfo.data.length).to.be.greaterThan(0);
  });
  });
 
  describe('searchBlock with streamer', () => {
  it('should return block info given height and limit', async () => {
  const streamer = new BlockPaginationStreamer(blockRepository);
- const blockInfoStreamer = await streamer.search({ pageSize: 20 }).pipe(take(20), toArray()).toPromise();
- const blocksInfo = await blockRepository.search({ pageSize: 20 }).toPromise();
+ const blockInfoStreamer = await firstValueFrom(streamer.search({ pageSize: 20 }).pipe(take(20), toArray()));
+ const blocksInfo = await firstValueFrom(blockRepository.search({ pageSize: 20 }));
  expect(blockInfoStreamer.length).to.be.greaterThan(0);
  deepEqual(blockInfoStreamer, blocksInfo.data);
  });
  });
 
  describe('getMerkleReceipts', () => {
  it('should return Merkle Receipts', async () => {
- const merkleReceipts = await receiptRepository
- .searchReceipts({ height: chainHeight })
- .pipe(
+ const merkleReceipts = await firstValueFrom(
+ receiptRepository.searchReceipts({ height: chainHeight }).pipe(
  mergeMap((_) => {
  return blockRepository.getMerkleReceipts(chainHeight, (_.data[0] as TransactionStatement).generateHash());
  }),
- )
-  .toPromise();
+ ),
+ );
  expect(merkleReceipts.merklePath).not.to.be.null;
  });
  });
  describe('getMerkleTransaction', () => {
  it('should return Merkle Transaction', async () => {
- const merkleTransactionss = await blockRepository.getMerkleTransaction(chainHeight, transactionHash).toPromise();
+ const merkleTransactionss = await firstValueFrom(blockRepository.getMerkleTransaction(chainHeight, transactionHash));
  expect(merkleTransactionss.merklePath).not.to.be.null;
  });
  });
 
  describe('getBlockReceipts', () => {
  it('should return block receipts', async () => {
- const statement = await receiptRepository.searchReceipts({ height: chainHeight }).toPromise();
+ const statement = await firstValueFrom(receiptRepository.searchReceipts({ height: chainHeight }));
  expect(statement.data.length).to.be.greaterThan(0);
  });
  });
 
  describe('searchReceipt with streamer', () => {
  it('should return receipt info', async () => {
  const streamer = ReceiptPaginationStreamer.transactionStatements(receiptRepository);
- const infoStreamer = await streamer
- .search({ pageSize: 20, height: chainHeight, order: Order.Asc })
- .pipe(take(20), toArray())
- .toPromise();
- const info = await receiptRepository.searchReceipts({ pageSize: 20, height: chainHeight, order: Order.Asc }).toPromise();
+ const infoStreamer = await firstValueFrom(
+ streamer.search({ pageSize: 20, height: chainHeight, order: Order.Asc }).pipe(take(20), toArray()),
+ );
+ const info = await firstValueFrom(receiptRepository.searchReceipts({ pageSize: 20, height: chainHeight, order: Order.Asc }));
  expect(infoStreamer.length).to.be.greaterThan(0);
  deepEqual(infoStreamer[0], info.data[0]);
  });

e2e/infrastructure/ChainHttp.spec.ts

@@ -15,6 +15,7 @@
  */
 
 import { expect } from 'chai';
+import { firstValueFrom } from 'rxjs';
 import { ChainRepository } from '../../src/infrastructure/ChainRepository';
 import { IntegrationTestHelper } from './IntegrationTestHelper';
 
@@ -34,7 +35,7 @@ describe('ChainHttp', () => {
 
  describe('getChainInfo', () => {
  it('should return blockchain score', async () => {
- const info = await chainRepository.getChainInfo().toPromise();
+ const info = await firstValueFrom(chainRepository.getChainInfo());
  expect(info.scoreLow).to.not.be.equal(undefined);
  expect(info.scoreHigh.lower).to.be.equal(0);
  expect(info.scoreHigh.higher).to.be.equal(0);

e2e/infrastructure/FinalizationHttp.spec.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import { expect } from 'chai';
+import { firstValueFrom } from 'rxjs';
 import { FinalizationRepository } from '../../src/infrastructure/FinalizationRepository';
 import { UInt64 } from '../../src/model/UInt64';
 import { IntegrationTestHelper } from './IntegrationTestHelper';
@@ -34,7 +35,7 @@ describe('FinalizationHttp', () => {
 
  describe('getFinalizationProofAtEpoch', () => {
  it('should return finalization proof at epoch', async () => {
- const dto = await finalizationRepository.getFinalizationProofAtEpoch(1).toPromise();
+ const dto = await firstValueFrom(finalizationRepository.getFinalizationProofAtEpoch(1));
  expect(dto).not.to.be.null;
  expect(dto.height).to.deep.eq(UInt64.fromUint(1));
  expect(dto.version).to.eq(1);
@@ -46,7 +47,7 @@ describe('FinalizationHttp', () => {
 
  describe('getNetworkName', () => {
  it('should return finalization proof at height', async () => {
- const dto = await finalizationRepository.getFinalizationProofAtHeight(UInt64.fromUint(1)).toPromise();
+ const dto = await firstValueFrom(finalizationRepository.getFinalizationProofAtHeight(UInt64.fromUint(1)));
  expect(dto).not.to.be.null;
  expect(dto.height).to.deep.eq(UInt64.fromUint(1));
  expect(dto.version).to.eq(1);

e2e/infrastructure/HashLockHttp.spec.ts

@@ -17,6 +17,7 @@
 import { ChronoUnit } from '@js-joda/core';
 import { deepEqual } from 'assert';
 import { expect } from 'chai';
+import { firstValueFrom } from 'rxjs';
 import { take, toArray } from 'rxjs/operators';
 import { HashLockPaginationStreamer, Order } from '../../src/infrastructure';
 import { HashLockRepository } from '../../src/infrastructure/HashLockRepository';
@@ -154,34 +155,33 @@ describe('HashLockHttp', () => {
  describe('searchHashLock', () => {
  it('should return hash lock page info', async () => {
  await new Promise((resolve) => setTimeout(resolve, 3000));
- const page = await hashLockRepo.search({ address: account.address }).toPromise();
+ const page = await firstValueFrom(hashLockRepo.search({ address: account.address }));
  const info = page.data[0];
  hash = info.hash;
  expect(page.data.length).to.be.greaterThan(0);
 
- const infoFromId = await hashLockRepo.getHashLock(hash).toPromise();
+ const infoFromId = await firstValueFrom(hashLockRepo.getHashLock(hash));
  expect(infoFromId).deep.eq(info);
- const merkleInfo = await hashLockRepo.getHashLockMerkle(hash).toPromise();
+ const merkleInfo = await firstValueFrom(hashLockRepo.getHashLockMerkle(hash));
  expect(merkleInfo.raw).to.not.be.undefined;
  });
  });
 
  describe('searchHashLock with streamer', () => {
  it('should return hash lock page info', async () => {
  const streamer = new HashLockPaginationStreamer(hashLockRepo);
- const infoStreamer = await streamer
- .search({ address: account.address, pageSize: 20, order: Order.Asc })
- .pipe(take(20), toArray())
- .toPromise();
- const info = await hashLockRepo.search({ address: account.address, pageSize: 20, order: Order.Asc }).toPromise();
+ const infoStreamer = await firstValueFrom(
+ streamer.search({ address: account.address, pageSize: 20, order: Order.Asc }).pipe(take(20), toArray()),
+ );
+ const info = await firstValueFrom(hashLockRepo.search({ address: account.address, pageSize: 20, order: Order.Asc }));
  expect(infoStreamer.length).to.be.greaterThan(0);
  deepEqual(infoStreamer[0], info.data[0]);
  });
  });
 
  describe('getHashLock', () => {
  it('should return hash lock info given hash', async () => {
- const info = await hashLockRepo.getHashLock(hash).toPromise();
+ const info = await firstValueFrom(hashLockRepo.getHashLock(hash));
  expect(info.ownerAddress.plain()).to.be.equal(account.address.plain());
  expect(info.amount.toString()).to.be.equal('10000000');
  });

e2e/infrastructure/IntegrationTestHelper.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { firstValueFrom } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { Addresses, BootstrapService, BootstrapUtils, ConfigLoader, StartParams } from 'symbol-bootstrap';
 import { IListener, RepositoryFactory, RepositoryFactoryHttp } from '../../src/infrastructure';
@@ -84,9 +85,9 @@ export class IntegrationTestHelper {
  this.repositoryFactory.createReceiptRepository(),
  );
 
- this.networkType = await this.repositoryFactory.getNetworkType().toPromise();
- this.generationHash = await this.repositoryFactory.getGenerationHash().toPromise();
- this.epochAdjustment = await this.repositoryFactory.getEpochAdjustment().toPromise();
+ this.networkType = await firstValueFrom(this.repositoryFactory.getNetworkType());
+ this.generationHash = await firstValueFrom(this.repositoryFactory.getGenerationHash());
+ this.epochAdjustment = await firstValueFrom(this.repositoryFactory.getEpochAdjustment());
 
  let index = 0;
  this.accounts = accounts.map((account) => Account.createFromPrivateKey(account, this.networkType));
@@ -104,7 +105,7 @@ export class IntegrationTestHelper {
 
  // What would be the best maxFee? In the future we will load the fee multiplier from rest.
  this.maxFee = UInt64.fromUint(1000000);
- this.networkCurrency = (await this.repositoryFactory.getCurrencies().toPromise()).currency;
+ this.networkCurrency = (await firstValueFrom(this.repositoryFactory.getCurrencies())).currency;
 
  if (openListener) {
  await this.listener.open();
@@ -118,22 +119,21 @@ export class IntegrationTestHelper {
 
  announce(signedTransaction: SignedTransaction): Promise<Transaction> {
  console.log(`Announcing transaction: ${signedTransaction.type}`);
- return this.transactionService
- .announce(signedTransaction, this.listener)
- .pipe(
+ return firstValueFrom(
+ this.transactionService.announce(signedTransaction, this.listener).pipe(
  map((t) => {
  console.log(`Transaction ${signedTransaction.type} confirmed`);
  return t;
  }),
- )
-  .toPromise();
+ ),
+ );
  }
 
- public static sleep(ms: number): Promise<any> {
+ public static sleep(ms: number): Promise<void> {
  // Create a promise that rejects in <ms> milliseconds
  return new Promise((resolve) => {
  setTimeout(() => {
- resolve();
+ resolve(undefined);
  }, ms);
  });
  }