Modellazione di un gestore account in OOP

Ho questo compito di modellare un sistema in cui un gruppo di utenti può tenere traccia delle proprie spese. I requisiti di base sono i seguenti:

1. Essere in grado di dare credito a un utente.
2. Trova tutte le transazioni di un determinato utente.
3. Filtra la transazione in cui l'utente è mutuatario o spender.
4. Crea un gruppo e metti gli utenti in quel gruppo e poi, quando viene menzionato un gruppo, distribuisci equamente il denaro tra di loro. [TODO]

Ho provato poche cose ma non ne sono affatto convinto.

const trxn = new Array();

class Transaction {
    constructor(amount, from, to) {
      this.timestamp = new Date();
      this.amount = amount;
      this.from = from;
      this.to   = to;
      trxn.push(this);
    }

    toString() {
      let dd = this.timestamp.getDate();
      let mm = this.timestamp.getMonth();
      let yy = this.timestamp.getFullYear();
      return '[Transaction: ${dd}/${mm}/${yy}] ${this.from} Gives ${this.amount} to ${this.to}';
    }
}

class Person {
    constructor(name) {
      this.name = name;
      this._transactions = [];
    }

    transfer(amount, to) {
      let t = new Transaction(amount, this, to);
      this._transactions.push(t);
    }

    transactions() {
      return this._transactions;
    }

    toString() {
      return '${this.name.charAt(0).toUpperCase() + this.name.slice(1)}';
    }
}


function history(transactions, user) {
  return transactions.filter((t) => {
    return t.to.name === user.name || t.from.name === user.name;
  });
}


let amy = new Person('amy');
let foo = new Person('foo');
amy.transfer(500, foo);
amy.transfer(500, foo);
foo.transfer(200, amy);

for (let t of amy.transactions()) {
  console.log('Transaction by AMY');
  console.log(t);
}

for (let f of foo.transactions()) {
  console.log('Transaction by FOO');
  console.log(f);
}

console.log('Transaction history');
console.log(history(trxn, amy));

Output della logica precedente:

Transaction by AMY
[Transaction: 22/10/2016] Amy Gives 500 to Foo
Transaction by AMY
[Transaction: 22/10/2016] Amy Gives 500 to Foo
Transaction by FOO
[Transaction: 22/10/2016] Foo Gives 200 to Amy
Transaction history
[Transaction: 22/10/2016] Amy Gives 500 to Foo,
[Transaction: 22/10/2016] Amy Gives 500 to Foo,
[Transaction: 22/10/2016] Foo Gives 200 to Amy

Come affrontare problemi come questi? Ho letto che basti pensare alla logica di business e non ai dettagli di implementazione, quindi nel mio codice non si fa menzione del meccanismo di consegna e di tutti.

Come posso rendere il mio codice più flessibile e robusto seguendo le pratiche OOP?