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. Non-Fungible Tokens (NFTs) 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. Decentralized Event Ticketing System Symfony Messenger 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). Direct Interaction (Write): We use Symfony Messenger to offload “Minting” transactions to a worker, preventing HTTP timeouts. Direct Interaction (Write): RPC Polling (Read): We use scheduled commands to verify on-chain status. RPC Polling (Read): Smart Contract: We assume a standard ERC-721 contract deployed on an EVM-compatible chain (Ethereum, Polygon, Base). Smart Contract: Prerequisites & Stack PHP: 8.3+
Symfony: 7.4 (LTS)
Blockchain Node: Infura, Alchemy, or a local Hardhat node. 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. web3p/web3.php Symfony’s native HttpClient 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 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: composer.json {
    "require": {
        "php": ">=8.3",
        "symfony/http-client": "7.4.*",
        "symfony/messenger": "7.4.*",
        "symfony/uid": "7.4.*",
        "web3p/web3.php": "^0.3.0"
    }
} {
    "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. EthereumService //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;
    }
} //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
    ) {}
} //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. web3p/web3.php 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. Note: Key Management Service (KMS) //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;
        }
    }
} //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);
    }
} //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. messenger.yaml #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 #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). Local Node: Hardhat Anvil npx hardhat node npx hardhat node Environment: Set your .env.local to point to localhost. Environment: .env.local 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" 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. Consume: php bin/console messenger:consume async -vv php bin/console messenger:consume async -vv Request: Request: curl -X POST https://localhost:8000/api/v1/tickets/mint \
-H "Content-Type: application/json" \
-d '{"wallet_address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"}' 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. Web3 shift in mindset By using Symfony 7.4, we leveraged: Symfony 7.4 HttpClient for reliable, controllable RPC communication.
Messenger to handle the asynchronous reality of blockchains.
PHP 8.3 Attributes for clean, readable code. HttpClient for reliable, controllable RPC communication. HttpClient Messenger to handle the asynchronous reality of blockchains. Messenger PHP 8.3 Attributes for clean, readable code. PHP 8.3 Attributes 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.

This story contains AI-generated text. The author has used AI either for research, to generate outlines, or write the text itself. 

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Building a Decentralized Event Ticketing System Web3 with Symfony 7.4

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Advanced Patterns with the Symfony Clock: MockClock, NativeClock, and More

An Introduction to JavaScript Functions and Asynchronous Programming with Callbacks

Asynchronous Initialization in C#: Overcoming Constructor Limitations

How to do Asynchronous Programming in Flutter with Dart

Pin Safety: Understanding Pinning in Rust Futures

The Complete Asynchronous Programming Primer for Unity Development

Advanced Patterns with the Symfony Clock: MockClock, NativeClock, and More

An Introduction to JavaScript Functions and Asynchronous Programming with Callbacks

Asynchronous Initialization in C#: Overcoming Constructor Limitations

How to do Asynchronous Programming in Flutter with Dart

Pin Safety: Understanding Pinning in Rust Futures

The Complete Asynchronous Programming Primer for Unity Development

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps