The intersection of Web3 and traditional web frameworks is where real-world utility begins. While hype cycles come and go, the utility of Non-Fungible Tokens (NFTs) for verifying ownership — specifically in event ticketing — remains a solid use case.
In this article, we will build the backbone of a Decentralized Event Ticketing System using Symfony 7.4 and PHP 8.3. We will move beyond basic tutorials and implement a production-grade architecture that handles the asynchronous nature of blockchain transactions using the Symfony Messenger component.
The Architecture
A “Senior” approach acknowledges that PHP is not a long-running process like Node.js. Therefore, we don’t listen to blockchain events in real-time within a controller. Instead, we use a hybrid approach:
- Direct Interaction (Write): We use Symfony Messenger to offload “Minting” transactions to a worker, preventing HTTP timeouts.
- RPC Polling (Read): We use scheduled commands to verify on-chain status.
- Smart Contract: We assume a standard ERC-721 contract deployed on an EVM-compatible chain (Ethereum, Polygon, Base).
Prerequisites & Stack
- PHP: 8.3+
- Symfony: 7.4 (LTS)
- Blockchain Node: Infura, Alchemy, or a local Hardhat node.
Many PHP Web3 libraries are abandoned or poorly typed. While web3p/web3.php is the most famous, strictly relying on it can be risky due to maintenance gaps.
For this guide, we will use web3p/web3.php (version ^0.3) for ABI encoding but will leverage Symfony’s native HttpClient for the actual JSON-RPC transport. This gives us full control over timeouts, retries and logging — critical for production apps.
Project Setup
First, let’s install the dependencies. We need the Symfony runtime, the HTTP client and the Web3 library.
composer create-project symfony/skeleton:"7.4.*" decentralized-ticketing
cd decentralized-ticketing
composer require symfony/http-client symfony/messenger symfony/uid web3p/web3.php
Ensure your composer.json reflects the stability:
{
"require": {
"php": ">=8.3",
"symfony/http-client": "7.4.*",
"symfony/messenger": "7.4.*",
"symfony/uid": "7.4.*",
"web3p/web3.php": "^0.3.0"
}
}
The Blockchain Service
We need a robust service to talk to the blockchain. We will create an EthereumService that wraps the JSON-RPC calls.
//src/Service/Web3/EthereumService.php
namespace App\Service\Web3;
use Symfony\Contracts\HttpClient\HttpClientInterface;
use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Web3\Utils;
class EthereumService
{
private const JSON_RPC_VERSION = '2.0';
public function __construct(
private HttpClientInterface $client,
#[Autowire(env: 'BLOCKCHAIN_RPC_URL')]
private string $rpcUrl,
#[Autowire(env: 'SMART_CONTRACT_ADDRESS')]
private string $contractAddress,
#[Autowire(env: 'WALLET_PRIVATE_KEY')]
private string $privateKey
) {}
/**
* Reads the owner of a specific Ticket ID (ERC-721 ownerOf).
*/
public function getTicketOwner(int $tokenId): ?string
{
// Function signature for ownerOf(uint256) is 0x6352211e
// We pad the tokenId to 64 chars (32 bytes)
$data = '0x6352211e' . str_pad(Utils::toHex($tokenId, true), 64, '0', STR_PAD_LEFT);
$response = $this->callRpc('eth_call', [
[
'to' => $this->contractAddress,
'data' => $data
],
'latest'
]);
if (empty($response['result']) || $response['result'] === '0x') {
return null;
}
// Decode the address (last 40 chars of the 64-char result)
return '0x' . substr($response['result'], -40);
}
/**
* Sends a raw JSON-RPC request using Symfony HttpClient.
* This offers better observability than standard libraries.
*/
private function callRpc(string $method, array $params): array
{
$response = $this->client->request('POST', $this->rpcUrl, [
'json' => [
'jsonrpc' => self::JSON_RPC_VERSION,
'method' => $method,
'params' => $params,
'id' => random_int(1, 9999)
]
]);
$data = $response->toArray();
if (isset($data['error'])) {
throw new \RuntimeException('RPC Error: ' . $data['error']['message']);
}
return $data;
}
}
Run a local test accessing getTicketOwner with a known minted ID. If you get a 0x address, your RPC connection is working.
Asynchronous Minting with Messenger
Blockchain transactions are slow (15s to minutes). Never make a user wait for a block confirmation in a browser request. We will use Symfony Messenger to handle this in the background.
The Message
//src/Message/MintTicketMessage.php:
namespace App\Message;
use Symfony\Component\Uid\Uuid;
readonly class MintTicketMessage
{
public function __construct(
public Uuid $ticketId,
public string $userWalletAddress,
public string $metadataUri
) {}
}
The Handler
This is where the magic happens. We will use the web3p/web3.php library helper to sign a transaction locally.
Note: In a high-security environment, you would use a Key Management Service (KMS) or a separate signing enclave. For this article, we sign locally.
//src/MessageHandler/MintTicketHandler.php
namespace App\MessageHandler;
use App\Message\MintTicketMessage;
use App\Service\Web3\EthereumService;
use Psr\Log\LoggerInterface;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;
use Web3\Contract;
use Web3\Providers\HttpProvider;
use Web3\RequestManagers\HttpRequestManager;
use Web3p\EthereumTx\Transaction;
#[AsMessageHandler]
class MintTicketHandler
{
public function __construct(
private EthereumService $ethereumService, // Our custom service
private LoggerInterface $logger,
#[Autowire(env: 'BLOCKCHAIN_RPC_URL')]
private string $rpcUrl,
#[Autowire(env: 'WALLET_PRIVATE_KEY')]
private string $privateKey,
#[Autowire(env: 'SMART_CONTRACT_ADDRESS')]
private string $contractAddress
) {}
public function __invoke(MintTicketMessage $message): void
{
$this->logger->info("Starting mint process for Ticket {$message->ticketId}");
// 1. Prepare Transaction Data (mintTo function)
// detailed implementation of raw transaction signing usually goes here.
// For brevity, we simulate the logic flow:
try {
// Logic to get current nonce and gas price via EthereumService
// $nonce = ...
// $gasPrice = ...
// Sign transaction offline to prevent key exposure over network
// $tx = new Transaction([...]);
// $signedTx = '0x' . $tx->sign($this->privateKey);
// Broadcast
// $txHash = $this->ethereumService->sendRawTransaction($signedTx);
// In a real app, you would save $txHash to the database entity here
$this->logger->info("Mint transaction broadcast successfully.");
} catch (\Throwable $e) {
$this->logger->error("Minting failed: " . $e->getMessage());
// Symfony Messenger will automatically retry based on config
throw $e;
}
}
}
The Controller
The controller remains thin. It accepts the request, validates the input, creates a “Pending” ticket entity in your database (omitted for brevity) and dispatches the message.
//src/Controller/TicketController.php:
namespace App\Controller;
use App\Message\MintTicketMessage;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Uid\Uuid;
#[Route('/api/v1/tickets')]
class TicketController extends AbstractController
{
#[Route('/mint', methods: ['POST'])]
public function mint(Request $request, MessageBusInterface $bus): JsonResponse
{
$payload = $request->getPayload();
$walletAddress = $payload->get('wallet_address');
// 1. Basic Validation
if (!$walletAddress || !str_starts_with($walletAddress, '0x')) {
return $this->json(['error' => 'Invalid wallet address'], 400);
}
// 2. Generate Internal ID
$ticketId = Uuid::v7();
// 3. Dispatch Message (Fire and Forget)
$bus->dispatch(new MintTicketMessage(
$ticketId,
$walletAddress,
'https://api.myapp.com/metadata/' . $ticketId->toRfc4122()
));
// 4. Respond immediately
return $this->json([
'status' => 'processing',
'ticket_id' => $ticketId->toRfc4122(),
'message' => 'Minting request queued. Check status later.'
], 202);
}
}
Configuration & Style Guide
Following the Symfony 7.4 style, we use strict typing and attributes. Ensure your messenger.yaml is configured for async transport.
#config/packages/messenger.yaml:
framework:
messenger:
transports:
async:
dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
retry_strategy:
max_retries: 3
delay: 1000
multiplier: 2
routing:
'App\Message\MintTicketMessage': async
Verification
To verify this implementation works without deploying to Mainnet:
Local Node: Run a local blockchain using Hardhat or Anvil (Foundry).
npx hardhat node
Environment: Set your .env.local to point to localhost.
BLOCKCHAIN_RPC_URL="http://127.0.0.1:8545"
WALLET_PRIVATE_KEY="<one of the test keys provided by hardhat>"
SMART_CONTRACT_ADDRESS="<deployed contract address>"
MESSENGER_TRANSPORT_DSN="doctrine://default"
Consume: Start the worker.
php bin/console messenger:consume async -vv
Request:
curl -X POST https://localhost:8000/api/v1/tickets/mint \
-H "Content-Type: application/json" \
-d '{"wallet_address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"}'
You should see the worker process the message and, if you implemented the raw transaction signing logic fully, a transaction hash appear in your Hardhat console.
Conclusion
Building Web3 applications in PHP requires a shift in mindset. You are not just building a CRUD app; you are building an orchestrator for decentralized state.
By using Symfony 7.4, we leveraged:
- HttpClient for reliable, controllable RPC communication.
- Messenger to handle the asynchronous reality of blockchains.
- PHP 8.3 Attributes for clean, readable code.
This architecture scales. Whether you are selling 10 tickets or 10,000, the message queue acts as a buffer, ensuring your transaction nonces don’t collide and your server doesn’t hang.
Ready to scale your Web3 infrastructure?
Integrating blockchain requires precision. If you need help auditing your smart contract interactions or scaling your Symfony message consumers, let’s be in touch.