chore(dev-docs) Entropy Guide Edits - 1

apps/developer-hub/content/docs/entropy/contract-addresses.mdx

@@ -1,23 +1,15 @@
 ---
 title: Contract Addresses
-description: Entropy contract addresses on different networks
+description: Pyth Entropy contract addresses on EVM networks
 ---
 
-# Entropy Contract Addresses on EVM
+import { EntropyTable } from "../../../src/components/EntropyTable";
 
 ## Mainnets
 
 The Entropy contract is deployed on the following mainnet chains:
 
-| Network   | Contract Address                             | Gas Limit | Provider                                     |
-| --------- | -------------------------------------------- | --------- | -------------------------------------------- |
-| Ethereum  | `0x98046Bd286715D3B0BC227Dd7a956b83D8978603` | 100,000   | `0x52DeaA1c84233F7bb8C8A45baeDE41091c616506` |
-| Arbitrum  | `0x23f0e8FAeE7bbb405E7A7C3d60138FCfd43d7509` | 100,000   | `0x52DeaA1c84233F7bb8C8A45baeDE41091c616506` |
-| Avalanche | `0x36825bf3Fbdf5a29E2d5148bfe7Dcf7B5639e320` | 100,000   | `0x52DeaA1c84233F7bb8C8A45baeDE41091c616506` |
-| Base      | `0x98046Bd286715D3B0BC227Dd7a956b83D8978603` | 100,000   | `0x52DeaA1c84233F7bb8C8A45baeDE41091c616506` |
-| BNB Chain | `0x98046Bd286715D3B0BC227Dd7a956b83D8978603` | 100,000   | `0x52DeaA1c84233F7bb8C8A45baeDE41091c616506` |
-| Optimism  | `0x98046Bd286715D3B0BC227Dd7a956b83D8978603` | 100,000   | `0x52DeaA1c84233F7bb8C8A45baeDE41091c616506` |
-| Polygon   | `0x98046Bd286715D3B0BC227Dd7a956b83D8978603` | 100,000   | `0x52DeaA1c84233F7bb8C8A45baeDE41091c616506` |
+<EntropyTable isMainnet={true} />
 
 **The default provider for above mainnet chains is `0x52DeaA1c84233F7bb8C8A45baeDE41091c616506`.**
 
@@ -30,18 +22,8 @@ The default provider fulfills the request by sending a transaction with a gas li
 
 The Entropy contract is deployed on the following testnet chains:
 
-| Network          | Contract Address                             | Gas Limit | Provider                                     |
-| ---------------- | -------------------------------------------- | --------- | -------------------------------------------- |
-| Ethereum Sepolia | `0x41c9e39574F40Ad34c79f1C99B66A45eFB830d4c` | 100,000   | `0x6CC14824Ea2918f5De5C2f75A9Da968ad4BD6344` |
-| Arbitrum Sepolia | `0x36825bf3Fbdf5a29E2d5148bfe7Dcf7B5639e320` | 100,000   | `0x6CC14824Ea2918f5De5C2f75A9Da968ad4BD6344` |
-| Avalanche Fuji   | `0x36825bf3Fbdf5a29E2d5148bfe7Dcf7B5639e320` | 100,000   | `0x6CC14824Ea2918f5De5C2f75A9Da968ad4BD6344` |
-| Base Sepolia     | `0x41c9e39574F40Ad34c79f1C99B66A45eFB830d4c` | 100,000   | `0x6CC14824Ea2918f5De5C2f75A9Da968ad4BD6344` |
-| BNB Testnet      | `0x41c9e39574F40Ad34c79f1C99B66A45eFB830d4c` | 100,000   | `0x6CC14824Ea2918f5De5C2f75A9Da968ad4BD6344` |
-| Optimism Sepolia | `0x41c9e39574F40Ad34c79f1C99B66A45eFB830d4c` | 100,000   | `0x6CC14824Ea2918f5De5C2f75A9Da968ad4BD6344` |
-| Polygon Amoy     | `0x41c9e39574F40Ad34c79f1C99B66A45eFB830d4c` | 100,000   | `0x6CC14824Ea2918f5De5C2f75A9Da968ad4BD6344` |
+<EntropyTable isMainnet={false} />
 
 **The default provider for above testnet chains is `0x6CC14824Ea2918f5De5C2f75A9Da968ad4BD6344`.**
 
 The default provider on testnet has reveal delays identical to the corresponding mainnet chains to ensure consistent environment.
