MoeCasts / laravel-wallet

src/Models/Wallet.php

<?php

namespace Moecasts\Laravel\Wallet\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\MorphMany;
use Illuminate\Database\Eloquent\Relations\MorphTo;
use Illuminate\Support\Facades\DB;
use Moecasts\Laravel\Wallet\Exceptions\AmountInvalid;
use Moecasts\Laravel\Wallet\Exceptions\ExchangeInvalid;
use Moecasts\Laravel\Wallet\Exceptions\InsufficientFunds;
use Moecasts\Laravel\Wallet\Interfaces\Assemblable;
use Moecasts\Laravel\Wallet\Interfaces\Exchangeable;
use Moecasts\Laravel\Wallet\Interfaces\Transferable;
use Moecasts\Laravel\Wallet\Models\Transaction;
use Moecasts\Laravel\Wallet\Tax;
use Moecasts\Laravel\Wallet\Traits\CanPay;
use Moecasts\Laravel\Wallet\WalletProxy;
use Ramsey\Uuid\Uuid;

class Wallet extends Model
{
    use CanPay;

The trait Moecasts\Laravel\Wallet\Traits\CanPay requires some properties which are not provided by Moecasts\Laravel\Wallet\Models\Wallet: $withdraw, $deposit, $fromWallet, $toWallet

    protected $fillable = [
        'holder_type',
        'holder_id',
        'currency',
        'balance'
    ];

    public function holder(): MorphTo
    {
        return $this->morphTo();
    }

    public function transactions(): HasMany
    {
        return $this->hasMany(Transaction::class);
    }

    public function holderTransfers(): MorphMany
    {
        return $this->holder->transfers();
    }

    public function transfers(): HasMany
    {
        return $this->hasMany(Transfer::class, 'from_wallet_id');
    }

    public function deposit(float $amount, ?array $meta = null, bool $confirmed = true): Transaction
    {
        $this->checkAmount($amount);

$amount of type double is incompatible with the type integer expected by parameter $amount of Moecasts\Laravel\Wallet\Models\Wallet::checkAmount().

        $amount = (int) ($amount * $this->coefficient($this->currency));

        return $this->change(Transaction::TYPE_DEPOSIT, $amount, $meta, $confirmed);
    }

    private function checkAmount(int $amount): void
    {
        if ($amount < 0) {
            throw new AmountInvalid(trans('wallet::errors.price_positive'));

It seems like trans('wallet::errors.price_positive') can also be of type array; however, parameter $message of Moecasts\Laravel\Wallet\Exceptions\AmountInvalid::__construct() does only seem to accept string, maybe add an additional type check?

        }
    }

    protected function change(string $type, int $amount, ?array $meta, bool $confirmed): Transaction
    {
        return DB::transaction(function () use ($type, $amount, $meta, $confirmed) {
            if ($confirmed) {
                $this->addBalance($amount);
            }

            return $this->transactions()->create([
                'type' => $type,
                'holder_type' => $this->holder->getMorphClass(),
                'holder_id' => $this->holder->getKey(),
                'wallet_id' => $this->getKey(),
                'uuid' => Uuid::uuid4()->toString(),
                'confirmed' => $confirmed,
                'amount' => $amount,
                'meta' => $meta,
            ]);
        });
    }

    protected function addBalance(float $amount): bool
    {
        $newBalance = $this->attributes['balance'] + $amount;
        $this->balance = $newBalance;
        $finalBalance = $newBalance / $this->coefficient($this->attributes['currency']);

        return
            // update database wallet
            $this->save() &&

            // update static wallet
            WalletProxy::set($this->getKey(), $finalBalance);
    }

    public function getBalanceAttribute(): float
    {
        $this->exists or $this->save();

        if (! WalletProxy::has($this->getKey())) {
            $balance = $this->attributes['balance'] / $this->coefficient($this->attributes['currency']);
            WalletProxy::set($this->getKey(), (float) ($balance ?? 0));
        }

        return WalletProxy::get($this->getKey());
    }

    public function safeTransfer(Transferable $transferable, float $amount, ?array $meta = null, string $action = Transfer::ACTION_TRANSFER): ?Transfer
    {
        try {
            return $this->transfer($transferable, $amount, $meta, $action);
        } catch (\Throwable $throwable) {
            return null;
        }
    }

    public function transfer(Transferable $transferable, float $amount, ?array $meta = null, string $action = Transfer::ACTION_TRANSFER): Transfer
    {
        $wallet = $transferable->getReceiptWallet($this->currency);

        return DB::transaction(function () use ($transferable, $amount, $wallet, $meta, $action) {
            $fee = Tax::fee($transferable, $wallet, $amount);
            $withdraw = $this->withdraw($amount + $fee, $meta);
            $deposit = $wallet->deposit($amount, $meta);
            return $this->assemble($transferable, $wallet, $withdraw, $deposit, $action);
        });
    }

    public function withdraw(float $amount, ?array $meta = null, bool $confirmed = true): Transaction
    {
        if (! $this->canWithdraw($amount)) {
            throw new InsufficientFunds(trans('wallet::errors.insufficient_funds'));

It seems like trans('wallet::errors.insufficient_funds') can also be of type array; however, parameter $message of Moecasts\Laravel\Wallet\Exceptions\InsufficientFunds::__construct() does only seem to accept string, maybe add an additional type check?

        }

        return $this->forceWithdraw($amount, $meta, $confirmed);
    }

    public function canWithdraw($amount): bool
    {
        return $this->balance >= $amount;
    }

