Creating a wallet system in Laravel can be a fantastic way to manage user balances, handle transactions, and build more complex financial features into your application. Whether you're building an e-commerce platform, a gaming app with in-game currency, or a fintech solution, a robust wallet system is crucial. In this guide, we'll walk you through the process of setting up a basic wallet system in Laravel, covering everything from database design to implementing key functionalities. So, let's dive in and get started!

Setting Up Your Laravel Project

First things first, you need to have a Laravel project up and running. If you don't already have one, you can create a new project using the Laravel installer or Composer. Open your terminal and run the following command:

composer create-project --prefer-dist laravel/laravel wallet-app
cd wallet-app

This command creates a new Laravel project named wallet-app. Once the project is created, navigate into the project directory.

Configuring the Database

Next, you need to configure your database. Open the .env file in your project and update the database connection details. Here’s an example:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=wallet_db
DB_USERNAME=your_username
DB_PASSWORD=your_password

Make sure you have a MySQL database set up with the specified name, username, and password. After updating the .env file, you can run the migrations to create the necessary tables.

Creating the Wallet Model and Migration

Now, let's create the Wallet model and migration. This model will represent the wallet in our application, and the migration will create the corresponding database table. Run the following command in your terminal:

php artisan make:model Wallet -m

This command creates both a Wallet model in the app/Models directory and a migration file in the database/migrations directory. Open the migration file (it will have a timestamp in its name) and update the up method to define the table schema:

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateWalletsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('wallets', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('user_id');
            $table->decimal('balance', 15, 2)->default(0.00);
            $table->timestamps();

            $table->foreign('user_id')->references('id')->on('users')->onDelete('cascade');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('wallets');
    }
}

In this schema, we have the following fields:

• id: The primary key for the wallet.
• user_id: The ID of the user who owns the wallet. This is a foreign key referencing the users table.
• balance: The current balance of the wallet, stored as a decimal with 15 digits and 2 decimal places.
• timestamps: Laravel's default created_at and updated_at timestamps.

Important Considerations: The balance field is defined as a decimal to ensure accuracy when dealing with financial data. Always use decimals for monetary values to avoid floating-point precision issues.

Now, open the Wallet model (app/Models/Wallet.php) and define the relationship with the User model:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Wallet extends Model
{
    use HasFactory;

    protected $fillable = [
        'user_id',
        'balance',
    ];

    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

Here, we've defined a user relationship using the belongsTo method, indicating that a wallet belongs to a user. We've also specified the fillable property to allow mass assignment for the user_id and balance fields.

Running the Migrations

With the model and migration set up, run the migrations to create the wallets table in your database:

php artisan migrate

This command executes all pending migrations, including the one we just created for the wallets table. Verify that the table has been created in your database.

Implementing Wallet Functionality

Now that we have the basic setup, let's implement the core functionality for our wallet system. This includes creating wallets, depositing funds, withdrawing funds, and checking the balance.

Creating Wallets

To create a wallet for a user, you can use the following code snippet:

use App\Models\User;
use App\Models\Wallet;

// Assuming you have a user instance
$user = User::find(1);

// Create a new wallet for the user
$wallet = new Wallet([
    'user_id' => $user->id,
    'balance' => 0.00, // Initial balance
]);

$user->wallet()->save($wallet);

echo "Wallet created for user: " . $user->name;

In this example, we're creating a new wallet for a user with an initial balance of 0.00. We're using the wallet relationship (which we'll define in the User model shortly) to save the wallet.

Open the User model (app/Models/User.php) and add the wallet relationship:

<?php

namespace App\Models;

use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Sanctum\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;

    /**
     * The attributes that are mass assignable.
     *
     * @var array<int, string>
     */
    protected $fillable = [
        'name',
        'email',
        'password',
    ];

    /**
     * The attributes that should be hidden for serialization.
     *
     * @var array<int, string>
     */
    protected $hidden = [
        'password',
        'remember_token',
    ];

    /**
     * The attributes that should be cast.
     *
     * @var array<string, string>
     */
    protected $casts = [
        'email_verified_at' => 'datetime',
    ];

    public function wallet()
    {
        return $this->hasOne(Wallet::class);
    }
}

Here, we've defined a wallet relationship using the hasOne method, indicating that a user has one wallet.

Depositing Funds

To deposit funds into a wallet, you can create a method in the Wallet model. This method will update the wallet's balance. Here’s how:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Wallet extends Model
{
    use HasFactory;

    protected $fillable = [
        'user_id',
        'balance',
    ];

    public function user()
    {
        return $this->belongsTo(User::class);
    }

    public function deposit($amount)
    {
        $this->balance += $amount;
        $this->save();
    }
}

Now you can deposit funds into a user's wallet like this:

use App\Models\User;

// Assuming you have a user instance
$user = User::find(1);

// Get the user's wallet
$wallet = $user->wallet;

// Deposit funds into the wallet
$wallet->deposit(100.00);

echo "Deposited 100.00 into wallet for user: " . $user->name;

Important Note: Always validate the $amount to ensure it's a positive number and handle any potential exceptions that may occur during the deposit process.

Withdrawing Funds

Similarly, to withdraw funds from a wallet, you can create a withdraw method in the Wallet model:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Wallet extends Model
{
    use HasFactory;

    protected $fillable = [
        'user_id',
        'balance',
    ];

    public function user()
    {
        return $this->belongsTo(User::class);
    }

    public function deposit($amount)
    {
        $this->balance += $amount;
        $this->save();
    }

    public function withdraw($amount)
    {
        if ($this->balance >= $amount) {
            $this->balance -= $amount;
            $this->save();
            return true;
        } else {
            return false; // Insufficient balance
        }
    }
}

Now you can withdraw funds from a user's wallet like this:

use App\Models\User;

// Assuming you have a user instance
$user = User::find(1);

// Get the user's wallet
$wallet = $user->wallet;

// Withdraw funds from the wallet
if ($wallet->withdraw(50.00)) {
    echo "Withdrew 50.00 from wallet for user: " . $user->name;
} else {
    echo "Insufficient balance to withdraw 50.00 from wallet for user: " . $user->name;
}

Important Consideration: Always check if the wallet has sufficient balance before allowing a withdrawal. Handle the case where the balance is insufficient gracefully.

Checking the Balance

To check the balance of a wallet, you can simply access the balance property of the Wallet model:

use App\Models\User;

// Assuming you have a user instance
$user = User::find(1);

// Get the user's wallet
$wallet = $user->wallet;

// Check the balance
$balance = $wallet->balance;

echo "Balance for user " . $user->name . ": " . $balance;

Adding Transactions

To keep track of all the transactions, you can create a Transaction model and table. This will allow you to log every deposit and withdrawal, providing an audit trail for your wallet system.

Creating the Transaction Model and Migration

Run the following command in your terminal:

php artisan make:model Transaction -m

This command creates both a Transaction model in the app/Models directory and a migration file in the database/migrations directory. Open the migration file and update the up method to define the table schema:

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateTransactionsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('transactions', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('wallet_id');
            $table->enum('type', ['deposit', 'withdrawal']);
            $table->decimal('amount', 15, 2);
            $table->timestamps();

            $table->foreign('wallet_id')->references('id')->on('wallets')->onDelete('cascade');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('transactions');
    }
}

