Proof of Play Onchain Services

https://docs.proofofplay.com
Admin
Proof of Play Onchain Services is a platform for building performance onchain applications and...
Tokens:8,694
Snippets:51
Trust Score:8
Update:10 months ago
Show doc for...
Tokens:
Raw
### Verifying Random Numbers with drand

Source: https://docs.proofofplay.com/services/vrng/about

Instructions and example for verifying random numbers using the drand quicknet API.

```APIDOC
## Verifying the round number / random number with drand

If you want to verify the random number, you can check directly with drand for this. We use drand's **quicknet** for this.

**For instance, to see the roundNumber 11:**

GET `https://api.drand.sh/52db9ba70e0cc0f6eaf7803dd07447a1f5477735fd3f661792ba94600c84e971/public/11`

### Response Example

```json
{
  "round": 11,
  "randomness": "ebdcbfe855d10c56db22455fa5a18963c1f62d85f859c35c310273449b49d284",
  "signature": "163d14081e191a3f5d81e2f580eab591ea608402fda4f6e44b5a0bde11e368070e77d07ad3240726ea33e410c84d4b09ea0a4a0291f6c3c485d8630e1c0edf0a"
}
```

We can see here the random number in hex is `ebdcbfe855d10c56db22455fa5a18963c1f62d85f859c35c310273449b49d284`
```

--------------------------------

### Verifying Random Numbers with drand

Source: https://docs.proofofplay.com/services/vrng

Provides an endpoint to verify generated random numbers by querying the drand network directly. It shows an example of how to fetch and interpret the data for a specific round.

```APIDOC
## Verifying Random Numbers with drand

### Description
You can verify the generated random numbers by directly querying the drand network. This example uses drand's `quicknet` to check a specific round number.

### Method
GET

### Endpoint
`https://api.drand.sh/<public_key>/<round_number>`

### Parameters
#### Path Parameters
- **public_key** (string) - Required - The public key for the drand network (e.g., `52db9ba70e0cc0f6eaf7803dd07447a1f5477735fd3f661792ba94600c84e971`).
- **round_number** (integer) - Required - The specific round number to query (e.g., `11`).

### Request Body
N/A

### Request Example
`GET https://api.drand.sh/52db9ba70e0cc0f6eaf7803dd07447a1f5477735fd3f661792ba94600c84e971/public/11`

### Response
#### Success Response (200)
- **round** (integer) - The queried round number.
- **randomness** (string) - The generated random number in hexadecimal format.
- **signature** (string) - The signature for the randomness.

#### Response Example
```json
{
  "round": 11,
  "randomness": "ebdcbfe855d10c56db22455fa5a18963c1f62d85f859c35c310273449b49d284",
  "signature": "163d14081e191a3f5d81e2f580eab591ea608402fda4f6e44b5a0bde11e368070e77d07ad3240726ea33e410c84d4b09ea0a4a0291f6c3c485d8630e1c0edf0a"
}
```
```

--------------------------------

### Generate Unique Random Numbers Per Transaction (Solidity)

Source: https://docs.proofofplay.com/services/vrng

Provides Solidity code examples to generate unique random numbers within a 3-second window by incorporating a `requestId`. Different methods are shown, varying in gas efficiency and normalization. These methods combine a `requestId` with the default `randomNumber` to ensure uniqueness for each transaction.

```Solidity
uint256 newRandomNumber = requestId + randomNumber;

uint256 newRandomNumber = uint256(keccak256(abi.encodePacked(requestId, randomNumber)));

uint256 newRandomNumber = uint256(keccak256(abi.encodePacked(blockhash(block.number - (requestId % 256)), randomNumber)));
```

--------------------------------

### Drand Quicknet Random Number Verification (JSON)

Source: https://docs.proofofplay.com/services/vrng/about

An example JSON response from the drand quicknet API, showing the structure of a verified random number for a specific round. This can be used to cross-reference the random numbers delivered by the VRF contract.

```json
{
  "round": 11,
  "randomness": "ebdcbfe855d10c56db22455fa5a18963c1f62d85f859c35c310273449b49d284",
  "signature": "163d14081e191a3f5d81e2f580eab591ea608402fda4f6e44b5a0bde11e368070e77d07ad3240726ea33e410c84d4b09ea0a4a0291f6c3c485d8630e1c0edf0a"
}
```

--------------------------------

### GET /v1/vrf/{chainId}/{txHash}

Source: https://docs.proofofplay.com/services/vrng/api

Generates a VRF signed transaction signature off-chain. This allows users to manually retry a random number generation if needed.

```APIDOC
## GET /v1/vrf/{chainId}/{txHash}

