.map( async (transferTransaction: TransferTransaction) => {
			try {
				const rawMsg = (transferTransaction.message as PlainMessage).plain().replace(/ /g, '');
				const hashId = rawMsg.substr(rawMsg.indexOf(':'), rawMsg.length);

				/**
				 * Try finding a transaction in the database that may be a partial payment. Sometimes people will send
				 * multiple amounts of XEM to purchase a product
				 */
				let transaction: XemTransaction = await findOneThatContains<XemTransaction>(DB_PARTIAL_XEM_CHARGES, 'message', hashId, TRANSACTION_MESSAGE_LENGTH);
				/**
				 * If it is not partial, we look up pending charges
				 */
				if (!transaction) {
					transaction = await findOneThatContains<XemTransaction>(DB_PENDING_XEM_CHARGES, 'message', hashId, TRANSACTION_MESSAGE_LENGTH);
				}
				const transfer = await formatIncomingTransaction(transferTransaction);

				/**
				 * Ignore transactions that are confirmed for the holding account - we only want to
				 * listen for customer transactions
				 */
				if (transfer.tokenRecipientAddress === tokenHoldingAccountAddress()
					|| transfer.tokenRecipientAddress === nemConfig.multisigAddress) {
					return;
				}

				/**
				 * If the transaction is not in the database someone sent us XEM without using
				 * our purchase process on the website
				 */
				if (!transaction) {
					saveAnonymousTransaction(transfer);
				} else {
					/**
					 * We found the pending transaction in the database
					 */
					onTransactionConfirmed(transaction, transfer);
				}
			} catch (err) {
				/**
				 * Save errors to the database so we can handle customer inquiries
				 */
				const amountPaid = transferTransaction.xem().amount;
				const errorTrans: XemTransaction = {
					_id: new ObjectID(),
					tokenRecipientAddress: transferTransaction.signer.address.plain(),
					tokenType: TokenType.NA,
					totalPaid: amountPaid,
					message: 'Contains mosaics: ' + transferTransaction.containsMosaics(),
					createdAt: new Date(),
					errMsg: err
				};
				await saveWithId<XemTransaction>(DB_PROBLEM_XEM_CHARGES, errorTrans);
			}
		})

				.subscribe(transferable => {
					resolve(TransferTransaction.createWithMosaics(
						TimeWindow.createWithDeadline(),
						new Address(toAddress),
						[transferable],
						EmptyMessage))
				}, error => {

			.map(mosaics => TransferTransaction.createWithMosaics(
				TimeWindow.createWithDeadline(),
				new Address(toAddress),
				mosaics,
				EmptyMessage))

			.map(mosaics => TransferTransaction.createWithMosaics(
				TimeWindow.createWithDeadline(),
				tokenTransfer.toAddress,
				mosaics,
				EmptyMessage))

	return new Promise<XemTransaction>(async (resolve, reject) => {
		try {
			let tokenType = TokenType.NA;
			let paid = 0;
			let usdPaid = 0;
			/**
			 * This first part is a safeguard - it means someone sent a Mosaic token
			 * instead of XEM. Handle these scenario accordingly
			 */
			if (transaction.containsMosaics()) {
				transaction.mosaics().map(mosaic => {
					if (mosaic.mosaicId.namespaceId === nemConfig.mosaicNamespace
						&& mosaic.mosaicId.name === nemConfig.mosaicForTransfer) {
						tokenType = TokenType.CHE;
						paid += mosaic.quantity;
					}
				});
			} else {
				/**
				 * Someone sent XEM
				 */
				tokenType = TokenType.XEM;
				paid = transaction.xem().amount * 1e6;
				usdPaid = await xemToUsd(paid);
			}
			const formmatedTransaction: XemTransaction = {
				_id: new ObjectID(),
				tokenRecipientAddress: transaction.signer.address.plain(),
				tokenType: tokenType,
				totalPaid: paid,
				usdPaid: usdPaid,
				createdAt: new Date()
			};
			if (transaction.message) {
				formmatedTransaction.message = (transaction.message as PlainMessage).plain().replace(/ /g, '');
			}
			resolve(formmatedTransaction);
		} catch (err) {
			reject(err);
		}
	});