Blockchain and cryptocurrencies are revolutionizing how value is created and exchanged digitally. However, integrating decentralized systems into traditional web applications can seem daunting. Where do we even start?

Well, we’ve been there too – figuring out the whats, hows and whys behind the scenes. And we’re excited to share our learnings on building a Laravel e-commerce site that accepts crypto payments using Ethereum and Coinremitter.

Prerequisites

There are a few things we’ll need to have set up before starting our integration:

• A Laravel application with basic user authentication: We can’t accept or send payments without knowing who the user is, so we’ll assume there is a registration and login system in place.
• PHP and Laravel fundamentals: Integrating new technologies assumes familiarity with languages like PHP and frameworks like Laravel at a basic level.
• Understanding of blockchain and Ethereum basics: Concepts like decentralized networks, tokens, wallets, mining etc. will be helpful to grasp how payments flow.
• An Infura account: This will allow our application to connect to the Ethereum network without running a local node. Infura is a popular service for this.
• The Metamask browser extension or similar Ethereum wallet: Users will need a non-custodial wallet to manage their funds and interact with our DApp. For our demo, we’ll use Metamask.
• Coinremitter cryptocurrency payment plugin: Since we’re focusing on crypto as an available payment option, we’ll leverage Coinremitter to facilitate the banking/fiat side of transactions in Laravel.

With these pre-requisite tools and concepts in place, we’ll be ready to start integrating blockchain capabilities into our existing e-commerce site!

Generate Ethereum Wallet for Users

We need to generate an Ethereum wallet for each user when they sign up on our Blockchain Laravel application. To accomplish this, we leverage the web3.js JavaScript library which provides APIs to interact with the Ethereum blockchain.

Upon user registration, we call the web3.js wallet generation method to create a new Ethereum account containing a public and private key pair. The keys are then stored securely in our database and associated with that user account.

To display the wallet address to the user for receiving payments, we retrieve their public wallet address from the database and render it on their account dashboard or settings page. We may also add QR codes or wallet address copying to streamline the payment process for users.

Proper key management is critical, so measures like encryption, access control and key rotation policies must be implemented to safeguard users’ wallets. Overall, with web3.js we can integrate non-custodial Ethereum wallets into our Laravel application to provide users full control over their funds. Here is a demo How to do it:

// Import web3.js 

const Web3 = require('web3');

// On user registration

function registerUser(request) {

// Instantiate web3 object with provider

const web3 = new Web3(new Web3.providers.HttpProvider('https://mainnet.infura.io/v3/{yourApiKey}'));

// Generate a new wallet

const wallet = web3.eth.accounts.create();

// Get public address 

const address = wallet.address;

// Get private key

const privateKey = wallet.privateKey;

// Securely store keys in database

DB::table('users')->insert([

'name' => $request->name,

'address' => $address,

'private_key' => encrypt($privateKey) 

]);

// Return address to display on profile

return response()->json(['address' => $address]);

}

Also Read: Laravel REST API For Ecommerce

Accepting Cryptocurrency Payments with Coinremitter

To accept crypto payments on our Laravel site, we will use the Coinremitter plugin. It simplifies the process while still allowing us to utilize cryptocurrencies.

Installation and Configuration

1. Install Coinremitter via Composer:

   composer require coinremitter/laravel

2. Add the service provider to config/app.php:

   Coinremitter\CoinremiterServiceProvider::class

3. Publish config file:

   php artisan vendor:publish --provider="Coinremitter\CoinremiterServiceProvider"

4. Configure credentials in config/coinremitter.php for desired coins like BTC, ETH.
5. Get API keys and passwords from your Coinremitter account.

Library Usage

1. Add namespace use Coinremitter\Coinremitter;
2. Create wallet objects:

   $btcWallet = new Coinremitter('ETH');

3. Get balance:

   $balance = $btcWallet->get_balance();

4. Send/receive coins by calling methods like:

   $btcWallet->send_coins()
   $btcWallet->receive_coins()

5. See transactions via $btcWallet->get_transactions()

Now our Laravel site can leverage Coinremitter’s APIs to accept and process cryptocurrency payments seamlessly.

Also Read: Best Laravel Development Tools

Accept Ethereum Payments

To accept Ethereum payments in our Laravel application, we need to setup a payment gateway like Coinbase Commerce which generates invoices and notifies us of payments.

First, we create a route in Laravel to receive webhooks from the payment gateway when an invoice is paid. Within the route handler, we verify the authenticity of the webhook request before processing.

Next, we confirm the payment on the Ethereum blockchain by checking that the specified transaction hash exists and is successful. This acts as a final precaution before considering the payment as valid.

Once the payment is verified on-chain, we can process the order in Laravel, such as delivering products or granting access. By only accepting payments after blockchain confirmation, we ensure transactions are immutable and avoid double-spending risks.

Overall, the combination of a reputed payment gateway and on-chain verification creates a streamlined yet secure platform for accepting Ethereum payments.

