AggregateBonded.js

const { 
  Account,
  TransactionHttp,
  TransactionService,
  TransferTransaction,
  AggregateTransaction,
  HashLockTransaction,
  UInt64,
  Deadline,
  PlainMessage,
  RepositoryFactoryHttp} = require('symbol-sdk');

const { map, mergeMap, filter } =  require('rxjs/operators');
const { ChronoUnit } = require('@js-joda/core');
const config = require('config');

const url = 'http://18.236.79.168:3000';
const rawprivatekey1 = '';
const rawprivatekey2 = '';
const rawprivatekey3 = '';

const minfeemultiplier = 100;

(async() => {
  const repo = new RepositoryFactoryHttp(url);

  const networkType = await repo.getNetworkType().toPromise()
  const ghash = await repo.getGenerationHash().toPromise()

  const tfee = await repo.createNetworkRepository().getTransactionFees().toPromise()

  console.log('network', networkType);
  console.log('GenerationHash', ghash);
  console.log('Fee', tfee);

  const epoch = await repo.getEpochAdjustment().toPromise();
  const currency = await repo.getCurrencies().toPromise();


  const account1 = Account.createFromPrivateKey(rawprivatekey1, networkType);
  const account2 = Account.createFromPrivateKey(rawprivatekey2, networkType);
  const account3 = Account.createFromPrivateKey(rawprivatekey3, networkType);


  const transferTransaction1 = TransferTransaction.create(
    Deadline.create(epoch),
    account3.address,
    [currency.currency.createRelative(10)],
    PlainMessage.create('TEST tx1'),
    networkType,
  )

  const transferTransaction2 = TransferTransaction.create(
    Deadline.create(epoch),
    account3.address,
    [currency.currency.createRelative(5)],
    PlainMessage.create('TEST tx2'),
    networkType,
  )

  const aggregteTransaction = AggregateTransaction.createBonded(
    Deadline.create(epoch),
    [
      transferTransaction1.toAggregate(account1.publicAccount),
      transferTransaction2.toAggregate(account2.publicAccount)
    ],
    networkType,
    []
  ).setMaxFeeForAggregate(minfeemultiplier, 1);

  console.log(aggregteTransaction.maxFee)

  const signedTransaction = account1.sign(aggregteTransaction, ghash);

  console.log('------------------- signedTransaction ------------------------');
  console.log(signedTransaction);


  const hashLockTransaction = HashLockTransaction.create(
    Deadline.create(epoch),
    currency.currency.createRelative(10),
    UInt64.fromUint(1000),
    signedTransaction,
    networkType
    ).setMaxFee(minfeemultiplier);

  const signedHashLockTransaction = account1.sign(hashLockTransaction, ghash);

  console.log('------------------- hashRockTransaction ------------------------');  

  const transactionHttp = new TransactionHttp(url);

  console.log('------------------- sendTransaction ------------------------');

  const listener = repo.createListener();
  const transactionService = new TransactionService(repo.createTransactionRepository(), repo.createReceiptRepository());

  await listener.open();

  transactionService.announceHashLockAggregateBonded(signedHashLockTransaction, signedTransaction, listener)
  // .pipe(
  //   map(async (_) => {
  //     const signdTransaction = account2.signCosignatureTransaction(CosignatureTransaction.create(_))
  //     return await transactionHttp.announceAggregateBondedCosignature(signdTransaction).toPromise()
  //     }),
  //   mergeMap(async (_) => _)
  // )
  .subscribe(async (transactionAnnounceResponse) => {
    console.log('------------------- Success --------------------------------')
    console.log('Success: TransactionAnnounceResponse', transactionAnnounceResponse);
    console.log('------------------------------------------------------------')
    listener.close();

  }, (error) => {
    console.log(error)
    listener.close();
  })

})()