In this schema, we have the following fields:

• id: The primary key for the transaction.
• wallet_id: The ID of the wallet associated with the transaction. This is a foreign key referencing the wallets table.
• type: The type of transaction (either 'deposit' or 'withdrawal').
• amount: The amount of the transaction, stored as a decimal with 15 digits and 2 decimal places.
• timestamps: Laravel's default created_at and updated_at timestamps.

Open the Transaction model (app/Models/Transaction.php) and define the relationship with the Wallet model:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Transaction extends Model
{
    use HasFactory;

    protected $fillable = [
        'wallet_id',
        'type',
        'amount',
    ];

    public function wallet()
    {
        return $this->belongsTo(Wallet::class);
    }
}

Here, we've defined a wallet relationship using the belongsTo method, indicating that a transaction belongs to a wallet. We've also specified the fillable property to allow mass assignment for the wallet_id, type, and amount fields.

Running the Migrations

With the model and migration set up, run the migrations to create the transactions table in your database:

php artisan migrate

Updating the Deposit and Withdraw Methods

Now, update the deposit and withdraw methods in the Wallet model to create a new transaction record each time funds are deposited or withdrawn:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Wallet extends Model
{
    use HasFactory;

    protected $fillable = [
        'user_id',
        'balance',
    ];

    public function user()
    {
        return $this->belongsTo(User::class);
    }

    public function deposit($amount)
    {
        $this->balance += $amount;
        $this->save();

        // Create a new transaction record
        $this->transactions()->create([
            'type' => 'deposit',
            'amount' => $amount,
        ]);
    }

    public function withdraw($amount)
    {
        if ($this->balance >= $amount) {
            $this->balance -= $amount;
            $this->save();

            // Create a new transaction record
            $this->transactions()->create([
                'type' => 'withdrawal',
                'amount' => $amount,
            ]);

            return true;
        } else {
            return false; // Insufficient balance
        }
    }

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

Here, we've added a transactions relationship using the hasMany method, indicating that a wallet has many transactions. We've also updated the deposit and withdraw methods to create a new transaction record each time funds are deposited or withdrawn.

Best Practice Tips: Implementing a transaction log is vital for maintaining the integrity and auditability of your wallet system. Always record every transaction with relevant details.

Conclusion

Creating a wallet system in Laravel involves setting up the database, defining models and relationships, and implementing the core functionality for managing balances and transactions. By following this guide, you can build a robust and reliable wallet system for your Laravel application. Remember to always validate inputs, handle exceptions, and secure your application to protect against potential vulnerabilities. Happy coding, and may your balances always be positive!