| Total Supply | -5,587,672.181 stRIF | +Varies and will increase and decrease as RIF is staked and unstaked. | |
| Contract Address | 0x5db91e24BD32059584bbDb831A901f1199f3d459 | ||
| Contract Type | -ERC1967Proxy | +Contract Types | +ERC20, ERC677, ERC1967Proxy |
| How to Get |
|
- ||
| How to Stake | -- |
+ 
+ 
-### Make first API Call
+### Make First API Call
Click on the newly created `apikey` to get the details:
diff --git a/docs/02-developers/07-rpc-api/02-methods.md b/docs/02-developers/07-rpc-api/02-rootstock/02-methods.md
similarity index 99%
rename from docs/02-developers/07-rpc-api/02-methods.md
rename to docs/02-developers/07-rpc-api/02-rootstock/02-methods.md
index 8b95eeb2..cdff10a7 100644
--- a/docs/02-developers/07-rpc-api/02-methods.md
+++ b/docs/02-developers/07-rpc-api/02-rootstock/02-methods.md
@@ -1,17 +1,17 @@
---
-sidebar_label: RPC API Methods
-sidebar_position: 200
-title: RPC API Methods
+sidebar_label: Rootstock RPC API Methods
+sidebar_position: 102
+title: Rootstock RPC API Methods
tags: [faucet, Rootstock, rpc api, testnet, address, wallet, tools]
description: "Easily create, interact and deploy EVM compatible smart contracts using a robust set of JSON RPC methods available through the RPC API."
---
-Find below a list of methods available on the RPC API. See [how to setup the RPC API](/developers/rpc-api/setup/).
+Find below a list of methods available on the Rootstock RPC Service. See [how to setup the Rootstock RPC Service](/developers/rpc-api/rootstock/setup/).
## eth_accounts
- _Method:_ `eth_accounts`
- - Returns a list of addresses owned by the client. Since Rootstock RPC API does not store keys, this will always return empty.
+ - Returns a list of addresses owned by the client. Since Rootstock RPC Service does not store keys, this will always return empty.
- _Params:_ None
```shell
@@ -294,12 +294,13 @@ curl --location 'https://rpc.testnet.rootstock.io/
+
+This simplified flow shows how UTXOs and OP\_RETURN work together to track Rune transactions.
+
+### **Why Use Bitcoin Runes?**
+
+By using these features of Bitcoin, Runes allow token creation and management without needing a separate blockchain. This makes them secure (since they rely on Bitcoinβs strong security) and simple, as they use the same underlying transaction system that Bitcoin already uses.
+
+In short, Bitcoin Runes work by:
+
+1. Tracking tokens using Bitcoin's UTXO model.
+2. Storing token data and actions using the OP\_RETURN field in Bitcoin transactions.
+
+This system lets users create, transfer, and manage tokens on the Bitcoin network in a straightforward way.
+
diff --git a/docs/04-resources/08-runes/_category_.yml b/docs/04-resources/08-runes/_category_.yml
new file mode 100644
index 00000000..c2cf9d93
--- /dev/null
+++ b/docs/04-resources/08-runes/_category_.yml
@@ -0,0 +1,6 @@
+label: Runes
+position: 2
+link:
+ type: generated-index
+ description: The Rootstock Runes Mock Bridge opens up exciting opportunities for developers to build Runes-focused applications within the Rootstock ecosystem. This bridge introduces three core solutions
+ slug: /resources/runes/
diff --git a/docs/04-resources/08-runes/runes-contracts.md b/docs/04-resources/08-runes/runes-contracts.md
new file mode 100644
index 00000000..b5482bd4
--- /dev/null
+++ b/docs/04-resources/08-runes/runes-contracts.md
@@ -0,0 +1,275 @@
+---
+sidebar_position: 3
+title: Runes Contract Explanation walk through
+sidebar_label: Runes Contract Explanation walk through
+tags: [rsk, rootstock, resources, tutorials, setup, Runes, dApps, smart contracts, Remix IDE, MetaMask]
+description: "The Rootstock Runes Mock Bridge setup page shows you how to getting building your runes, by first cloning our project and testing it locally."
+---
+
+### **1\. Understanding the Contract Structure**
+
+This contract defines a new token type, **RuneToken**, based on the **ERC-1155 standard**. It also uses the **Ownable** contract, which restricts certain functions to the contract's owner.
+
+#### **Key Imports:**
+
+```
+import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/utils/Strings.sol";
+```
+
+* **ERC1155**: This is a token standard that supports both fungible and non-fungible tokens within the same contract.
+* **Ownable**: This contract standard restricts certain actions to only the contract's owner (the one who deployed it or someone assigned as the owner).
+* **Strings**: A utility library for working with string conversions.
+
+### **Main Components of the Contract**
+
+#### **Events:**
+
+* `TokensFrozen`: Emits an event when tokens are frozen for a specific account.
+* `TokensUnfrozen`: Emits an event when tokens are unfrozen.
+
+#### **Data Structures:**
+
+* **Balance**: Holds the account and balance of a token.
+* **TokenInfo**: Contains details about a token, such as its URI ( **Uniform Resource Identifier**), name, symbol, maximum supply, current supply, default minting amount, and balance.
+
+#### **Mappings:**
+
+* `_tokenInfos`: Stores the information about each token, keyed by the token ID.
+* `_userTokens`: Tracks all tokens held by a user.
+* `_frozenTokens`: Keeps track of how many tokens are frozen for each user.
+
+###
+
+### **2\. The Constructor**
+
+```
+constructor(address initialOwner) ERC1155("") Ownable(initialOwner) {}
+```
+
+* **ERC1155 ("")**: This calls the ERC1155 constructor, but the URI is set as an empty string initially.
+* **Ownable (initialOwner)**: The `Ownable` contract is initialized with the `initialOwner` as the owner of the contract, allowing only this address to perform certain actions (e.g., minting).
+
+### **3\. The `uri` Function**
+
+```
+function uri(uint256 tokenId) public view override returns (string memory) {
+ return _tokenInfos[tokenId].uri;
+}
+```
+
+This function returns the URI for a given token ID. The URI typically points to a metadata file that contains additional details about the token (e.g., images, descriptions).
+
+### **4\. Minting Fungible Tokens**
+
+```
+function mintFungible(
+ string memory tokenURI,
+ string memory runeName,
+ string memory symbol,
+ uint256 maxSupply,
+ uint256 initialSupply,
+ uint256 defaultMintAmount,
+ address receiver
+) public onlyOwner {
+ // Function logic here
+}
+```
+
+This function allows the owner of the contract to mint fungible tokens.
+
+#### **Steps Involved:**
+
+1. **Check max supply**: Ensure that the initial supply is not greater than the maximum allowed supply.
+2. **Generate a token ID**: A unique token ID is created by hashing the `runeName` using `keccak256`.
+3. **Token ID uniqueness check**: Ensure that the token ID doesn't already exist.
+4. **Save Token Info**: Store details about the token in the `_tokenInfos` mapping.
+5. **Mint the token**: Mint the specified amount (`initialSupply`) to the `receiver` address.
+6. **Track ownership**: Add the minted token to the user's list of owned tokens using `_addUserToken`.
+
+### **5\. Minting Non-Fungible Tokens (NFTs)**
+
+```
+function mintNonFungible(
+ string memory tokenURI,
+ string memory runeName,
+ string memory symbol,
+ address receiver
+) public onlyOwner {
+ // Function logic here
+}
+```
+
+This function is similar to `mintFungible` but for minting non-fungible tokens. A non-fungible token is a unique token, meaning only one exists.
+
+#### **Key Differences:**
+
+* **Max Supply** is always `1` for non-fungible tokens.
+* **Current Supply** is also set to `1`.
+
+### **6\. Minting More Tokens**
+
+```
+function mintMore(
+ string memory runeName,
+ address receiver
+) external onlyOwner {
+ // Function logic here
+}
+```
+
+This function allows the contract owner to mint additional tokens of an existing fungible token, as long as the new supply doesnβt exceed the maximum supply.
+
+#### **Key Steps:**
+
+1. **Check token existence**: Ensure the token exists by checking its `maxSupply`.
+2. **Check supply limits**: Ensure the current supply plus the new minting amount doesnβt exceed the max supply.
+3. **Mint tokens**: Mint more tokens to the `receiver`.
+
+### **7\. Token Freezing and Unfreezing**
+
+#### **Freezing Tokens:**
+
+```
+function freezeTokens(string memory runeName, uint256 amount, address owner) external onlyOwner {
+ // Function logic here
+}
+```
+
+* Freezing tokens restricts the user from transferring them.
+* The function ensures that the account has sufficient tokens to freeze.
+* The frozen amount is added to `_frozenTokens`.
+
+#### **Unfreezing Tokens:**
+
+```
+function unfreezeTokens(string memory runeName, uint256 amount, address owner) external onlyOwner {
+ // Function logic here
+}
+```
+
+* This function unfreezes the tokens, allowing the user to transfer them again.
+* The frozen amount is reduced from `_frozenTokens`.
+
+### **8\. Token Information Queries**
+
+#### **Get Token Information:**
+
+```
+function getTokenInfo(uint256 tokenId, address holder) public view returns (TokenInfo memory) {
+ // Function logic here
+}
+```
+
+* This function retrieves the details about a token (such as URI, name, symbol, max supply, etc.).
+* It can also include the token balance of a specific `holder` if the `holder` address is provided.
+
+
+#### **Get Tokens Owned by a User:**
+
+```
+function getUserTokens(address user) public view returns (uint256[] memory) {
+ return _userTokens[user];
+}
+```
+
+* This function returns a list of all token IDs owned by a specific user.
+
+### **9\. Token Transfer Functions with Freezing Consideration**
+
+ERC1155 includes transfer functions (`safeTransferFrom` and `safeBatchTransferFrom`). These are overridden in this contract to take into account frozen tokens.
+
+```
+function safeTransferFrom(
+ address from,
+ address to,
+ uint256 id,
+ uint256 amount,
+ bytes memory data
+) public virtual override {
+ require(balanceOf(from, id) >= amount + _frozenTokens[id][from], "Insufficient unlocked balance for transfer");
+ super.safeTransferFrom(from, to, id, amount, data);
+}
+```
+
+This ensures that users cannot transfer frozen tokens. The contract checks that the unlocked balance (total balance minus frozen balance) is sufficient before allowing transfers.
+
+### **10\. Overriding `balanceOf` to Consider Frozen Tokens**
+
+```
+function balanceOf(address account, uint256 tokenId) public view override returns (uint256) {
+ uint256 totalBalance = super.balanceOf(account, tokenId);
+ uint256 frozenBalance = _frozenTokens[tokenId][account];
+ return totalBalance - frozenBalance;
+}
+```
+
+This function returns the number of **unfrozen** tokens owned by a user for a specific token ID.
+
+:::info[Complete Codebase on GitHub]
+[**Complete RSK-Runes**](https://github.com/rsksmart/rsk-runes/tree/main/contracts)
+:::
+
+
+## **Smart Contract Deployment**
+
+To deploy the Runes smart contract using Remix IDE, follow these steps in detail:
+
+### **Step 1: Access Remix IDE**
+
+1. Open your web browser and go to [Remix IDE](https://remix.ethereum.org/#lang=en&optimize=false&runs=200&evmVersion=null&version=soljson-v0.8.26+commit.8a97fa7a.js).
+
+### **Step 2: Create a New File**
+
+
+
+1. In the Remix IDE, navigate to the **File Explorer** (the first icon on the left sidebar).
+2. Click on the **file** icon to create a new file.
+3. Name the file `RuneToken.sol`.
+
+### **Step 3: Copy and Paste the Smart Contract**
+
+1. Locate the `RuneToken.sol` file from the RSK-RUNES repository under the contracts folder
+
+
+
+2. Open the `RuneToken.sol` file and copy the entire smart contract code.
+3. Paste the copied code into the newly created `RuneToken.sol` file in Remix IDE.
+
+
+
+4. Click on the **Save** icon (the disk icon) to save the file.
+
+###
+
+### **Step 4: Compile the Smart Contract**
+
+
+
+1. Go to the **Solidity Compiler** tab (the third icon in the left sidebar).
+2. Make sure the compiler version matches `0.8.26`. If not, select the correct version from the dropdown menu.
+3. Click on the **Compile RuneToken.sol** button. A green check icon inside a circle will appear, indicating that the compilation was successful.
+
+### **Step 5: Deploy the Smart Contract**
+
+
+
+1. Navigate to the **Deploy & Run Transactions** tab (the fourth icon in the left sidebar).
+2. Under **Environment**, select **Remix VM**
+3. In the **Account** dropdown, copy the first address by clicking the icon next to it.
+4. Paste the copied address into the **Deploy** input field.
+5. Click the **Deploy** button.
+
+### **Step 6: Copy the Smart Contract Address**
+
+
+
+1. After deployment, scroll down to see the **Deployed Contracts** section.
+2. You will find the generated smart contract address listed there. Copy this address for your records.
+
+### **Alternative Method to Copy the Contract Address**
+
+1. Alternatively, you can also copy the contract address from the **Transaction Receipt** that appears after deployment.
+2. Look for the contract address in the receipt and copy it as well.
+
diff --git a/docs/04-resources/08-runes/runes-setup.md b/docs/04-resources/08-runes/runes-setup.md
new file mode 100644
index 00000000..09ecdda3
--- /dev/null
+++ b/docs/04-resources/08-runes/runes-setup.md
@@ -0,0 +1,234 @@
+---
+sidebar_position: 2
+title: Runes Setup
+sidebar_label: Runes Setup
+tags: [rsk, rootstock, resources, tutorials, setup, Runes, dApps, smart contracts, Remix IDE, MetaMask]
+description: "The Rootstock Runes Mock Bridge setup page shows you how to getting building your runes, by first cloning our project and testing it locally."
+---
+
+
+
+### **Prerequisites**
+
+Before getting started with the Runes Mock Bridge, ensure you have the following prerequisites in place:
+
+1. **Familiarity with Remix IDE**
+ You should have a basic understanding of how to use Remix IDE, an online platform for writing, compiling, and deploying Solidity smart contracts.
+2. **Knowledge of Solidity**
+ A solid grasp of Solidity, the smart contract programming language, is essential. You'll be writing or interacting with Solidity contracts as part of this process.
+3. **MetaMask Wallet Installed and Connected to Rootstock Testnet**
+ Make sure you have [MetaMask](https://dev.rootstock.io/dev-tools/wallets/metamask/) installed in your browser, and know how to connect it to the Rootstock (RSK) network for managing your transactions.
+4. **Rootstock Account**
+ You'll need an account on the[RPC API Dashboard](https://dashboard.rpc.rootstock.io/login). This will allow you to create API keys for interacting with the Rootstock blockchain via RPC.
+5. **Local Copy of `bc-runes-js` Package**
+ Clone the [`bc-runes-js`](https://github.com/rsksmart/bc-runes-js) package to your local environment. This package is necessary for generating a Taproot address and Wallet Import Format (WIF) key, which are required for the bridge.
+
+Once these prerequisites are in place, you'll be ready to proceed with setting up and using the Runes Mock Bridge effectively.
+
+### **Setting Up the `.env` File for the Runes Mock Bridge**
+
+```
+NEXT_PUBLIC_APP_PK='your-private-key'
+NEXT_PUBLIC_RPC_URL='your rsk rpc url'
+NEXT_PUBLIC_EXPLORER_URL=https://blockstream.info/testnet/tx
+NEXT_PUBLIC_RSK_EXPLORER_URL= https://explorer.testnet.rootstock.io/tx
+NEXT_PUBLIC_CONTRACT_ADDRESS='your erc1155 contract address'
+NEXT_PUBLIC_TAPROOT_ADDRESS='your taproot address'
+NEXT_PUBLIC_WIF='your wif key'
+```
+
+To run the **Runes Mock Bridge** effectively, you'll need to set up the environment variables in a `.env` file. These variables are crucial for connecting your application to the blockchain network, accessing private keys, and managing other sensitive configurations.
+
+Here's a detailed guide on what each environment variable means, how to get them, and how to set up your `.env` file correctly.
+
+#### **1\. `NEXT_PUBLIC_APP_PK='your-private-key'`**
+
+This is the private key for your application, which is essential for signing transactions or interacting with the blockchain via the Runes Mock Bridge
+
+:::info[Info]
+ Please avoid using a wallet that contains real funds for these exercises. Using an empty wallet ensures your funds remain secure and reduces the risk of unintentional loss.
+:::
+
+* You can obtain your private key from your wallet. Typically, you will export the private key from the wallet software you're using (like MetaMask or any other supported wallet).
+* Follow a detailed tutorial specific to your wallet on how to extract your private key, and then input it here.
+
+#### **2\. `NEXT_PUBLIC_RPC_URL='your RSK RPC URL'`**
+
+The Remote Procedure Call (RPC) URL is how your Runes Mock Bridge interacts with the Rootstock (RSK) blockchain.
+
+* To get the RSK RPC URL, go to the[RPC API Dashboard](https://dashboard.rpc.rootstock.io/login) and log in. After logging in, you can create an API key that will give you access to the RPC URL.
+* Once the key is generated, you can use it to set up this variable, which allows your bridge to communicate with the blockchain.
+
+#### **3\. `NEXT_PUBLIC_EXPLORER_URL=https://blockstream.info/testnet/tx`**
+
+This is the URL for the **Bitcoin Testnet Explorer** provided by Blockstream, where you can track Bitcoin testnet transactions.
+
+:::note[Note]
+This value remains constant and doesn't need to be changed, as it will always point to the Bitcoin testnet explorer.
+:::
+
+#### **4\. `NEXT_PUBLIC_RSK_EXPLORER_URL=https://explorer.testnet.rootstock.io/tx`**
+
+This is the URL for the **Rootstock Testnet Explorer**, where you can track transactions related to the Rootstock network.
+
+:::note[Note]
+Like the Blockstream explorer URL, this value is also constant and doesn't need to be changed. It is set to the correct Rootstock testnet explorer.
+:::
+
+#### **5\. `NEXT_PUBLIC_CONTRACT_ADDRESS='your ERC-1155 contract address'`**
+
+:::info[Important]
+The RuneToken implementation used is not a standard ERC-1155 contract. It includes custom functions to freeze tokens transferred from Rootstock to Bitcoin. To ensure compatibility, please use the same (or an improved) version of the smart contract available in this repository: [RuneToken.sol](https://github.com/rsksmart/rsk-runes/blob/main/contracts/RuneToken.sol) and deploy it.
+:::
+
+
+This variable is used to specify the address of your deployed ERC-1155 contract, which plays a key role in the bridge's functionality.
+
+* You need to deploy your ERC-1155 contract using Remix IDE or a similar tool. Once the deployment is complete, you will get the contract address.
+* Copy the contract address from Remix IDE after deployment and paste it into this variable.
+
+#### **6\. `NEXT_PUBLIC_TAPROOT_ADDRESS='your taproot address'`**
+
+Taproot addresses are used for Bitcoin transactions with improved privacy and flexibility. The [Runes Mock Bridge](https://github.com/rsksmart/rsk-runes) requires a Taproot address for interacting with Bitcoin's taproot transactions.
+
+* You can generate a Taproot address using a special package weβve created. Follow these steps:
+ 1. Clone the repository from [bc-runes-js](https://github.com/rsksmart/bc-runes-js.git).
+ 2. Run `npm install` to install all the required dependencies.
+ 3. Run `npm run generate-address` to generate the Taproot address.
+* Once generated, copy the Taproot address from the output and paste it into this variable.
+
+```
+> bc-runes-js@0.3.2 generate-address
+> node src/utils/address.js --log=address
+
+No WIF set, generating new random address
+{
+ taprootAddress: 'tb1pl9lcxu4f373dpzqzvq5amcm8het2chgwc45yhtlxkz5r66dq2zcqhfvrnx',
+ WIF: 'cQwnr3fnmrkEPYNpCnsHqn7opcEwfezKbmadBD8b85XozXQCZyzP'
+}
+
+```
+> you can generate multiple taproot address
+
+#### **7\. `NEXT_PUBLIC_WIF='your WIF key'`**
+
+The Wallet Import Format (WIF) key is the encoded version of your Bitcoin private key, which is necessary for signing Bitcoin transactions on the testnet.
+
+* The same package used to generate the Taproot address will also generate the WIF key.
+ 1. After running `npm run generate`, you will get both the Taproot address and the WIF key as part of the output.
+ 2. Copy the WIF key and paste it into this variable.
+
+
+
+:::note[Note]
+**Security:** Ensure that the `.env` file is kept private and not exposed in public repositories or shared with unauthorized people. This file contains sensitive information such as your private keys, which could be exploited if leaked.
+
+**Testing:** If you are using testnets (like Bitcoin or Rootstock testnets), make sure to configure your RPC URL, private keys, and contract addresses to match the appropriate testnet environment. This ensures that you're not interacting with the mainnet during development.
+:::
+
+
+## **Installation Guide**
+
+To clone and run the Runes Mock Bridge project locally, follow these steps:
+
+#### **1\. Clone the Repository:**
+
+```
+git clone https://github.com/rsksmart/rsk-runes.git
+cd rsk-runes
+```
+
+#### **2\. Install Dependencies:**
+
+Use either `yarn` or `npm` to install the necessary dependencies:
+
+```
+yarn
+or
+npm install
+```
+
+#### **3\. Access the Application:**
+
+Once the installation is complete, start the development server and access the application in your browser by visiting:
+
+```
+http://localhost:3000
+```
+
+
+
+1. **Click on "Connect Wallet"**:
+
+ * Locate and click the **"Connect Wallet"** button. This is typically found in the top right corner of the platform.
+
+2. **Select MetaMask**:
+
+ * From the list of available wallets, select **MetaMask**.
+
+3. **Follow the On-Screen Instructions**:
+
+ * Once connected, your wallet address will appear on the platform, indicating that your MetaMask wallet is successfully linked.
+
+## Mint Runes on Rootstock
+
+After logging in, follow the steps below to mint a new rune.
+
+1. **Check Your MetaMask Wallet**:
+ * At the top right of the screen, you will see your connected MetaMask wallet address (Rootstock network). Ensure it's the correct wallet before proceeding.
+2. **NFT Toggle (Optional)**:
+ * If you're minting an NFT, turn on the **NFT** toggle switch. Otherwise, leave it off to mint a standard token.
+3. **Name**:
+ * **Description**: Enter the name of your rune, which will serve as its identifier.
+ * **Example**: You might name it something like "EventRune."
+4. **Symbol**:
+ * **Description**: Enter a single character (letter, number, or symbol) as the token symbol.
+ * **Example**: Use something simple like "R" or "$."
+5. **Premine**:
+ * **Description**: This is the amount of runes that will be minted immediately to the rune creator.
+ * **Example**: Enter "10" to pre-mine 10 runes directly into your wallet.
+6. **Amount**:
+ * **Description**: Define the number of runes minted per transaction.
+ * **Example**: Enter "1" to mint one rune per transaction.
+7. **Cap**:
+ * **Description**: The maximum number of runes that can be minted, excluding pre-mined runes.
+ * **Example**: Set it to "100" if you want to limit the total rune supply to 100\.
+8. **Receiver**:
+ * **Description**: This will automatically fetch your Rootstock wallet address where the minted runes will be sent.
+9. **Etch Token**:
+ * After filling out all the fields, click the **"Etch Token"** button to start the minting process.
+10. **Wait for Confirmation**:
+ * Once you've clicked **Etch Token**, you will see a screen that informs you that your transaction is being processed.
+ * **Example**: The screen will show that it is waiting for multiple confirmations (e.g., "Waiting for 7 confirmations"). During this time, the network is validating your transaction.
+ * You will need to wait until the required number of confirmations is reached before the rune minting process is complete.
+11. **Runes List**:
+* After the confirmations are completed, your newly minted rune will appear in the **Runes List** at the bottom of the screen, displaying all the runes you've created.
+
+
+12. **Log Out**:
+* If you're done, click the **"Logout"** button at the top right of the screen to securely end your session.
+
+### Bridge Runes to BTC
+
+
+
+Once you've successfully minted your rune, you can bridge it to BTC. Follow the instructions below.
+
+1. **Click on the "Bridge" Button**:
+ * After minting your rune (like the one shown in the image above), click on the **"Bridge"** button next to the rune you want to convert to BTC.
+ * This will take you to the bridging screen.
+2. **Enter the Required Details**:
+ * On the new screen, you'll be prompted to enter the following information:
+ * **Name**:
+ * **Description**: Enter the name of the rune you want to bridge. This should match the name of the rune you created earlier.
+ * **Example**: If you named your rune "EventRune," enter that as the name.
+ * **Amount**:
+ * **Description**: Enter the number of runes you want to bridge to BTC.
+ * **Example**: If you want to bridge 10 runes, enter "10."
+ * **BTC Address**:
+ * **Description**: Enter your Bitcoin wallet address where the BTC equivalent will be sent after the rune is bridged.
+ * **Example**: Ensure this is a valid BTC wallet address (e.g., "bc1q...").
+3. **Click "Runes to BTC" Button**:
+ * After filling in the details, click on the **"Runes to BTC"** button to initiate the bridging process.
+ * The system will process the bridging, and your runes will be converted to BTC and sent to the provided BTC address.
+
diff --git a/docs/05-dev-tools/data/thegraph.md b/docs/05-dev-tools/data/thegraph.md
index 33b7a807..5229fbe0 100644
--- a/docs/05-dev-tools/data/thegraph.md
+++ b/docs/05-dev-tools/data/thegraph.md
@@ -54,7 +54,7 @@ Run the following command locally:
npm install -g @graphprotocol/graph-cli
```
-> You must have at least v0.76.0 to deploy subgraphs on Rootstock mainnet.
+> You must have at least v0.85.0 to deploy subgraphs on Rootstock mainnet and testnet.
### Initialize a Subgraphβ
diff --git a/docs/05-dev-tools/wallets/metamask.mdx b/docs/05-dev-tools/wallets/metamask.mdx
index 628dce08..edef75e0 100644
--- a/docs/05-dev-tools/wallets/metamask.mdx
+++ b/docs/05-dev-tools/wallets/metamask.mdx
@@ -14,14 +14,15 @@ In this guide, you will learn about the different ways to set up and connect to
> Ideal for general users looking to automatically add the Rootstock network to their MetaMask wallet.
-1. Install MetaMask on your browser from the oficial website: [https://metamask.io/download/](https://metamask.io/download/)
+1. Install MetaMask on your browser from the official website: [https://metamask.io/download/](https://metamask.io/download/)
2. Click on the buttons below to add Rootstock Mainnet and Rootstock Testnet
+
## Option 3: Add Rootstock Networks to MetaMask Programmatically
-> Ideal for developers looking to initiate a network switch on MetaMask from a website or dApp.
-See how to [Connect Rootstock to Metamask Programmatically](/resources/tutorials/rootstock-metamask/).
-
+> Ideal for developers looking to initiate a network switch on MetaMask from a website or dApp.
+> See how to [Connect Rootstock to Metamask Programmatically](/resources/tutorials/rootstock-metamask/).
## Watch the Video Explainer
@@ -164,6 +177,7 @@ A **workaround** for this is to lowercase the addresses after copying them.
- This tutorial uses the Public Nodes as RPC. You can connect to other nodes or use the [Rootstock RPC API](/developers/rpc-api/).
- The node must enable CORS for browser-based dApps to work.
- Please review the [configuration file reference](/node-operators/setup/configuration/) for CORS settings.
+
:::
## Next Steps
diff --git a/docusaurus.config.js b/docusaurus.config.js
index e871bc5d..360aa0f2 100644
--- a/docusaurus.config.js
+++ b/docusaurus.config.js
@@ -239,7 +239,7 @@ const config = {
appId: 'WAFPQL14PU',
// Public API key: it is safe to commit it
- apiKey: '4da8ccafcd04d9c5efd1601a60658bce',
+ apiKey: '78aa26683ec349ff7e4a7c2d723e4cb7',
indexName: 'dev-rootstock',
diff --git a/src/components/CardsGrid/Card/index.js b/src/components/CardsGrid/Card/index.js
new file mode 100644
index 00000000..ea7d54ac
--- /dev/null
+++ b/src/components/CardsGrid/Card/index.js
@@ -0,0 +1,36 @@
+import React from "react";
+import clsx from "clsx";
+import Button from "/src/components/Button";
+
+import styles from "./styles.module.scss";
+
+export default function Card({value, subtitle, title, description, color = "orange", className, linkHref, linkTitle, image, ...props}) {
+
+ return
+ {image && (
+ 
+ )}
+
+}
diff --git a/src/components/CardsGrid/Card/styles.module.scss b/src/components/CardsGrid/Card/styles.module.scss
new file mode 100644
index 00000000..215fae55
--- /dev/null
+++ b/src/components/CardsGrid/Card/styles.module.scss
@@ -0,0 +1,10 @@
+.Card{
+ --rsk-card-main-color: var(--bs-orange);
+ a:not([class*="btn"]){
+ color: var(--rsk-card-main-color);
+ text-decoration: underline;
+ &:hover {
+ text-decoration: none;
+ }
+ }
+}
diff --git a/src/components/CardsGrid/index.js b/src/components/CardsGrid/index.js
new file mode 100644
index 00000000..99d3c770
--- /dev/null
+++ b/src/components/CardsGrid/index.js
@@ -0,0 +1,17 @@
+import React from "react";
+import clsx from "clsx";
+import styles from './styles.module.scss';
+
+export default function CardsGrid({children, className, ...props}) {
+ const childItems = (Array.isArray(children) ? children : [children]).filter(
+ Boolean,
+ );
+
+ return
+ {subtitle && (
+
+ {subtitle}
+
+ )}
+
+ {description && (
+ {title}
+
+ {description}
+
+ )}
+ {linkHref && (
+
+ )}
+
+ {childItems.map((tabItem, i) =>
+
+ {tabItem}
+
+ )}
+
+}
diff --git a/src/components/CardsGrid/styles.module.scss b/src/components/CardsGrid/styles.module.scss
new file mode 100644
index 00000000..f2aa97ec
--- /dev/null
+++ b/src/components/CardsGrid/styles.module.scss
@@ -0,0 +1,7 @@
+.CardsGrid{
+ display: grid;
+ gap: 16px;
+ @media (min-width: 768px) {
+ grid-template-columns: repeat(2, 1fr);
+ }
+}
diff --git a/src/components/Carousel/CarouselItem/index.js b/src/components/Carousel/CarouselItem/index.js
new file mode 100644
index 00000000..0734bd49
--- /dev/null
+++ b/src/components/Carousel/CarouselItem/index.js
@@ -0,0 +1,26 @@
+import React from "react";
+import clsx from "clsx";
+import Link from '/src/components/Link';
+
+import {SplideSlide} from "@splidejs/react-splide";
+
+export default function CarouselItem({title, href, target, image, ...props}) {
+
+ const TagName = ({href, children, title, ...props}) => {
+ return href ? (
+
+ {children}
+
+ ) : (
+
+ {children}
+
+ )
+ }
+
+ return image &&
+ 
+