-
-The default provider fulfills the request by sending a transaction with a gas limit as mentioned in above table. Entropy callbacks the consumer as part of this transaction.

apps/developer-hub/content/docs/entropy/debug-callback-failures.mdx

@@ -3,14 +3,15 @@ title: Debug Callback Failures
 description: How to identify and resolve issues with Entropy callbacks
 ---
 
-# Debug Callback Failures
-
-> 🔍 **Quick Debug Tool**
-> Use the [Entropy Explorer](https://entropy-debugger.pyth.network/) to quickly diagnose and resolve callback issues.
+import { DynamicCodeBlock } from "fumadocs-ui/components/dynamic-codeblock";
 
 This guide explains how to identify and resolve issues with the Entropy callback.
 The intended audience for this guide is developers who have made an Entropy random number request, but their application hasn't received a callback.
 
+> 🔍 **Quick Debug Tool**
+>
+> Use the [Entropy Explorer](https://entropy-debugger.pyth.network/) to quickly diagnose and resolve callback issues.
+
 ## Dependencies
 
 This guide uses [Foundry](https://book.getfoundry.sh/getting-started/installation) to submit transactions to the blockchain.
@@ -22,45 +23,56 @@ Developers can run the Entropy callback themselves to see the reason for the fai
 To run the callback, invoke the `revealWithCallback` function on the Entropy contract on your blockchain.
 The function has the following signature:
 
-```solidity
-function revealWithCallback(
+<DynamicCodeBlock
+  lang="solidity"
+  code={`function revealWithCallback(
     address provider,
     uint64 sequenceNumber,
-    bytes32 userRandomNumber,
-    bytes32 providerRevelation
+    bytes32 userContribution,
+    bytes32 providerContribution
 )
-```
+`}
+/>
 
-This call requires the chain ID, contract address, and four arguments.
+This call requires the chain ID, contract address, and four other arguments.
 The chain ID and contract address can be retrieved from [Contract Addresses](contract-addresses).
 Export these values as environment variables for later use:
 
-```bash
-export CHAIN_ID=blast
+<DynamicCodeBlock
+  lang="bash"
+  code={`export CHAIN_ID=blast
 export ENTROPY_ADDRESS=0x5744Cbf430D99456a0A8771208b674F27f8EF0Fb
-```
+`}
+/>
 
-Three of the arguments can be retrieved from the request transaction's event logs.
+Three of the other arguments can be retrieved from the request transaction's event logs.
 Look at the event logs of the request transaction in a block explorer.
 You should see a `RequestedWithCallback` event emitted from the Entropy contract.
 
 Copy the following values from the event into environment variables:
 
-```bash
-export PROVIDER=0x52DeaA1c84233F7bb8C8A45baeDE41091c616506
+<DynamicCodeBlock
+  lang="bash"
+  code={`export PROVIDER=0x52DeaA1c84233F7bb8C8A45baeDE41091c616506
 export SEQUENCE_NUMBER=12345
 export USER_RANDOM_NUMBER=0x1234...
-```
+`}
+/>
 
-The fourth argument (provider revelation) must be retrieved from the provider's API.
+The fourth argument (provider contribution) must be retrieved from the provider's API.
 This value becomes available after the reveal delay has passed.
 
 ## Common Issues
 
+There are a few common issues that can cause the callback to fail.
+
 ### Gas Limit Exceeded
 
 If your callback function uses too much gas, the transaction will fail. Check the gas limit for your chain on the [contract addresses](contract-addresses) page and ensure your callback function uses less gas.
 
