Aggregate Transaction (Elephant-1)

AggregateBondTx.ts

import { Listener, Account, NetworkType, PublicAccount, TransferTransaction, Deadline, PlainMessage, NetworkCurrencyMosaic, AggregateTransaction, HashLockTransaction, UInt64, TransactionHttp } from 'nem2-sdk';
import { filter, mergeMap } from 'rxjs/operators';

const nodeUrl = 'https://catapult-test.opening-line.jp:3001';
const transactionHttp = new TransactionHttp(nodeUrl);
const listener = new Listener(nodeUrl);

const aPrivateKey = 'Account_A_Private_Key';
const aAccount = Account.createFromPrivateKey(aPrivateKey, NetworkType.MIJIN_TEST);

const bPublicKey = 'Account_B_Public_Key';
const bPublicAccount = PublicAccount.createFromPublicKey(bPublicKey, NetworkType.MIJIN_TEST);

const generationHash = '453052FDC4EB23BF0D7280C103F7797133A633B68A81986165B76FCE248AB235';

const aToBTx = TransferTransaction.create(
  Deadline.create(),
  bPublicAccount.address,
  [],
  PlainMessage.create('Please give me 100 cat.currency'),
  NetworkType.MIJIN_TEST
);

const bToATx = TransferTransaction.create(
  Deadline.create(),
  aAccount.address,
  [NetworkCurrencyMosaic.createRelative(10)],
  PlainMessage.create('give you 100 cat.currency'),
  NetworkType.MIJIN_TEST
);

const aggregateTransaction = AggregateTransaction.createBonded(
  Deadline.create(),
  [aToBTx.toAggregate(aAccount.publicAccount),
  bToATx.toAggregate(bPublicAccount)],
  NetworkType.MIJIN_TEST
);

const signedTransaction = aAccount.sign(aggregateTransaction, generationHash);
console.log(`Aggregate Transaction Hash: ${signedTransaction.hash}`)

const hashLockTransaction = HashLockTransaction.create(
  Deadline.create(),
  NetworkCurrencyMosaic.createRelative(10),
  UInt64.fromUint(480),
  signedTransaction,
  NetworkType.MIJIN_TEST
);

const hashLockTransactionSigned = aAccount.sign(hashLockTransaction, generationHash);

listener.open().then(() => {
  transactionHttp
    .announce(hashLockTransactionSigned)
    .subscribe(x => console.log(x), err => console.error(err));
  listener
    .confirmed(aAccount.address)
    .pipe(
      filter((transaction) => transaction.transactionInfo !== undefined
        && transaction.transactionInfo.hash === hashLockTransactionSigned.hash),
        mergeMap(ignored => transactionHttp.announceAggregateBonded(signedTransaction))
    )
    .subscribe(announcedAggregateBounded => {
      console.log(announcedAggregateBounded);
      listener.close();
    },
    err => {
      console.error(err);
      listener.close();
    })
});

SignAggregateBondTx.ts

import { AggregateTransaction, CosignatureSignedTransaction, CosignatureTransaction,Account, TransactionHttp, AccountHttp, NetworkType } from 'nem2-sdk';
import { mergeMap, filter, map } from 'rxjs/operators';

const cosignAggregateBondedTransaction = (transaction: AggregateTransaction, account: Account): CosignatureSignedTransaction => {
  const cosignatureTransaction = CosignatureTransaction.create(transaction);
  return account.signCosignatureTransaction(cosignatureTransaction);
};

const nodeUrl = 'https://catapult-test.opening-line.jp:3001';
const transactionHttp = new TransactionHttp(nodeUrl);
const accountHttp = new AccountHttp(nodeUrl);

const bPrivateKey = 'Account_B_Private_Key';
const bAccount = Account.createFromPrivateKey(bPrivateKey, NetworkType.MIJIN_TEST);

const targetHash = 'Target_Hash';

accountHttp
  .aggregateBondedTransactions(bAccount.publicAccount)
  .pipe(
    mergeMap((_) => _),
    filter((_) => !_.signedByAccount(bAccount.publicAccount) && _.transactionInfo.hash === targetHash),
    map(transaction => cosignAggregateBondedTransaction(transaction, bAccount)),
    mergeMap(cosignAggregateBondedTransaction => transactionHttp.announceAggregateBondedCosignature(cosignAggregateBondedTransaction))
  )
  .subscribe(announcedTransaction => console.log(announcedTransaction), err => console.error(err));