Integrating Laravel 11 with Blockchain for Decentralized Applications

Hello, laravel web developers! In this guide, I’ll show you how to integrate Laravel 11 with blockchain technology to build decentralized applications (DApps). Blockchain can transform how applications handle data and transactions, ensuring security, transparency, and decentralization.

I’ll walk you through interacting with smart contracts and managing blockchain transactions using Laravel. Don’t worry if you're new to blockchain — I’ll make this as simple as possible!

First, ensure your Laravel environment is set up. If you haven't installed Laravel 11 yet, use Composer to install it.

composer create-project --prefer-dist laravel/laravel blockchain-app

 Next, you’ll need to install the web3.php library to interact with Ethereum-based blockchains.

composer require sc0vu/web3.php

This library allows us to interact with Ethereum smart contracts and manage blockchain transactions directly from our Laravel application.

 Add the blockchain-related environment variables to your env file. For instance, if you are using an Ethereum network like Ropsten, you need the provider URL and a private key for signing transactions.

BLOCKCHAIN_PROVIDER=https://ropsten.infura.io/v3/YOUR_INFURA_PROJECT_ID
WALLET_PRIVATE_KEY=your_ethereum_wallet_private_key
CONTRACT_ADDRESS=0xYourSmartContractAddress

 Next, create a service class to manage blockchain interactions. This service will help us connect to the Ethereum blockchain, interact with smart contracts, and execute transactions.

app/Services/BlockchainService.php

namespace App\Services;

use Web3\Web3;
use Web3\Contract;

class BlockchainService
{
    protected $web3;
    protected $contract;

    public function __construct()
    {
        $provider = env('BLOCKCHAIN_PROVIDER');
        $this->web3 = new Web3($provider);
        $contractAddress = env('CONTRACT_ADDRESS');
        $abi = '[YOUR_CONTRACT_ABI]'; // Replace with your contract's ABI

        $this->contract = new Contract($provider, $abi);
        $this->contract->at($contractAddress);
    }

    // Example: Call a smart contract function
    public function callSmartContractFunction($functionName, $params)
    {
        $result = null;
        $this->contract->call($functionName, $params, function ($err, $res) use (&$result) {
            if ($err !== null) {
                throw new \Exception($err->getMessage());
            }
            $result = $res;
        });

        return $result;
    }

    // Example: Send a transaction to the blockchain
    public function sendTransaction($functionName, $params)
    {
        $privateKey = env('WALLET_PRIVATE_KEY');
        $result = null;

        $this->contract->send('sendTransaction', $functionName, $params, [
            'from' => $this->web3->eth->coinbase(),
            'gas' => '0x76c0', // 30400 gas limit
            'gasPrice' => '0x9184e72a000', // 10000000000000
        ], function ($err, $res) use (&$result) {
            if ($err !== null) {
                throw new \Exception($err->getMessage());
            }
            $result = $res;
        });

        return $result;
    }
}

Now that we have a service to interact with the blockchain, let's create a controller to handle user requests. We’ll also define routes for these actions.

routes/web.php

use App\Http\Controllers\BlockchainController;

Route::get('/smart-contract-call', [BlockchainController::class, 'callSmartContract']);
Route::post('/send-transaction', [BlockchainController::class, 'sendTransaction']);

Next, create the controller that uses the BlockchainService to interact with the blockchain.

app/Http/Controllers/BlockchainController.php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Services\BlockchainService;

class BlockchainController extends Controller
{
    protected $blockchainService;

    public function __construct(BlockchainService $blockchainService)
    {
        $this->blockchainService = $blockchainService;
    }

    // Call a smart contract function
    public function callSmartContract()
    {
        $response = $this->blockchainService->callSmartContractFunction('getValue', []);
        return response()->json($response);
    }

    // Send a transaction
    public function sendTransaction(Request $request)
    {
        $response = $this->blockchainService->sendTransaction('setValue', [$request->value]);
        return response()->json($response);
    }
}

You can now test your blockchain interactions. For example, call the smart contract function:

http://your-laravel-app.test/smart-contract-call

To send a blockchain transaction, send a POST request to /send-transaction with the appropriate value:

POST http://your-laravel-app.test/send-transaction
{
    "value": 42
}

You might also like:

• Read Also: Implementing CQRS (Command Query Responsibility Segregation) in Laravel 11
• Read Also: Optimizing Laravel 11 for Serverless Deployment on AWS Lambda
• Read Also: How To Check Image Blur Or Not Using Python
• Read Also: How To Run Python Script In Laravel 9