### Description
Generates a VRF signed transaction signature off-chain. This allows users to manually retry a random number generation if needed.

### Method
GET

### Endpoint
/v1/vrf/{chainId}/{txHash}

### Parameters
#### Path Parameters
- **txHash** (string) - Required - The transaction hash.
- **chainId** (number) - Required - The chain ID.

### Request Example
```json
{
  "example": "No request body for GET request"
}
```

### Response
#### Success Response (200)
- **requestId** (number) - The unique identifier for the request.
- **roundNumber** (number) - The round number used for randomness generation.
- **randomNumber** (string) - The generated random number.
- **signature** (string) - The cryptographic signature of the random number data.

#### Response Example
```json
{
  "requestId": 1234567890,
  "roundNumber": 12345,
  "randomNumber": "100390681190810751958784661347623210498151382836405096200928376056671247975325",
  "signature": "0x3ba0095fdcd3704f83882efe53562bfaf84a34ae30765def05ce78d213b41ca568cf5da0c507be8b02c39ae47c377dbb5f7085e9a91919fd07dddc264f0df7d81c"
}
```
```

--------------------------------

### Verify Random Number with Drand API (HTTP)

Source: https://docs.proofofplay.com/services/vrng

Shows how to verify a random number generated by drand using its public API. This involves making an HTTP GET request to a specific endpoint that includes the network's public key and the round number. The response provides the round number, the randomness in hex format, and a signature for verification.

```HTTP
GET https://api.drand.sh/52db9ba70e0cc0f6eaf7803dd07447a1f5477735fd3f661792ba94600c84e971/public/11
```

```JSON
{
  "round": 11,
  "randomness": "ebdcbfe855d10c56db22455fa5a18963c1f62d85f859c35c310273449b49d284",
  "signature": "163d14081e191a3f5d81e2f580eab591ea608402fda4f6e44b5a0bde11e368070e77d07ad3240726ea33e410c84d4b09ea0a4a0291f6c3c485d8630e1c0edf0a"
}
```

--------------------------------

### Generating Unique Random Numbers Within a Transaction

Source: https://docs.proofofplay.com/services/vrng/about

Provides examples of how to generate multiple unique random numbers from a single VRF-provided number within the same transaction. This is achieved by using cryptographic hashing functions like `keccak256` or bitwise operations to derive new numbers from the initial one.

```solidity
//Example 1: Keccak dervive
uint256 randomNumber = 12398012938091283113928;
uint256 randomNumber2 = keccak256(randomNumber);
uint256 randomNumber3 = keccak256(randomNumber2);

//Example 2: Split the number and use both sides
uint256 randomNumber = 234345234523452345;
uint256 randomNumber2 = randomNumber >> 128;  // Take upper 128 bits
uint256 randomNumber3 = randomNumber & ((1 << 128) - 1); // Take lower 128 bits
```

--------------------------------

### GET /v1/vrf/{chainId}/{txHash}

Source: https://docs.proofofplay.com/services/vrng

Requests an EIP712 signature from the API servers to manually deliver a VRF random number directly to the contract on the blockchain. This is useful when random numbers fail to be delivered due to contract-side issues.

```APIDOC
## GET /v1/vrf/{chainId}/{txHash}

### Description
Requests an EIP712 signature to manually deliver a VRF random number. This is a preview feature and requires contacting support for access.

### Method
GET

### Endpoint
`https://vrf.proofofplay.com/v1/vrf/{chainId}/{txHash}`

### Parameters
#### Path Parameters
- **chainId** (string) - Required - The chain ID of the network.
- **txHash** (string) - Required - The transaction hash for which to request a signature.

### Request Example
```
GET https://vrf.proofofplay.com/v1/vrf/1/0x1234567890abcdef
```

### Response
#### Success Response (200)
- **requestId** (Number) - The ID of the request.
- **roundNumber** (Number) - The round number associated with the request.
- **randomNumber** (BigInt) - The generated random number.
- **signature** (String) - The EIP712 signature for delivering the random number.

