Modelando um gerenciador de contas em OOP

Eu tenho essa tarefa de modelar um sistema onde, dado um grupo de usuários, cada um pode acompanhar suas despesas. Os requisitos básicos são os seguintes:

1. Para poder dar crédito a um usuário.
2. Encontre todas as transações de um determinado usuário.
3. Filtre a transação em que um dos usuários é mutuário ou gastador.
4. Crie um grupo e coloque usuários nesse grupo e, quando um grupo for mencionado, distribua o dinheiro igualmente entre eles. [TODO]

Eu tentei algumas coisas, mas não estou convencido.

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));

Saída da lógica acima:

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

Como abordar problemas como esses? Eu li que apenas pensar sobre a lógica de negócios e não sobre os detalhes de implementação, portanto, no meu código não há menção de mecanismo de entrega e tudo mais.

Como posso tornar meu código mais flexível e robusto seguindo as práticas de POO?