PHPackages                             payracash/payra-sdk-laravel - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Payment Processing](/categories/payments)
4. /
5. payracash/payra-sdk-laravel

ActiveLibrary[Payment Processing](/categories/payments)

payracash/payra-sdk-laravel
===========================

Payra Crypto Payments signature generator SDK for Laravel

v1.2.4(3mo ago)08MITPHPPHP ^8.0

Since Feb 5Pushed 3mo agoCompare

[ Source](https://github.com/payracash/payra-sdk-laravel)[ Packagist](https://packagist.org/packages/payracash/payra-sdk-laravel)[ RSS](/packages/payracash-payra-sdk-laravel/feed)WikiDiscussions main Synced 1mo ago

READMEChangelogDependencies (2)Versions (2)Used By (0)

Payra Laravel SDK
=================

[](#payra-laravel-sdk)

Official **Laravel SDK** for integrating **Payra's on-chain payment system** into your backend applications.

This SDK provides:

- Secure generation of **ECDSA signatures** compatible with the Payra smart contract — used for order payment verification.
- Simple methods for **checking the on-chain details of orders** to confirm completed payments.

How It Works
------------

[](#how-it-works)

The typical flow for signing and verifying a Payra transaction:

1. The **frontend** prepares all required payment parameters:
    - **Network** – blockchain name (e.g. Polygon, Linea)
    - **Token address** – ERC-20 token contract address
    - **Order ID** – unique order identifier
    - **Amount WEI** – already converted to the smallest unit (e.g. wei, 10⁶)
    - **Timestamp** – Unix timestamp of the order
    - **Payer wallet address** – the wallet address from which the user will make the on-chain payment
2. The frontend sends these parameters to your **backend**.
3. The **backend** uses this SDK to generate a cryptographic **ECDSA signature** with its signature key (performed **offline**).
4. The backend returns the generated signature to the frontend.
5. The **frontend** calls the Payra smart contract (`payOrder`) with all parameters **plus** the signature.

This process ensures full compatibility between your backend and Payra’s on-chain verification logic.

Features
--------

[](#features)

- Generates **Ethereum ECDSA signatures** using the `secp256k1` curve.
- Fully compatible with **Payra's Solidity smart contracts** (`ERC-1155` payment verification).
- Includes built-in **ABI encoding and decoding** via `web3.php`.
- Supports `.env` and `config/payra.php` configuration for multiple blockchain networks.
- Laravel IoC container integration (easy dependency injection)
- Verifies **order payment details directly on-chain** via RPC or blockchain explorer API.
- Provides **secure backend integration** for signing and verifying transactions.
- Includes optional utility helpers for:
    - **Currency conversion** (via [ExchangeRate API](https://www.exchangerate-api.com/))
    - **USD ⇄ WEI** conversion for token precision handling.

Setup
-----

[](#setup)

Before installing this package, make sure you have an active **Payra** account:

[https://payra.cash/products/on-chain-payments/registration](https://payra.cash/products/on-chain-payments/registration#registration-form)

Before installing this package, make sure you have a **MerchantID**

- Your **Merchant ID** (unique for each blockchain network)
- Your **Signature Key** (used to sign Payra transactions securely)

Additionally: To obtain your **RPC URLs** which are required for reading on-chain order details directly from the blockchain, you can use the public free endpoints provided with this package or create an account on one of the following services for better performance and reliability:

- **QuickNode** – Extremely fast and excellent for Polygon/Mainnet. ([quicknode.com](https://quicknode.com/))
- **Alchemy** – Offers a great developer dashboard and high reliability. ([alchemy.com](https://alchemy.com/))
- **DRPC** – Decentralized RPC with a generous free tier and a strict no-log policy. ([drpc.org](https://drpc.org))
- **Infura** – The industry standard; very stable, especially for Ethereum. ([infura.io](https://infura.io))

Optional (recommended):

- Create a free API key at [ExchangeRate API](https://www.exchangerate-api.com/) to enable **automatic fiat → USD conversions** using the built-in utility helpers.

Installation
------------

[](#installation)

### Requirements

[](#requirements)

- PHP 8.1 or higher
- Composer
- cURL extension enabled
- `.env` file for environment configuration

### Via Composer (recommended)

[](#via-composer-recommended)

```
composer require payracash/payra-sdk-laravel
```

Laravel will auto-discover the service provider.
You can also publish the configuration file:

```
php artisan vendor:publish --tag=payra-config

```

Environment Configuration
-------------------------

[](#environment-configuration)

Create a `.env` file in your project root (you can copy from example):

```
cp  .env.example  .env
```

This file stores your **private configuration** and connection settings for all supported networks. Never commit `.env` to version control.

### Required Variables

[](#required-variables)

Exchange Rate (optional) used for automatic fiat → USD conversions via the built-in Payra utilities.

```
# (Optional) API key required for authenticating backend requests
PAYRA_API_KEY=

# Optional: used by PayraUtils::convertToUSD() for fiat conversions
PAYRA_EXCHANGE_RATE_API_KEY=
PAYRA_EXCHANGE_RATE_CACHE_TIME=720 # in minutes

# Polygon network configuration
PAYRA_POLYGON_OCP_GATEWAY_CONTRACT_ADDRESS=0xc56c55D9cF0FF05c85A2DF5BFB9a65b34804063b
PAYRA_POLYGON_SIGNATURE_KEY=
PAYRA_POLYGON_MERCHANT_ID=
PAYRA_POLYGON_RPC_URL_1=https://polygon-rpc.com

# Ethereum network configuration
PAYRA_ETHEREUM_OCP_GATEWAY_CONTRACT_ADDRESS=
PAYRA_ETHEREUM_SIGNATURE_KEY=
PAYRA_ETHEREUM_MERCHANT_ID=
PAYRA_ETHEREUM_RPC_URL_1=
PAYRA_ETHEREUM_RPC_URL_2=

# Linea network configuration
PAYRA_LINEA_OCP_GATEWAY_CONTRACT_ADDRESS=
PAYRA_LINEA_SIGNATURE_KEY=
PAYRA_LINEA_MERCHANT_ID=
PAYRA_LINEA_RPC_URL_1=
PAYRA_LINEA_RPC_URL_2=
```

These values will be loaded into `config/payra.php`.

#### Important Notes

[](#important-notes)

- The cache automatically refreshes when it expires.
- You can adjust the cache duration by setting `PAYRA_EXCHANGE_RATE_CACHE_TIME`:
    - `5` → cache for 5 minutes
    - `60` → cache for 1 hour
    - `720` → cache for 12 hours (default)
- Each network (Polygon, Ethereum, Linea) has its own **merchant ID**, **signature key**, and **RPC URLs**.
- The SDK automatically detects which chain configuration to use based on the selected network.
- You can use multiple RPC URLs for redundancy (the SDK will automatically fall back if one fails).
- Contract addresses correspond to the deployed Payra Core Forward contracts per network.

### Payra API key (server-to-server)

[](#payra-api-key-server-to-server)

This package uses a simple API key to protect backend HTTP endpoints (for example `/api/payra/generate/signature` and `/api/payra/convert/to/usd`).

**You create this key yourself** and keep it secret, it is **not** issued by Payra. The backend (your Laravel app) validates the key in the `X-Payra-Key` header.

> **Note:** The API key is only required if you expose Payra endpoints via HTTP (for example, when your frontend calls your backend). If you are using the SDK internally in your Laravel app or services (without calling API routes), you can safely omit this variable.

#### Why do we use it?

[](#why-do-we-use-it)

- It prevents unauthorized clients from calling your Payra endpoints.
- It’s a lightweight server-to-server authentication mechanism for internal integrations.

#### How to generate a secure key

[](#how-to-generate-a-secure-key)

Generate a long random key (do not handcraft a short password). Examples:

```
# recommended: 32 bytes hex
php -r "echo bin2hex(random_bytes(32));"

# or using openssl
openssl rand -hex 32
```

Put the generated key into your `.env`:

```
# API key required for authenticating backend requests
PAYRA_API_KEY=your_generated_hex_key_here
```

#### How to call the API (example with curl / Postman)

[](#how-to-call-the-api-example-with-curl--postman)

Include the key in the `X-Payra-Key` header:

```
curl -X POST "https://your-domain.com/api/payra/generate/signature" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "X-Payra-Key: your_generated_hex_key_here" \
  -d '{"network":"polygon","token_address":"0x...","order_id":"order_1","amount":"1000000","timestamp":1234567890,"payer_address":"0x..."}'
```

#### Endpoints for API

[](#endpoints-for-api)

```
https://your-domain.com/payra/generate/signature
https://your-domain.com/payra/order/details
https://your-domain.com/payra/order/is-paid
https://your-domain.com/payra/convert/to/usd
```

#### Security best practices

[](#security-best-practices)

- Always use **HTTPS** , never send the key over plain HTTP.
- Store the key only in server-side `.env` (never in client-side code or public repositories).
- Consider rotating the key periodically and update `.env` (and deployed configs).
- If you need stricter security, combine the API key with IP allowlists, HMAC signatures, or short-lived tokens.
- If `PAYRA_API_KEY` is missing from `.env`, middleware will return an explicit configuration error (500), if it is present but mismatched, requests return `401 Unauthorized`.

Usage Example
-------------

[](#usage-example)

### Generate Signature

[](#generate-signature)

```
use Payra\PayraSignature;

class PayraController extends Controller
{
    public function generateSignature()
    {
        $payraSignature = app(PayraSignature::class);

        $signature = $payraSignature->generate(
            $network,         	// e.g. "polygon"
            $tokenAddress,    	// ERC-20 USDT or USDC
            $orderId,         	// string (unique per merchantId)
            $amountWei,        	// in Wei $1 = 1_000_000
            (int) $timestamp,	// now()->timestamp
            $payerAddress     	// Public payer wallet address
        );

        return response()->json(['signature' => $signature]);
    }
}
```

#### Response

[](#response)

```
{
	"status": "success",
	"signature": "0x2772922237f8960627760c568965903c9ea25f76bd63320fc6c03bc8f614905036837347c8ed7e94b93c570ebe5e6abb0272b3096fce065e000d5413a8c3561c1c",
	"message": "Signature generated successfully."
}
```

#### Input Parameters

[](#input-parameters)

FieldTypeDescription**`network`**`string`Selected network name**`tokenAddress`**`string`ERC20 token contract address**`orderId`**`string`Unique order reference (e.g. ORDER-123)**`amountWei`**`string` or `integer`Token amount in smallest unit (e.g. wei)**`timestamp`**`number`Unix timestamp of signature creation**`payerAddress`**`string`Payer Wallet Address---

### Get Order Details

[](#get-order-details)

Retrieve **full transaction details** for a specific order from the Payra smart contract. This method returns the complete on-chain payment data associated with the order, including:

- whether the order has been paid,
- the payment token address,
- the paid amount,
- the fee amount,
- and the payment timestamp.

Use this method when you need **detailed information** about the payment or want to display full transaction data.

```
use Payra\PayraOrderService;

class PayraController extends Controller
{
    public function getDetails()
    {
	    $orderService = app(PayraOrderService::class);

        $orderDetails = $orderService->getDetails(
	        $network,    // e.g. "polygon"
			$orderId,    // string (unique per merchantId)
		);

		return response()->json(['result' => $orderDetails]);
	}
}
```

#### Response

[](#response-1)

```
{
    "result": {
        "success": true,
        "error": null,
        "paid": true,
        "token": "0xc2132d05d31c914a87c6611c10748aeb04b58e8f",
        "amount": 400000,
        "fee": 3600,
        "timestamp": 1765138941
    }
}
```

---

### Check Order Paid Status

[](#check-order-paid-status)

Perform a **simple payment check** for a specific order. This method only verifies whether the order has been paid (`true` or `false`) and does **not** return any additional payment details.

Use this method when you only need a **quick boolean confirmation** of the payment status.

```
use Payra\PayraOrderService;

class PayraController extends Controller
{
    public function isPaid()
    {
	    $orderService = app(PayraOrderService::class);

        $isPaid = $orderService->isPaid(
	        $network,    // e.g. "polygon"
			$orderId,    // string (unique per merchantId)
		);

		return response()->json(['result' => $isPaid]);
	}
}
```

#### Response

[](#response-2)

```
{
    "result": {
        "success": true,
        "paid": true,
        "error": null
    }
}
```

---

Utilities / Conversion Helpers
------------------------------

[](#utilities--conversion-helpers)

The SDK includes **helper functions** for working with token amounts and currency conversion.

### 1. Get Token Decimals

[](#1-get-token-decimals)

```
use Payra\PayraUtils;

class PaymentController extends Controller
{
	public function convertToUSD()
	{
		$utils = app(PayraUtils::class);
	    $tokenDecimals = $utils->getTokenDecimals('polygon', 'USDT');

		return response()->json(['token_decimals' => $tokenDecimals]);
	}
}
```

#### Response

[](#response-3)

```
{
    "token_decimals": 6
}
```

Returns the number of decimal places for a given token on a specific network.

---

### 2. Convert USD/Token Amounts to Wei

[](#2-convert-usdtoken-amounts-to-wei)

```
use Payra\PayraUtils;

class PaymentController extends Controller
{
	public function convertToUSD()
	{
		$utils = app(PayraUtils::class);
	    $toWei = $utils->toWei(14.33, 'polygon', 'USDT');

		return response()->json(['to_wei' => $toWei]);
	}
}
```

#### Response

[](#response-4)

```
{
    "to_wei": 14330000
}
```

---

### 3. Convert Wei to USD/Token

[](#3-convert-wei-to-usdtoken)

```
use Payra\PayraUtils;

class PaymentController extends Controller
{
	public function convertToUSD()
	{
		$utils = app(PayraUtils::class);
	    $fromWei = $utils->fromWei(34345230, 'polygon', 'USDT');

		return response()->json(['from_wei' => $fromWei]);
	}
}
```

#### Response

[](#response-5)

```
{
    "from_wei": 34.35
}
```

### 4. Currency Conversion (Optional)

[](#4-currency-conversion-optional)

Payra processes all payments in **USD**. If your store uses another currency (like EUR, AUD, or GBP), you can:

- Convert the amount to USD on your backend manually, **or**
- Use the built-in helper provided in the SDK.

```
use Payra\PayraUtils;

class PaymentController extends Controller
{
	public function convertToUSD()
	{
		$utils = app(PayraUtils::class);

		$convertedAmount = $utils->convertToUSD(
			$amount,    // e.g. 232.23
			$from_currency    // e.g. EUR
		);

		return response()->json(['converted_amount' => $convertedAmount]);
	}
}
```

#### Response

[](#response-6)

```
{
    "converted_amount": 177.64 # in USD
}
```

#### Setup for Currency Conversion

[](#setup-for-currency-conversion)

To use the conversion helper, you need a free API key from **[exchangerate-api.com](https://exchangerate-api.com/)**.

1. Register a free account and get your API key.
2. Add the key to your `.env` file:

```
PAYRA_EXCHANGE_RATE_API_KEY=your_api_key_here
```

4. That’s it. Payra will automatically fetch the exchange rate and calculate the USD amount.

**Note:** The free plan allows 1,500 requests per month, which is sufficient for most stores. Exchange rates on this plan are updated every 24 hours, so with caching, it’s more than enough. Paid plans offer faster update intervals.

---

#### You can also inject the generator via constructor:

[](#you-can-also-inject-the-generator-via-constructor)

```
use Payra\PayraSignature;
use Payra\PayraOrderService;
use Payra\PayraUtils;

class PaymentController extends Controller
{
    public function __construct(
        private PayraSignature $signature,
        private PayraOrderService $order,
        private PayraUtils $utils
    ) {}

    public function generateSignature()
    {
		// $network, $tokenAddress, $orderId, $amountWei, $timestamp, $payerAddress
        // should come from request / your business logic
        $signature = $this->signature->generate(
	        $network,         // e.g. "polygon"
	        $tokenAddress,    // ERC-20 USDT or USDC
	        $orderId,         // string (unique per merchantId)
	        $amountWei,       // in Wei $1 = 1_000_000
	        (int) $timestamp, // now()->timestamp
	        $payerAddress     // Public payer wallet address
	    );

	    return response()->json([
	        'status' => 'success',
	        'signature' => $signature,
	        'message' => 'Signature generated successfully.'
	    ]);
	}

	public function getDetails()
	{
		$orderDetails = $this->order->getDetails(
			$network,   // e.g. "polygon"
			$orderId    // string (unique per merchantId)
		);

	  return response()->json(['order_details' => $orderDetails]);
	}

	public function isPaid()
	{
		$isPaid = $this->order->isPaid(
			$network,   // e.g. "polygon"
			$orderId    // string (unique per merchantId)
		);

		return response()->json(['is_paid' => $isPaid]);
	}

	public function convertToUSD()
	{
		$convertedAmount = $this->utils->convertToUSD(
			$amount,	// e.g. 232.23
			$from_currency  // e.g. EUR
	);

	return response()->json(['converted_amount' => $convertedAmount]);
	}
}
```

Security Notice
---------------

[](#security-notice)

Never expose your signature key in frontend or client-side code.
This SDK is **server-side only** and must be used securely on your backend. Never use it in frontend or browser environments. Also, never commit your `.env` file to version control.

Project
-------

[](#project)

-
-
-
- [https://payra.eth](https://payra.eth.limo) - suporrted by Brave Browser or .limo

Social Media
------------

[](#social-media)

- [Telegram Payra Group](https://t.me/+GhTyJJrd4SMyMDA0)
- [Telegram Announcements](https://t.me/payracash)
- [Twix (X)](https://x.com/PayraCash)
- [Dev.to](https://dev.to/payracash)

License
-------

[](#license)

MIT © [Payra](https://payra.cash)

###  Health Score

34

—

LowBetter than 77% of packages

Maintenance82

Actively maintained with recent releases

Popularity4

Limited adoption so far

Community2

Small or concentrated contributor base

Maturity39

Early-stage or recently created project

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Unknown

Total

1

Last Release

96d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/1e933f22d5269968f5eb619c28970640eef37c629f788785e5202782a164d13a?d=identicon)[payracash](/maintainers/payracash)

### Embed Badge

![Health badge](/badges/payracash-payra-sdk-laravel/health.svg)

```
[![Health](https://phpackages.com/badges/payracash-payra-sdk-laravel/health.svg)](https://phpackages.com/packages/payracash-payra-sdk-laravel)
```

###  Alternatives

[omnipay/paypal

PayPal gateway for Omnipay payment processing library

3156.8M53](/packages/omnipay-paypal)[eduardokum/laravel-boleto

Biblioteca com boletos para o laravel

626351.9k2](/packages/eduardokum-laravel-boleto)[tbbc/money-bundle

This is a Symfony bundle that integrates moneyphp/money library (Fowler pattern): https://github.com/moneyphp/money.

1961.9M](/packages/tbbc-money-bundle)[2checkout/2checkout-php

2Checkout PHP Library

83740.3k2](/packages/2checkout-2checkout-php)[smhg/sepa-qr-data

Generate QR code data for SEPA payments

61717.2k5](/packages/smhg-sepa-qr-data)[omnipay/dummy

Dummy driver for the Omnipay payment processing library

271.2M33](/packages/omnipay-dummy)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)