#### Response Example
```json
{
  "requestId": 12345,
  "roundNumber": 67890,
  "randomNumber": "12345678901234567890",
  "signature": "0xabc123..."
}
```

### Usage with VRFSystem Contract
With the response, you can call the VRFSystem contract:
```javascript
vrf.deliverSignedRandomNumber(requestId, roundNumber, randomNumber, signature);
```

### Warning
Be aware that you will be racing the normal relay flow. If your transaction reverts with `InvalidRequestId`, it means a relay has already delivered this random number, and random numbers can only be delivered once.
```

--------------------------------

### Derive Multiple Random Numbers Per Transaction (Solidity)

Source: https://docs.proofofplay.com/services/vrng

Demonstrates how to derive multiple distinct random numbers within a single transaction using Solidity. This is achieved by re-hashing the initial random number multiple times, ensuring each derived number is unique within the same transaction context. This approach is useful when more than one random value is needed in a single transaction.

```Solidity
functionThatUsesNumber(randomNumber);
randomNumber = uint256(keccak256(randomNumber));
functionThatUsesNumber(randomNumber);
```

--------------------------------

### Request EIP712 Signature for Manual Retry (JavaScript)

Source: https://docs.proofofplay.com/services/vrng/about

Demonstrates how to request an EIP712 signature from Proof of Play's API servers for manual retry of a failed random number delivery. This signature is used to deliver the random number directly to the contract.

```javascript
GET https://vrf.proofofplay.com/v1/vrf/{chainId}/{txHash}
```

--------------------------------

### Manual Retries with EIP712 Signatures

Source: https://docs.proofofplay.com/services/vrng/about

Instructions for manually retrying random number delivery using EIP712 signatures, for use in rare failure cases.

```APIDOC
## Manual Retries with EIP712 signatures

> 🧪 **This feature is in Preview**. Please contact us on slack if you wish to use this.

In a very rare instance, you may see random numbers fail to be delivered. In most cases this will be an issue on the contract side.

In these situations, you can choose to deliver this number yourself. First you should request the EIP712 signature from our API servers which you can use to deliver the random nummber directly to the contract on the blockchain.

### Request

**Method**: GET

**Endpoint**: `https://vrf.proofofplay.com/v1/vrf/{chainId}/{txHash}`

*   **Path Parameters**:
    *   `chainId` (string) - Required - The chain ID for the transaction.
    *   `txHash` (string) - Required - The transaction hash associated with the failed delivery.

### Request Example

(Link to API documentation: [Try the API!](/services/vrng/api))

### Response

#### Success Response (200)

*   **requestId** (Number) - The unique identifier for the random number request.
*   **roundNumber** (Number) - The round number associated with the random number.
*   **randomNumber** (BigInt) - The generated random number.
*   **signature** (String) - The EIP712 signature (bytes data) for delivering the random number.

#### Response Example

```json
{
  "requestId": Number,
  "roundNumber": Number,
  "randomNumber": BigInt,
  "signature": "String // bytes data of signature"
}
```

With the response you can now call the VRFSystem contract:

```solidity
vrf.deliverSignedRandomNumber(requestId, roundNumber, randomNumber, signature);
```

> ⚠️ **Warning**: You will be racing the normal relay flow. If you get a tx revert with `InvalidRequestId`, this means that a relay has already delivered this random number. Random numbers can only be delivered once.
```

--------------------------------

### Smart Contract Events for Random Number Requests (Solidity)

Source: https://docs.proofofplay.com/services/vrng

Defines two essential Solidity events for managing random number requests within a smart contract. `RandomNumberRequested` tracks the initiation of a request, including its ID, callback address, and an optional trace ID. `RandomNumberDelivered` confirms the successful delivery of a random number, providing the request ID, callback address, trace ID, the round number used, and the generated random number itself.

```Solidity
/// @notice Emitted when a random number request is initiated
/// @param requestId The unique identifier for the random number request
/// @param callbackAddress The address the random number is requested to
/// @param traceId The trace ID used to track the request across transactions (0 if no trace ID)
event RandomNumberRequested(uint256 indexed requestId, address indexed callbackAddress, uint256 indexed traceId);

