New accounting

src/main/java/org/core/eco/CurrencyManager.java

@@ -1,10 +1,8 @@
 package org.core.eco;
 
-import org.core.TranslateCore;
 import org.core.entity.living.human.player.User;
-import org.core.source.eco.Account;
-import org.core.source.eco.NamedAccount;
-import org.core.source.eco.PlayerAccount;
+import org.core.eco.account.NamedAccount;
+import org.core.eco.account.PlayerAccount;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Collection;

src/main/java/org/core/eco/account/Account.java

@@ -0,0 +1,48 @@
+package org.core.eco.account;
+
+import org.core.TranslateCore;
+import org.core.eco.Currency;
+import org.core.eco.transaction.*;
+import org.core.eco.transaction.pending.PendingTransaction;
+import org.core.source.Source;
+import org.jetbrains.annotations.NotNull;
+
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.function.BiFunction;
+
+public interface Account extends Source {
+
+    @NotNull String getName();
+
+    @NotNull PendingTransaction transact(@NotNull Transaction transaction);
+
+    default @NotNull PendingTransaction transact(@NotNull Account other,
+                                                 BiFunction<AccountSnapshot, AccountSnapshot, List<Transaction>> transactions) {
+        return new SecureTransaction(this, other, transactions).run();
+    }
+
+    @NotNull BigDecimal getBalance(@NotNull Currency currency);
+
+    default @NotNull BigDecimal getBalance() {
+        return this.getBalance(TranslateCore.getCurrencyManager().getDefaultCurrency());
+    }
+
+    default PendingTransaction deposit(@NotNull Currency currency, @NotNull Number amount) {
+        return this.transact(new DepositTransaction(this, currency,
+                                                    amount instanceof BigDecimal ? (BigDecimal) amount : BigDecimal.valueOf(
+                                                            amount.doubleValue())));
+    }
+
+    default PendingTransaction withdraw(@NotNull Currency currency, @NotNull Number amount) {
+        return this.transact(new WithdrawTransaction(this, currency,
+                                                     amount instanceof BigDecimal ? (BigDecimal) amount : BigDecimal.valueOf(
+                                                             amount.doubleValue())));
+    }
+
+    default PendingTransaction setBalance(@NotNull Currency currency, @NotNull Number amount) {
+        return this.transact(new SetTransaction(this, currency,
+                                                amount instanceof BigDecimal ? (BigDecimal) amount : BigDecimal.valueOf(
+                                                        amount.doubleValue())));
+    }
+}

src/main/java/org/core/eco/account/AccountSnapshot.java