    public function forceWithdraw(float $amount, ?array $meta = null, bool $confirmed = true): Transaction
    {
        $amount = (int) ($amount * $this->coefficient($this->currency));

        $this->checkAmount($amount);

        return $this->change(Transaction::TYPE_WITHDRAW, -$amount, $meta, $confirmed);
    }

    protected function assemble(Assemblable $transferable, Wallet $wallet, Transaction $withdraw, Transaction $deposit, string $action = Transfer::ACTION_PAID): Transfer
    {
        return \app('moecasts.wallet::transfer')->create([

The method create() does not exist on Illuminate\Contracts\Foundation\Application.

            'action' => $action,
            'deposit_id' => $deposit->getKey(),
            'withdraw_id' => $withdraw->getKey(),
            'from_type' => $this->holder->getMorphClass(),
            'from_id' => $this->holder->getKey(),
            'from_wallet_id' => $this->getKey(),
            'to_type' => $transferable->getMorphClass(),

The method getMorphClass() does not exist on Moecasts\Laravel\Wallet\Interfaces\Assemblable. It seems like you code against a sub-type of said class. However, the method does not exist in Moecasts\Laravel\Wallet\Interfaces\Transferable or Moecasts\Laravel\Wallet\Interfaces\Exchangeable or Moecasts\Laravel\Wallet\Interfaces\Product. Are you sure you never get one of those?

            'to_id' => $transferable->getKey(),

The method getKey() does not exist on Moecasts\Laravel\Wallet\Interfaces\Assemblable. It seems like you code against a sub-type of said class. However, the method does not exist in Moecasts\Laravel\Wallet\Interfaces\Transferable or Moecasts\Laravel\Wallet\Interfaces\Exchangeable or Moecasts\Laravel\Wallet\Interfaces\Product. Are you sure you never get one of those?

            'to_wallet_id' => $wallet->getKey(),
            'fee' => \abs($withdraw->amount) - \abs($deposit->amount),
            'uuid' => Uuid::uuid4()->toString(),
        ]);
    }

    public function forceTransfer(Transferable $transferable, float $amount, ?array $meta = null, string $action = Transfer::ACTION_TRANSFER): Transfer
    {
        $wallet = $transferable->getReceiptWallet($this->currency);

        return DB::transaction(function () use ($transferable, $amount, $wallet, $meta, $action) {
            $fee = Tax::fee($transferable, $wallet, $amount);
            $withdraw = $this->forceWithdraw($amount + $fee, $meta);
            $deposit = $wallet->deposit($amount, $meta);
            return $this->assemble($transferable, $wallet, $withdraw, $deposit, $action);
        });
    }

    public function exchange(string $currency, float $amount, ?array $meta = null, $action = Transfer::ACTION_EXCHANGE): Transfer
    {
        $wallet = $this->holder->getWallet($currency);

        $exchangeRate = config('wallet.exchange.' . $this->currency . '.' . $currency);

        if (! $exchangeRate ||
            ! $this->holder instanceof Exchangeable) {
            throw new ExchangeInvalid(trans('wallet::errors.exchange_unsupported'));

It seems like trans('wallet::errors.exchange_unsupported') can also be of type array; however, parameter $message of Moecasts\Laravel\Wallet\Exceptions\ExchangeInvalid::__construct() does only seem to accept string, maybe add an additional type check?

        }

        $exchangedAmount = $amount * $exchangeRate;

        return DB::transaction(function () use ($wallet, $amount, $exchangedAmount, $meta, $action) {
            $fee = Tax::fee($this->holder, $wallet, $amount);
            $withdraw = $this->withdraw($amount + $fee, $meta);
            $deposit = $wallet->deposit($exchangedAmount, $meta);
            return $this->assemble($this->holder, $wallet, $withdraw, $deposit, $action);
        });
    }

    public function safeExchange(string $currency, float $amount, ?array $meta = null, $action = Transfer::ACTION_EXCHANGE): ?Transfer
    {
        try {
            return $this->exchange($currency, $amount, $meta, $action);
        } catch (\Throwable $throwable) {
            return null;
        }
    }

    public function forceExchange(string $currency, float $amount, ?array $meta = null, $action = Transfer::ACTION_EXCHANGE): Transfer
    {
        $wallet = $this->holder->getWallet($currency);

        $exchangeRate = config('wallet.exchange.' . $this->currency . '.' . $currency);

        if (! $exchangeRate ||
            ! $this->holder instanceof Exchangeable) {
            throw new ExchangeInvalid(trans('wallet::errors.exchange_unsupported'));

It seems like trans('wallet::errors.exchange_unsupported') can also be of type array; however, parameter $message of Moecasts\Laravel\Wallet\Exceptions\ExchangeInvalid::__construct() does only seem to accept string, maybe add an additional type check?

        }

        $exchangedAmount = $amount * $exchangeRate;

        return DB::transaction(function () use ($wallet, $amount, $exchangedAmount, $meta, $action) {
            $fee = Tax::fee($this->holder, $wallet, $amount);
            $withdraw = $this->forceWithdraw($amount + $fee, $meta);
            $deposit = $wallet->deposit($exchangedAmount, $meta);
            return $this->assemble($this->holder, $wallet, $withdraw, $deposit, $action);
        });
    }

    public function refreshBalance(): bool
    {
        $balance = $this->getAvailableBalance();

        $this->attributes['balance'] = $balance;

        WalletProxy::set($this->getKey(), $balance);

        return $this->save();
    }

    public function getAvailableBalance(): int
    {
        return $this->transactions()
            ->where('wallet_id', $this->getKey())
            ->where('confirmed', true)
            ->sum('amount');
    }

    public function coefficient(string $currency = ''): float
    {
        return config('wallet.coefficient.' . $currency , 100.);
    }
}