/// @notice Emitted when a random number is successfully delivered
/// @param requestId The unique identifier of the fulfilled request
/// @param callbackAddress the adddress was random number is requested to
/// @param traceId The trace ID associated with the request
/// @param number The round number that was used for the random number
/// @param randomNumber The random number that was generated
event RandomNumberDelivered(uint256 indexed requestId, address indexed callbackAddress, uint256 indexed traceId, uint256 roundNumber, uint256 randomNumber);
```

--------------------------------

### Generating Unique Random Numbers Within a Time Window

Source: https://docs.proofofplay.com/services/vrng/about

Demonstrates methods to derive unique random numbers from the delivered VRF output, even when multiple requests occur within the same 3-second window. These techniques involve combining the received `randomNumber` with other transaction-specific data like `requestId` or block hashes to create distinct values.

```solidity
// Add the requestId (Most Gas Efficient)
uint256 newRandomNumber = requestId + randomNumber;

// Hash with requestId
uint256 newRandomNumber = uint256(keccak256(abi.encodePacked(requestId, randomNumber)));

// More expensive, but more normalized, hash based on requestId in last 256 block hashes
uint256 newRandomNumber = uint256(keccak256(abi.encodePacked(blockhash(block.number - (requestId % 256)), randomNumber)));
```

--------------------------------

### Smart Contract Events

Source: https://docs.proofofplay.com/services/vrng

The smart contract emits two primary events: `RandomNumberRequested` when a request is initiated and `RandomNumberDelivered` upon successful generation and delivery of a random number.

```APIDOC
## Smart Contract Events

### Description
The smart contract emits the following events to track random number requests and deliveries.

### Method
N/A (Event Definitions)

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Request Example
N/A

### Response
#### Event Definitions
```solidity
/// @notice Emitted when a random number request is initiated
/// @param requestId The unique identifier for the random number request
/// @param callbackAddress The address the random number is requested to
/// @param traceId The trace ID used to track the request across transactions (0 if no trace ID)
event RandomNumberRequested(uint256 indexed requestId, address indexed callbackAddress, uint256 indexed traceId);

/// @notice Emitted when a random number is successfully delivered
/// @param requestId The unique identifier of the fulfilled request
/// @param callbackAddress the adddress was random number is requested to
/// @param traceId The trace ID associated with the request
/// @param number The round number that was used for the random number
/// @param randomNumber The random number that was generated
event RandomNumberDelivered(uint256 indexed requestId, address indexed callbackAddress, uint256 indexed traceId, uint256 roundNumber, uint256 randomNumber);
```

### Response Example
N/A
```

--------------------------------

### Proof of Play VRF Contract Events (Solidity)

Source: https://docs.proofofplay.com/services/vrng/about

Defines the events emitted by the VRF contract for random number requests and deliveries. These events can be monitored on the RPC level or through block explorers.

```solidity
/// @notice Emitted when a random number request is initiated
/// @param requestId The unique identifier for the random number request
/// @param callbackAddress The address the random number is requested to
/// @param traceId The trace ID used to track the request across transactions (0 if no trace ID)
event RandomNumberRequested(uint256 indexed requestId, address indexed callbackAddress, uint256 indexed traceId);

/// @notice Emitted when a random number is successfully delivered
/// @param requestId The unique identifier of the fulfilled request
/// @param callbackAddress the adddress was random number is requested to
/// @param traceId The trace ID associated with the request
/// @param roundNumber The round number that was used for the random number
/// @param randomNumber The random number that was generated
event RandomNumberDelivered(uint256 indexed requestId, address indexed callbackAddress, uint256 indexed traceId, uint256 roundNumber, uint256 randomNumber);
```

--------------------------------

### VRFSystem Interface

Source: https://docs.proofofplay.com/services/vrng/about

Interface for interacting with the VRFSystem contract to request random numbers. It allows for an optional traceId to aid in transaction tracing.

```APIDOC
## VRFSystem Interface

### Description
This interface defines the method for requesting random numbers from the VRFSystem contract deployed on various chains.

### Method
`requestRandomNumberWithTraceId`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **traceId** (uint256) - Optional - An identifier to trace the request. Defaults to 0 if not provided.

### Request Example
```solidity
// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.26;

uint256 constant ID = uint256(keccak256('com.proofofplay.vrfsystem.v1'));

interface IVRFSystem {
  /**
   * Starts a VRF random number request
   *
   * @param traceId Optional Id to use when tracing the request
   * @return requestId for the random number, will be passed to the callback contract
   */
  function requestRandomNumberWithTraceId(uint256 traceId) external returns (uint256);
}
```