@@ -0,0 +1,57 @@
+package org.core.eco.account;
+
+import org.core.eco.Currency;
+import org.core.eco.transaction.Transaction;
+import org.core.eco.transaction.pending.PendingSingleTransactionImpl;
+import org.core.eco.transaction.pending.PendingTransaction;
+import org.jetbrains.annotations.NotNull;
+
+import java.math.BigDecimal;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+
+public class AccountSnapshot implements Account {
+
+    private final Account account;
+    private Map<Currency, BigDecimal> cachedAmount = new HashMap<>();
+
+    public AccountSnapshot(Account account) {
+        this.account = account;
+    }
+
+    @Override
+    public @NotNull String getName() {
+        return this.account.getName();
+    }
+
+    @Override
+    public @NotNull PendingTransaction transact(@NotNull Transaction transaction) {
+        switch (transaction.getType()) {
+            case DEPOSIT -> {
+                BigDecimal current = cachedAmount.get(transaction.getCurrency());
+                if(current == null){
+                    current = account.getBalance(transaction.getCurrency());
+                }
+                cachedAmount.put(transaction.getCurrency(), current.add(transaction.getAmount()));
+                return new PendingSingleTransactionImpl(this, transaction, CompletableFuture.completedFuture());
+            }
+            case WITHDRAW -> {
+            }
+            case SET -> {
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public @NotNull BigDecimal getBalance(@NotNull Currency currency) {
+        BigDecimal amount = this.cachedAmount.get(currency);
+        if (amount != null) {
+            return amount;
+        }
+        amount = this.account.getBalance(currency);
+        this.cachedAmount.put(currency, amount);
+        return amount;
+    }
+}

src/main/java/org/core/source/eco/NamedAccount.java → src/main/java/org/core/eco/account/NamedAccount.java

@@ -1,4 +1,4 @@
-package org.core.source.eco;
+package org.core.eco.account;
 
 public interface NamedAccount extends Account {
 

src/main/java/org/core/source/eco/PlayerAccount.java → src/main/java/org/core/eco/account/PlayerAccount.java

@@ -1,6 +1,5 @@
-package org.core.source.eco;
+package org.core.eco.account;
 
-import org.core.entity.living.human.player.User;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.UUID;

src/main/java/org/core/eco/transaction/AbstractTransaction.java

@@ -0,0 +1,27 @@
+package org.core.eco.transaction;
+
+import org.core.eco.Currency;
+import org.jetbrains.annotations.NotNull;
+
+import java.math.BigDecimal;
+
+class AbstractTransaction implements Transaction {
+
+    private final Currency currency;
+    private final BigDecimal amount;
+
+    AbstractTransaction(Currency currency, BigDecimal amount) {
+        this.amount = amount;
+        this.currency = currency;
+    }
+
+    @Override
+    public @NotNull Currency getCurrency() {
+        return this.currency;
+    }
+
+    @Override
+    public @NotNull BigDecimal getAmount() {
+        return this.amount;
+    }
+}

src/main/java/org/core/eco/transaction/SecureTransaction.java

@@ -0,0 +1,26 @@
+package org.core.eco.transaction;
+
+import org.core.eco.account.Account;
+import org.core.eco.transaction.pending.PendingTransaction;
+
+import java.util.Collection;
+import java.util.function.BiFunction;
+
+public class SecureTransaction {
+
+    private Account target;
+    private Account other;
+    private BiFunction<Account, Account, Collection<PendingTransaction>> transactions;
+
+    public SecureTransaction(Account target,
+                             Account other,
+                             BiFunction<Account, Account, Collection<PendingTransaction>> transactions) {
+        this.target = target;
+        this.other = other;
+        this.transactions = transactions;
+    }
+
+    public PendingTransaction run() {
+
+    }
+}

src/main/java/org/core/eco/transaction/Transaction.java

@@ -0,0 +1,16 @@
+package org.core.eco.transaction;
+
+import org.core.eco.Currency;
+import org.jetbrains.annotations.NotNull;
+
+import java.math.BigDecimal;
+
+public interface Transaction {
+
+    @NotNull Currency getCurrency();
+
+    @NotNull BigDecimal getAmount();
+
+    @NotNull TransactionType getType();
+
+}

src/main/java/org/core/eco/transaction/TransactionType.java

@@ -0,0 +1,8 @@
+package org.core.eco.transaction;
+
+public enum TransactionType {
+
+    DEPOSIT,
+    WITHDRAW,
+    SET
+}

src/main/java/org/core/eco/transaction/pending/PendingSingleTransaction.java

@@ -0,0 +1,21 @@
+package org.core.eco.transaction.pending;
+
+import org.core.eco.transaction.Transaction;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public interface PendingSingleTransaction extends PendingTransaction {
+
+    @NotNull Transaction getTransaction();
+
+    @Override
+    @Deprecated
+    default @NotNull List<Transaction> getRemainingTransactions() {
+        if (this.isComplete()) {
+            return Collections.emptyList();
+        }
+        return Collections.singletonList(this.getTransaction());
+    }
+}

src/main/java/org/core/eco/transaction/pending/PendingSingleTransactionImpl.java

@@ -0,0 +1,62 @@
+package org.core.eco.transaction.pending;
+
+import org.core.eco.account.Account;
+import org.core.eco.transaction.Transaction;
+import org.core.eco.transaction.result.TransactionResult;
+import org.core.eco.transaction.result.TransactionsResult;
+import org.core.eco.transaction.result.impl.TransactionsResultImpl;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public class PendingSingleTransactionImpl implements PendingSingleTransaction {
+
+    private final Account account;
+    private final Transaction transaction;
+    private final List<TransactionResult> result = new ArrayList<>();
+    private final CompletableFuture<TransactionResult> future;
+
+    public PendingSingleTransactionImpl(Account account,
+                                        Transaction transaction,
+                                        CompletableFuture<TransactionResult> future) {
+        this.future = future.thenApply(result -> {
+            this.result.add(result);
+            return result;
+        });
+        this.transaction = transaction;
+        this.account = account;
+    }
+
+
+    @Override
+    public @NotNull Transaction getTransaction() {
+        return this.transaction;
+    }
+
+    @Override
+    public @NotNull Account getTarget() {
+        return this.account;
+    }
+
+    @Override
+    public @NotNull TransactionsResult getCurrentResult() {
+        return new TransactionsResultImpl(this.result);
+    }
+
+    @Override
+    public @NotNull CompletableFuture<TransactionResult> awaitCurrentTransaction() {
+        return this.future;
+    }
+
+    @Override
+    public @NotNull CompletableFuture<TransactionsResult> awaitComplete() {
+        return this.awaitCurrentTransaction().thenApply(t -> this.getCurrentResult());
+    }
+
+    @Override
+    public boolean isComplete() {
+        return !this.result.isEmpty();
+    }
+}

src/main/java/org/core/eco/transaction/pending/PendingTransaction.java

@@ -0,0 +1,37 @@
+package org.core.eco.transaction.pending;
+
+import org.core.eco.account.Account;
+import org.core.eco.transaction.Transaction;
+import org.core.eco.transaction.result.TransactionResult;
+import org.core.eco.transaction.result.TransactionsResult;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+public interface PendingTransaction {
+
+    @NotNull List<Transaction> getRemainingTransactions();
+
+    @NotNull Account getTarget();
+
+    @NotNull TransactionsResult getCurrentResult();
+
+    @NotNull CompletableFuture<TransactionResult> awaitCurrentTransaction();
+
+    @NotNull CompletableFuture<TransactionsResult> awaitComplete();
+
+    boolean isComplete();
+
+    default Optional<Transaction> getCurrentTransaction() {
+        List<Transaction> remaining = this.getRemainingTransactions();
+        if (remaining.isEmpty()) {
+            return Optional.empty();
+        }
+        return Optional.of(remaining.get(0));
+    }
+
+    ;
+
+}