Also Read: Laravel Mail Message Template

Send Transactions via Laravel

To send Ethereum transactions like payments or contract calls from our Laravel backend, we integrate a specialized library like web3.php. It provides a wrapper to interact with Ethereum nodes using PHP.

Within our Laravel app, we fetch the user’s private key securely from the database to sign transactions on their behalf. The web3.php library handles creating the raw transaction, signing it cryptographically and broadcasting to the network.

First, require the composer package:

composer require web3php/web3.php

Then in our controller:

use Web3php\Web3;

// Connect to Ethereum node 

$web3 = new Web3(new Web3\Providers\HttpProvider('https://mainnet.infura.io/v3/{project_id}'));

// Transfer tokens function

function transferTokens($fromAddr, $toAddr, $amount) {

// Fetch private key from DB

$privateKey = DB::table('users')->where('address', $fromAddr)->value('private_key');

// Build transaction 

$tx = [

'from' => $fromAddr, 

'to' => $toAddr,

'value' => $web3->toWei($amount, 'ether') 

];

// Sign with private key

$signedTx = $web3->eth->account()->signTransaction($tx, $privateKey);

// Send raw tx

$web3->eth->sendRawTransaction($signedTx->raw);

}

// Execute a smart contract method

function callContractMethod() {

//...

}

Also Read: Laravel and Flutter for Ecommerce

Monitor Ethereum Network

To provide a dynamic user experience, we need to monitor the Ethereum network in real-time from our Laravel application backend. We can achieve this by connecting to Ethereum nodes using WebSockets.

We implement event listeners for new blocks and pending transactions using web3.js subscriptions. Then we can notify users of incoming payments to their wallet address by matching transaction recipients with our user addresses.

As new blocks arrive, we can update account balances by extracting the latest state from the chain. We can also maintain a transaction history by storing all activities associated with user accounts on our database.

Also Read: Laravel Nova Vs Filament

Store Transaction Data

To enable reporting and analytics, we need to store transaction data from the Ethereum blockchain in our Laravel application’s database.

We leverage web3.js library’s APIs to extract transaction details like amount, sender, recipient, contract addresses etc. These are logged in our local database linked to the associated user account.

// Extract transaction details 

$tx = web3->eth->getTransaction($txHash);

// Log to database

DB::table('transactions')->insert([

'user_id' => $user->id,

'tx_hash' => $txHash, 

'from' => $tx['from'],

'to' => $tx['to'],

'amount' => $tx['value']

]);

We also update user balances by getting their latest token holdings from contract state. To avoid redundant queries, we synchronize balances to the database periodically instead of on every new block.

By storing transaction history and balances locally, we enable optimized lookups and queries for analytics, saving on-chain requests. We can also build user dashboards with tables of transactions and profile summaries.

Also Read: Intro to Laravel Nova

Testing the Integration

Rigorous testing is essential before deploying our Ethereum integrated Laravel app to production. We leverage testnets like Ropsten to simulate the live environment.

For core functionality, we write automated PHPUnit tests that run transactions, contract calls etc. and assert the expected behavior. We cover success cases as well as failure scenarios like insufficient funds.

We also conduct manual testing across different wallets like Metamask, hardware wallets, etc. to gauge real-world user experience. Exploratory manual testing helps uncover inconsistencies and UX issues.

Thorough testing provides confidence in our solution and allows us to identify and rectify problems early before subjecting users. We continue periodically testing even post-deployment to account for evolving platform conditions.

Also Read: Laravel Filament vs Backpack

Security Considerations

Security should be the foremost priority when developing blockchain integrations. We follow best practices like:

• Storing API keys and user private keys encrypted in the database with tightly scoped access.
• Using nonces and gas limits appropriately to prevent replays.
• Following established smart contract security guidelines like known vulnerability checks.
• Conducting external security audits on our smart contract logic.
• Monitoring transactions, balances and activities for anomalies indicating potential exploits.

A proactive approach to security coupled with internal and third-party auditing minimizes risk when handling cryptocurrency transactions while instilling confidence in users.

Also Read: Filament vs Orchid

Final Thoughts

While the technical integration required effort, breaking it down step-by-step made the process feel achievable. Our goal was not to cover every facet, but rather demonstrate the possibilities and build confidence in approaches once viewed as complex.

For organizations seeking to evolve their platforms, evaluating emerging technologies takes time. Outsourcing aspects to experts affords flexibility – whether augmenting in-house teams or outsourcing their Custom Laravel Development Project.

As a leader in bespoke Laravel development, Hybrid Web Agency is uniquely positioned to assist at any point on that journey. Through our flexible staffing models, clients have full transparency into how their projects are delivered, while retaining control over deadlines and budgets.

Hybrid’s skilled Laravel engineers stay up-to-date on innovations like those explored here. We welcome discussing your vision and requirements and how technical execution can advance your strategic objectives.