### Response
#### Success Response (200)
- **requestId** (uint256) - The unique identifier for the requested random number.
```

--------------------------------

### Generating Unique Random Numbers

Source: https://docs.proofofplay.com/services/vrng

Default behavior provides the same random number within a 3-second window. To achieve unique numbers per request, developers can add a source of entropy like `requestId` or use hashing techniques.

```APIDOC
## Generating Unique Random Numbers

### Description
By default, a single random number is delivered to all requests within the same 3-second window provided by drand. To obtain unique random numbers for each request during this period, it's recommended to incorporate an additional entropy source.

### Method
N/A (Code Examples)

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Request Example
```solidity
// Add the requestId (Most Gas Efficient)
uint256 newRandomNumber = requestId + randomNumber;

// Hash with requestId
uint256 newRandomNumber = uint256(keccak256(abi.encodePacked(requestId, randomNumber)));

// More expensive, but more normalized, hash based on requestId in last 256 block hashes
uint256 newRandomNumber = uint256(keccak256(abi.encodePacked(blockhash(block.number - (requestId % 256)), randomNumber)));
```

### Response
N/A

### Response Example
N/A
```

--------------------------------

### Handling Random Number Callbacks with IVRFSystemCallback Interface

Source: https://docs.proofofplay.com/services/vrng/about

This Solidity interface defines the callback function that the VRF system uses to deliver the generated random number. The `randomNumberCallback` function receives the `requestId` associated with the request and the generated `randomNumber`. Callbacks are delivered shortly after the request, ensuring the number is not known beforehand.

```solidity
// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.26;

interface IVRFSystemCallback {
  /**
   * Callback for when a Random Number is delivered
   *
   * @param requestId     Id of the request
   * @param randomNumber   Random number that was generated by the Verified Random Number Generator Tool
   */
  function randomNumberCallback(uint256 requestId, uint256 randomNumber) external;
}
```

--------------------------------

### Requesting a Random Number using IVRFSystem Interface

Source: https://docs.proofofplay.com/services/vrng/about

This Solidity interface allows contracts to request a verifiable random number from the VRF system. It supports an optional `traceId` for tracking requests, which is useful for debugging complex transactions. The function returns a `requestId` that will be used in the callback.

```solidity
// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.26;

uint256 constant ID = uint256(keccak256('com.proofofplay.vrfsystem.v1'));

interface IVRFSystem {
  /**
   * Starts a VRF random number request
   *
   * @param traceId Optional Id to use when tracing the request
   * @return requestId for the random number, will be passed to the callback contract
   */
  function requestRandomNumberWithTraceId(uint256 traceId) external returns (uint256);
}
```

--------------------------------

### VRFSystemCallback Interface

Source: https://docs.proofofplay.com/services/vrng/about

Interface for handling the callback when a random number is delivered by the VRF system. This is invoked by the VRF system to return the generated random number.

```APIDOC
## VRFSystemCallback Interface

### Description
This interface defines the callback method that the VRFSystem contract invokes upon successful generation and delivery of a random number.

### Method
`randomNumberCallback`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```solidity
// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.26;

interface IVRFSystemCallback {
  /**
   * Callback for when a Random Number is delivered
   *
   * @param requestId     Id of the request
   * @param randomNumber   Random number that was generated by the Verified Random Number Generator Tool
   */
  function randomNumberCallback(uint256 requestId, uint256 randomNumber) external;
}
```

### Response
#### Success Response (200)
This method is a callback and does not return a standard HTTP response. It is executed externally by the VRF system.

#### Response Example
None
```

--------------------------------

### Generating Unique Random Numbers within a Transaction

Source: https://docs.proofofplay.com/services/vrng

By default, only one random number is provided per transaction. Developers can derive multiple new numbers from this single number using methods like hashing or bitwise operations.

```APIDOC
## Generating Unique Random Numbers within a Transaction

### Description
By default, the API provides a single random number per transaction. Developers are encouraged to derive additional unique numbers from this initial number to suit their needs.

### Method
N/A (Code Examples)

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Request Example
```solidity
// Example 1: Keccak derive
uint256 randomNumber = 12398012938091283113928;
uint256 randomNumber2 = keccak256(randomNumber);
uint256 randomNumber3 = keccak256(randomNumber2);

// Example 2: Split the number and use both sides
uint256 randomNumber = 234345234523452345;
uint256 randomNumber2 = randomNumber >> 128;  // Take upper 128 bits
uint256 randomNumber3 = randomNumber & ((1 << 128) - 1); // Take lower 128 bits
```