+> 💡 **Tip**
+> Refer to the [Set Custom Gas Limits](set-custom-gas-limits) guide to set a custom gas limit for your callback function.
+
 ### Callback Function Errors
 
 Your callback function might contain logic that throws an error. Review your callback implementation for:
@@ -73,3 +85,4 @@ Your callback function might contain logic that throws an error. Review your cal
 ### Transaction Timing
 
 Make sure you're attempting the callback after the reveal delay has passed. The reveal delay varies by network and helps prevent MEV attacks.
+Refer to the [Contract Addresses](contract-addresses) page for the reveal delay for each network.

apps/developer-hub/content/docs/entropy/generate-random-numbers-evm.mdx

@@ -0,0 +1,190 @@
+---
+title: Generate Random Numbers onchain
+description: Learn how to integrate Pyth Entropy to generate random numbers in your dapp
+---
+
+import { Step, Steps } from "fumadocs-ui/components/steps";
+import { DynamicCodeBlock } from "fumadocs-ui/components/dynamic-codeblock";
+
+This guide explains how to integrate Pyth Entropy into EVM Contracts to generate on-chain random numbers.
+The intended audience for this guide is developers of any application that needs on-chain randomness, such as NFT mints or games.
+
+## Install the SDK
+
+Pyth Entropy has a [Solidity SDK](https://github.com/pyth-network/pyth-crosschain/tree/main/target_chains/ethereum/entropy_sdk/solidity) that lets your contract interact with the Entropy contract.
+Install the SDK using your package manager:
+
+<Tabs items={['hardhat', 'foundry']}>
+<Tab value="hardhat">
+<DynamicCodeBlock lang="shell" 
+code={`npm install @pythnetwork/entropy-sdk-solidity`} />
+</Tab>
+<Tab value="foundry">
+<DynamicCodeBlock lang="shell" code={`npm init -y
+npm install @pythnetwork/entropy-sdk-solidity
+`} />
+
+Then add the following line to your `remappings.txt` file:
+
+<DynamicCodeBlock
+  lang="text"
+  code={`@pythnetwork/entropy-sdk-solidity/=node_modules/@pythnetwork/entropy-sdk-solidity
+`}
+/>
+
+</Tab>
+</Tabs>
+
+## Setup
+
+The Solidity SDK exports two interfaces:
+
+- [`IEntropyConsumer`](https://github.com/pyth-network/pyth-crosschain/blob/main/target_chains/ethereum/entropy_sdk/solidity/IEntropyConsumer.sol) - The interface that your contract should implement. It makes sure that your contract is compliant with the Entropy contract.
+- [`IEntropyV2`](https://github.com/pyth-network/pyth-crosschain/blob/main/target_chains/ethereum/entropy_sdk/solidity/IEntropyV2.sol) - The interface to interact with the Entropy contract.
+  You will need the address of an Entropy contract on your blockchain.
+  Consult the current [Entropy contract addresses](../contract-addresses) to find the address on your chain.
+  Once you have a contract address, instantiate an `console.log("IEntropyV2"){:bash}` contract in your solidity contract:
+
+<DynamicCodeBlock lang="solidity" 
+code={`import { IEntropyConsumer } from "@pythnetwork/entropy-sdk-solidity/IEntropyConsumer.sol";
+import { IEntropyV2 } from "@pythnetwork/entropy-sdk-solidity/IEntropyV2.sol";
+
+// @param entropyAddress The address of the entropy contract.
+contract YourContract is IEntropyConsumer {
+IEntropyV2 public entropy;
+
+constructor(address entropyAddress) {
+entropy = IEntropyV2(entropyAddress);
+}
+}
+`} />
+
+## Usage
+
+To generate a random number, follow these steps.
+
+<Steps>
+<Step>
+### Request a number from Entropy
+
+Invoke the [`requestV2`](https://github.com/pyth-network/pyth-crosschain/blob/main/target_chains/ethereum/entropy_sdk/solidity/IEntropy.sol#L83) method of the `IEntropyV2` interface.
+The `console.log("requestV2"){:bash}` method requires paying a fee in native gas tokens which is configured per-provider.
+
+The fee differs for every chain and also varies over time depending on the chain's current gas price.
+The current value for each chain can be found on the [Current Fees](../current-fees) page.
+However, you should use the on-chain method [`getFeeV2`](https://github.com/pyth-network/pyth-crosschain/blob/main/target_chains/ethereum/entropy_sdk/solidity/IEntropy.sol#L101) to compute the required fee and send it as the value of the `requestV2{:bash}` call.
+
+These methods use the default randomness provider ([see here](#randomness-providers) for more info on providers).
+
+<DynamicCodeBlock lang="solidity" 
+code={`function requestRandomNumber() external payable {
+  uint256 fee = entropy.getFeeV2();
+
+uint64 sequenceNumber = entropy.requestV2{ value: fee }();
+}
+`} />
+
+This method returns a sequence number and emits a [`Requested`](https://github.com/pyth-network/pyth-crosschain/blob/main/target_chains/ethereum/entropy_sdk/solidity/EntropyEventsV2.sol#L30) event. You can store this sequence number to identify the request in next step.
+
+Note that there are several variants of `requestV2` that allow the caller to configure the provider fulfilling the request and the gas limit for the callback. Refer [request callback variants](../request-callback-variants.mdx) for more details.
+
+Please see the method documentation in the [IEntropyV2 interface](https://github.com/pyth-network/pyth-crosschain/blob/main/target_chains/ethereum/entropy_sdk/solidity/IEntropyV2.sol).
+
+</Step>
+<Step>
+
+### Implement the Entropy callback
+
+<DynamicCodeBlock lang="solidity" 
+code={`pragma solidity ^0.8.0;
+
+import { IEntropyConsumer } from "@pythnetwork/entropy-sdk-solidity/IEntropyConsumer.sol";
+import { IEntropyV2 } from "@pythnetwork/entropy-sdk-solidity/IEntropyV2.sol";
+
+contract YourContract is IEntropyConsumer {
+IEntropyV2 entropy;
+
+// @param entropyAddress The address of the entropy contract.
+constructor(address entropyAddress) {
+entropy = IEntropyV2(entropyAddress);
+}
+
+function requestRandomNumber() external payable {
+// Get the fee for the request
+uint256 fee = entropy.getFeeV2();
+
+    // Request the random number with the callback
+    uint64 sequenceNumber = entropy.requestV2{ value: fee }();
+    // Store the sequence number to identify the callback request
+
+}
+
+// @param sequenceNumber The sequence number of the request.
+// @param provider The address of the provider that generated the random number. If your app uses multiple providers, you can use this argument to distinguish which one is calling the app back.
+// @param randomNumber The generated random number.
+// This method is called by the entropy contract when a random number is generated.
+// This method **must** be implemented on the same contract that requested the random number.
+// This method should **never** return an error -- if it returns an error, then the keeper will not be able to invoke the callback.
+// If you are having problems receiving the callback, the most likely cause is that the callback is erroring.
+// See the callback debugging guide here to identify the error https://docs.pyth.network/entropy/debug-callback-failures
+function entropyCallback(
+uint64 sequenceNumber,
+address provider,
+bytes32 randomNumber
+) internal override {
+// Implement your callback logic here.
+}
+
+// This method is required by the IEntropyConsumer interface.
+// It returns the address of the entropy contract which will call the callback.
+function getEntropy() internal view override returns (address) {
+return address(entropy);
+}
+}
+`} />
+
+</Step>
+</Steps>
+
+When the final random number is ready to use, the entropyCallback function will be called by the Entropy contract. This will happen in a separate transaction submitted by the requested provider.
+
+<Callout variant="warning">
+  The `entropyCallback` function on your contract should **never** return an
+  error. If it returns an error, the keeper will not be able to invoke the
+  callback. If you are having problems receiving the callback, please see
+  [Debugging Callback Failures](/entropy/debug-callback-failures).
+</Callout>
+
+## Additional Resources
+
+You may find these additional resources helpful while integrating Pyth Entropy into your EVM contract.
+
+### Debug Callback Failures
+
+Check how to [Debug Callback Failures](../debug-callback-failures) if you are having trouble getting the callback to run.
+
+### Pyth Entropy Contract Addresses
+
+Consult the [Entropy contract addresses](../contract-addresses) to find the Entropy contract address on your chain.
+
+### Current Fees
+
+Check the [Current Fees](../current-fees) to find the current fee for each provider on your chain.
+
+### Best Practices
+
+Check out the [Best Practices](../best-practices) guide for tips to limit gas usage, or generate multiple random numbers in a single transaction.
+
+### Randomness providers
+
+Some methods on Entropy require selecting a **randomness provider**. The randomness provider is a third-party
+who participates in the generation process. Each provider is identified by an address and hosts
+a keeper service for fullfilling requests.
+
+You can get the default provider's address by calling the [`getDefaultProvider`](https://github.com/pyth-network/pyth-crosschain/blob/f8ebeb6af31d98f94ce73edade6da2ebab7b2456/target_chains/ethereum/entropy_sdk/solidity/IEntropy.sol#L94) method:
+
+<DynamicCodeBlock
+  lang="solidity"
+  code={`address provider = entropy.getDefaultProvider();
+`}
+/>

apps/developer-hub/content/docs/entropy/index.mdx

@@ -1,31 +1,33 @@
 ---
 title: Entropy
-description: Random number Generator for Ethereum smart contracts
+description: Secure, Verifiable Random Number Generator for EVM-based smart contracts
 icon: DiceSix
 full: true
 ---
 
-# Entropy
+**Pyth Entropy** is an on-chain random number generator (RNG) designed for developers who need fair, unbiased, and cryptographically secure randomness.
+Whether you're building a blockchain game, NFT mint, lottery, or simulation, Entropy delivers randomness that is:
 
-Pyth Entropy allows developers to quickly and easily generate secure random numbers on the blockchain.
-Entropy's rapid response time allows developers to build applications such as NFT mints and games with responsive UX.
-Entropy also provides [strong security guarantees](protocol-design) to ensure that both users and application developers can trust that the results are random.
+- **Trustless & verifiable** - built on commit-reveal(TODO: link to commit-reveal).
+- **Low-latency** - randomness available within a few blocks(TODO: link to latency).
+- **Easy to integrate** - Permissionless Integration, Visual Tx Explorer(TODO: link to explorer).
+- **Cost-efficient** - designed for scalable production use(TODO: link to fees).
+- **Native gas fees** - pay with chain native token.
 
-Pyth Entropy is currently available on several [EVM networks](contract-addresses).
-If you would like a deployment on another network, please [ask in Discord](https://discord.gg/invite/PythNetwork).
+## What's New in Entropy v2
+
+Entropy v2 introduces several improvements and new features to make random number generation more flexible and efficient.
+See [What's New in Entropy v2](whats-new-entropyv2) for more details.
+(TODO: This can be displayed in a banner above) (TODO: Add aan infographic here)
 
 ## Getting Started
 
 Using Pyth Entropy is permissionless and developers can integrate in a few minutes.
 Please see [How to Generate Random Numbers Using Pyth Entropy](generate-random-numbers) to start integrating Pyth Entropy into your application.
 
-## Additional Resources
-
-To learn more about how the protocol works, please see [Protocol design](protocol-design).
-
 ## Reference Material
 
 - [Protocol design](protocol-design)
-- [Contract Addresses](contract-addresses)
+- [Contract Addresses/Supported Networks](contract-addresses)
 - [Error Codes](error-codes)
 - [Entropy Debugger](https://entropy-debugger.pyth.network/) - Interactive tool for diagnosing callback issues