### Response
N/A

### Response Example
N/A
```

--------------------------------

### EIP712 Signature Response for Manual Retry (JavaScript)

Source: https://docs.proofofplay.com/services/vrng/about

The expected JSON response structure when requesting an EIP712 signature for manual retry. This response contains the necessary parameters to call the VRF contract's deliverSignedRandomNumber function.

```javascript
{
  "requestId": Number,
  "roundNumber": Number,
  "randomNumber": BigInt,
  "signature": String // bytes data of signature
}
```

--------------------------------

### Blockchain Events

Source: https://docs.proofofplay.com/services/vrng/about

The contract emits events for random number requests and deliveries.

```APIDOC
## Blockchain Events

The contract will emit the following events.

### `RandomNumberRequested`

*   **Description**: Emitted when a random number request is initiated.
*   **Parameters**:
    *   `requestId` (uint256, indexed): The unique identifier for the random number request.
    *   `callbackAddress` (address, indexed): The address the random number is requested to.
    *   `traceId` (uint256, indexed): The trace ID used to track the request across transactions (0 if no trace ID).

### `RandomNumberDelivered`

*   **Description**: Emitted when a random number is successfully delivered.
*   **Parameters**:
    *   `requestId` (uint256, indexed): The unique identifier of the fulfilled request.
    *   `callbackAddress` (address, indexed): The address the random number is requested to.
    *   `traceId` (uint256, indexed): The trace ID associated with the request.
    *   `roundNumber` (uint256): The round number that was used for the random number.
    *   `randomNumber` (uint256): The random number that was generated.

You can query these events on RPC level to see if they were delivered or use the block explorer to view a stream of events.
```

--------------------------------

### Deliver Signed Random Number to VRF Contract (Solidity)

Source: https://docs.proofofplay.com/services/vrng/about

The Solidity function call to deliver a signed random number to the VRF contract. This is used in manual retry scenarios after obtaining an EIP712 signature from the API.

```solidity
vrf.deliverSignedRandomNumber(requestId, roundNumber, randomNumber, signature);
```

--------------------------------

### Generating Unique Random Numbers

Source: https://docs.proofofplay.com/services/vrng/about

Strategies for deriving unique random numbers from the delivered VRF number, useful when multiple users require distinct random values within the same time window or transaction.

```APIDOC
## Generating Unique Random Numbers

### Description
Provides methods to ensure unique random numbers per user or transaction, addressing scenarios where the default VRF delivery might provide the same number to multiple requests within a short period.

### Strategies

#### 1. Unique numbers within the same 3-second window:

By default, all requests within the same 3-second window receive the same VRF number. To ensure uniqueness, you can combine the delivered `randomNumber` with other transaction-specific data.

**Example using `requestId` (Most Gas Efficient):**
```solidity
uint256 newRandomNumber = requestId + randomNumber;
```

**Example using hashing with `requestId`:**
```solidity
uint256 newRandomNumber = uint256(keccak256(abi.encodePacked(requestId, randomNumber)));
```

**Example using hashing with `blockhash` (More Normalized):**
```solidity
uint256 newRandomNumber = uint256(keccak256(abi.encodePacked(blockhash(block.number - (requestId % 256)), randomNumber)));
```
*Note: These methods provide randomness but may require adjustment for normalization based on specific needs.*

#### 2. Unique numbers within the same transaction:

If you need multiple distinct random numbers within a single transaction, derive them from the initially provided VRF number.

**Example 1: Keccak derivation**
```solidity
uint256 randomNumber = 12398012938091283113928;
uint256 randomNumber2 = uint256(keccak256(abi.encodePacked(randomNumber)));
uint256 randomNumber3 = uint256(keccak256(abi.encodePacked(randomNumber2)));
```

**Example 2: Splitting the number**
```solidity
uint256 randomNumber = 2343452345234523452345;
uint256 randomNumber2 = randomNumber >> 128;  // Take upper 128 bits
uint256 randomNumber3 = randomNumber & ((1 << 128) - 1); // Take lower 128 bits
```

*Note: The default delivery ensures the number cannot be known before the user requests it, preserving the integrity of the random number generation.*
```
Tokens:
Raw