diff --git a/docs/04-resources/08-runes/airdrop/_category_.yml b/docs/04-resources/08-runes/airdrop/_category_.yml
new file mode 100644
index 00000000..d6203e81
--- /dev/null
+++ b/docs/04-resources/08-runes/airdrop/_category_.yml
@@ -0,0 +1,6 @@
+label: Build A Giveaway Airdrop Machine
+position: 4
+link:
+ type: generated-index
+ description: This guide will focus on airdrops on the Rootstock network, highlighting how they function and the unique benefits they offer to users. A particular focus will be on the Runes Giveaway Machine Airdrop Claim, where you will learn how to install and use this innovative tool to claim your tokens easily.
+ slug: /resources/runes/
diff --git a/docs/04-resources/08-runes/airdrop/airdrop-Intro.md b/docs/04-resources/08-runes/airdrop/airdrop-Intro.md
new file mode 100644
index 00000000..c8b01654
--- /dev/null
+++ b/docs/04-resources/08-runes/airdrop/airdrop-Intro.md
@@ -0,0 +1,47 @@
+---
+sidebar_position: 1
+title: Introduction to Airdrops on Bitcoin
+sidebar_label: Introduction
+tags: [rsk, rootstock, resources, tutorials, runes, nft, Ethereum, dApps, smart contracts, airdrop]
+description: "Airdrops are a way for cryptocurrency projects to distribute free or sometimes paid tokens to users, often to promote a new project or reward loyal users. "
+---
+
+
+
+Airdrops are a way for cryptocurrency projects to distribute free or sometimes paid tokens to users, often to promote a new project or reward loyal users.
+
+While most airdrops are associated with Ethereum-based tokens, Bitcoin also has its own share of airdrops. One exciting example is the **Runes giveaway machine Airdrop claim**, which we’ll dive into later to explain how to install and use it.
+In this guide, you will learn about airdrops, focusing on how they serve as a tool for cryptocurrency projects to engage with their communities.
+
+You will gain an understanding of what airdrops are, including their purpose in promoting new projects and rewarding loyal users.
+This guide will focus on airdrops on the Rootstock network, highlighting how they function and the unique benefits they offer to users. A particular focus will be on the Runes Giveaway Machine Airdrop Claim, where you will learn how to install and use this innovative tool to claim your tokens easily.
+
+Additionally, you will learn the process of building your airdrop machine, you can create your token distribution systems for future projects.
+
+## What is an Airdrop?
+An airdrop refers to the distribution of cryptocurrency tokens or coins, usually free of charge, to users. The main reasons for this distribution include promoting a new project, rewarding users, or building a community around a token. Generally, users must meet certain criteria, such as holding a particular cryptocurrency or signing up for the project, to receive the airdrop.
+
+## Airdrops on Bitcoin
+Although Bitcoin isn’t as widely used for airdrops as Ethereum, a few notable projects use its technology to offer them. These airdrops may come from Bitcoin forks or projects built on Bitcoin’s Layer 2 solutions.
+
+For example:
+- **Fork Airdrops:** When a fork of Bitcoin happens (e.g., Bitcoin Cash), users holding Bitcoin at the time of the fork automatically receive an equal amount of the new currency.
+- **Layer 2 Airdrops:** Some projects that utilize Bitcoin’s second-layer solutions, like the Lightning Network, reward users through airdrops to encourage adoption and participation in new services.
+
+## The Runes Giveaway Machine Airdrop Claim
+
+One of the more exciting developments in the Bitcoin airdrop space is the Runes giveaway machine Airdrop claim. This project is an open-source proof of concept that implements an **Airdrop dApp** (decentralized application).
+
+It allows users to claim airdropped tokens in a decentralized manner, making the process transparent and secure. Below is a breakdown of the technologies used in this project and how to get started with installation.
+
+### Technologies Used
+- OpenZeppelin Standards: These are widely used, secure smart contract libraries that help with the development of blockchain applications.
+- Ethers.js: A powerful library for interacting with the Ethereum blockchain, used here for its flexible capabilities in building dApps.
+
+## Why Are Airdrops Important?
+Airdrops serve several key purposes in the cryptocurrency ecosystem:
+1. **Building Awareness:** Airdrops are an effective way to introduce users to new projects, fostering quick community growth.
+2. **Rewarding Users:** Loyal users or early adopters often receive airdrops as a way of thanking them for their support.
+3. **Creating Liquidity:** By distributing tokens to a wide user base, projects can increase the liquidity of their tokens.
+4. **Decentralization:** Airdrops help spread ownership of tokens, ensuring that the token distribution is more decentralized.
+
diff --git a/docs/04-resources/08-runes/airdrop/airdrop-setup.md b/docs/04-resources/08-runes/airdrop/airdrop-setup.md
new file mode 100644
index 00000000..fcd0bbdc
--- /dev/null
+++ b/docs/04-resources/08-runes/airdrop/airdrop-setup.md
@@ -0,0 +1,128 @@
+---
+sidebar_position: 2
+title: Setup Airdrop Machine
+sidebar_label: Setup
+tags: [rsk, rootstock, resources, tutorials, runes, nft, Ethereum, dApps, smart contracts, airdrop]
+description: "This shows you steps to set up your airdrop giveaway machine"
+---
+
+## **Prerequisite**
+
+Before going further in this guide, it's essential to have the following foundational knowledge and tools in place:
+
+1. **Familiarity with Remix IDE:**
+ * Understanding how to navigate and utilize Remix IDE is crucial. This includes knowledge of its features, such as the Solidity compiler, file management, and debugging tools. Being comfortable with the IDE will enable you to write, test, and deploy smart contracts efficiently.
+2. **Basic Knowledge of Solidity:**
+ * A foundational grasp of Solidity, the primary programming language for Ethereum smart contracts, is necessary. This should include familiarity with basic syntax, data types, functions, and contract structures. You should be able to write simple smart contracts and understand how to interact with them.
+3. **Git Installation:**
+ * Ensure that Git is installed on your machine. Familiarity with Git will help you manage version control effectively, collaborate with others, and track changes to your code.
+
+#### **Installation**
+
+To install and run the Runes giveaway machine Airdrop claim locally, follow these steps:
+
+1. **Clone the Repository**:
+
+```
+git clone https://github.com/rsksmart/airdrop-ui.git
+cd airdrop-ui
+```
+
+2. **Install Dependencies**:
+Run the following command to install the necessary packages:
+
+```
+npm install
+```
+
+3. **Configure Environment Variables**: Create a `.env` file in the root directory and add the necessary environment variables. Below is an example of how to configure the environment variables:
+
+```
+NEXT_PUBLIC_AIRDROP_MANAGER_ADDRESS=
+NEXT_PUBLIC_RPC_URL=
+NEXT_PUBLIC_EXPLORER=
+```
+
+### Explanation with added context for each environment variable:
+
+```
+NEXT_PUBLIC_AIRDROP_MANAGER_ADDRESS=
+```
+
+This variable specifies the address of the Airdrop Manager smart contract. To ensure your application interacts with it correctly, you'll need to deploy this contract using Remix IDE. After deployment, copy the contract's address and paste it here.
+
+:::info[Info]
+
+For detailed instructions on obtaining the Airdrop Manager address, please refer to the [Deploy](docs/04-resources/09-Airdrop/deploy.md) section
+
+:::
+
+```
+NEXT_PUBLIC_RPC_URL=
+```
+
+This variable holds the URL of the Remote Procedure Call (RPC) endpoint for your blockchain network. It allows your application to communicate with the blockchain by sending requests and receiving responses. Be sure to replace `` with the actual URL provided by your blockchain service provider.
+
+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 [RSK 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.
+
+```
+NEXT_PUBLIC_EXPLORER=https://explorer.testnet.rootstock.io/tx
+```
+
+This variable contains the URL of your blockchain explorer. A blockchain explorer is a tool that allows you to view transactions, addresses, and other activities on the blockchain. Replace `` with this `https://explorer.testnet.rootstock.io/tx`
+
+:::warning[Info]
+
+Make sure to replace the placeholders with your actual values before deploying your application\!
+
+:::
+
+4. **Run the Development Server**:
+To start the development server, use the command:
+
+```
+npm run dev
+```
+
+Once installed, this project can be used to claim airdrops via a decentralized application, adding another layer of utility to the Bitcoin ecosystem.
+
+## **Frontend Integration Guide**
+
+Once you have the application running locally, follow these steps to interact with the airdrop functionality:
+
+1. **Connect Your Wallet:**
+
+
+
+* Click on the **"Connect Wallet"** button.
+ * This will prompt you to connect to your MetaMask wallet. Follow the on-screen instructions to complete the connection.
+2. **Wait for Airdrops to Load:**
+ * After connecting your wallet, give it a few moments for the list of available airdrops to load. You can find these airdrops by scrolling down the screen.
+3. **Choose Your Action:**
+
+
+
+* At this point, you have two options:
+ * **Create a new airdrop**, or
+ * **Claim available airdrops**.
+4. **Understanding the Airdrop Card:**
+ * The first airdrop on the list is called **“Test”**. Here's a breakdown of what you’ll see on the airdrop card:
+ * **Progress bar** showing the status of the airdrop.
+ * **Amount to receive**, which indicates how many tokens you can claim.
+ * **Available to claim** section with the wallet address eligible for the airdrop.
+ * A **"Claim"** button.
+5. **Claiming the Airdrop:**
+
+
+
+* Click the **"Claim"** button on the airdrop card.
+ * You will be directed to a screen where you can proceed to claim your tokens.
+ * Wait for a few moments for the transaction to complete.
+6. **Viewing the Transaction:**
+ * After successfully claiming your airdrop, click on the **"View Transaction"** button.
+ * This will take you to the Rootstock explorer, where you can view the details of your transaction.
+
+
\ No newline at end of file
diff --git a/docs/04-resources/08-runes/airdrop/deploy.md b/docs/04-resources/08-runes/airdrop/deploy.md
new file mode 100644
index 00000000..840a3084
--- /dev/null
+++ b/docs/04-resources/08-runes/airdrop/deploy.md
@@ -0,0 +1,78 @@
+---
+sidebar_position: 3
+title: Deploying the Airdrop Machine Smart Contract Using Remix IDE
+sidebar_label: Deploy Airdrop Machine
+tags: [rsk, rootstock, resources, tutorials, runes, nft, Ethereum, dApps, smart contracts, airdrop]
+description: "This guide will walk you through deploying the Airdrop Machine smart contract using Remix IDE. The Airdrop Machine is designed to distribute tokens across multiple addresses, supporting both standard and Merkle tree-based airdrops.
+"
+---
+This section will walk you through deploying the Airdrop Machine smart contract using Remix IDE. The Airdrop Machine is designed to distribute tokens across multiple addresses, supporting both standard and [Merkle tree-based](https://www.investopedia.com/terms/m/merkle-tree.asp) airdrops.
+
+By following these instructions, you'll learn how to clone the necessary repository, prepare the contracts, and deploy them in Remix IDE.
+
+## **Step 1: Clone the Repository**
+
+Clone the Airdrop template repository from the link below:
+```
+git clone https://github.com/rsksmart/airdrop-template.git
+```
+
+This repository contains all the smart contract code you need to deploy the Airdrop Machine. You’ll use this code to get the smart contract address required for your project.
+
+> Basic knowledge of deploying and testing smart contracts in Remix IDE is required. If you’re unfamiliar, please refer to the [Remix Quickstart Guide](/developers/quickstart/remix/) for a detailed tutorial.
+
+## **Step 2: Prepare the Contracts for Remix IDE**
+
+1. Navigate to the cloned repository and locate the `contracts` folder.
+2. Copy the code from both `AirdropManager.sol` and `Administrable.sol` contracts. These files are crucial because the `AirdropManager` contract imports functions from `Administrable.sol`.
+3. Paste the contents of both contracts into Remix IDE.
+
+
+
+**Note:** If you're using the latest Solidity version, be aware that some Rootstock contracts may not be fully compatible. We recommend using Solidity version **0.8.20** for better compatibility.
+
+## **Step 3: Compile and Deploy the AirdropManager Contract**
+
+After pasting the contracts into Remix IDE, follow these steps to successfully compile and deploy them:
+
+* **Select Solidity Version**
+
+ * Ensure the compiler version is set to **0.8.20** to maintain compatibility with Rootstock contracts.
+
+* **Compile the AirdropManager.sol Contract**
+
+ * Click the **Compile AirdropManager.sol** button to compile the contract.
+ * Make sure there are no errors before proceeding to the next step.
+
+* **Deploy the AirdropManager Contract**
+
+ * Go to the **Deploy & Run Transactions** tab in Remix.
+ * From the **Environment** dropdown, select the Remix VM (Cancun)
+ * In the **Accounts** section at the top of Remix, copy the first account address.
+ * Paste this address into the contract deployment input field.
+
+:::tip[Important]
+Make sure to enter the address inside square brackets, like this: `[0x5B38Da6a701c568545dCfcB03FcB875f56beddC4]`. If entered incorrectly
+(e.g., without brackets), you will encounter the following error:
+
+```
+ “creation of AirdropManager errored: Error encoding arguments: Error: expected array value (argument=null, value="0x5B38Da6a701c568545dCfcB03FcB875f56beddC4", code=INVALID\_ARGUMENT, version=abi/5.7.0)”.
+```
+:::
+
+> Double-check that the account address is properly formatted with square brackets to avoid this issue.
+
+
+
+## **4\. Deploy the Contract**
+
+* After correctly entering the address, click **Deploy**.
+* This will deploy the `AirdropManager` contract, which manages the entire airdrop process, including both custom and Merkle tree-based airdrops.
+
+## **5\. Copy the Contract Address**
+
+
+
+* Once deployment is successful, copy the contract address of the deployed `AirdropManager`.
+* This address will be required in your Airdrop UI project.
+
diff --git a/docs/04-resources/08-runes/airdrop/template-repository.md b/docs/04-resources/08-runes/airdrop/template-repository.md
new file mode 100644
index 00000000..c9f58be0
--- /dev/null
+++ b/docs/04-resources/08-runes/airdrop/template-repository.md
@@ -0,0 +1,792 @@
+---
+sidebar_position: 4
+title: Overview of the Airdrop Template Repository
+sidebar_label: Airdrop Machine Template Repository
+
+tags: [rsk, rootstock, resources, tutorials, runes, nft, Ethereum, dApps, smart contracts, airdrop]
+description: "The repository consists of multiple smart contracts that work around a core logic contract called AirdropManager.sol which manages the logic for the different airdrops inside.Each contract has a specific role, and they interact with one another to manage airdrops effectively."
+---
+
+
+This repository contains multiple smart contracts designed to facilitate and manage airdrops efficiently. At the center of the codebase is `AirdropManager.sol`, the core logic contract responsible for handling various airdrop functions.
+
+Each supporting contract is assigned a distinct role, working in together with `AirdropManager.sol` to coordinate and execute airdrop processes smoothly. The following sections provide a detailed breakdown of the codebase.
+
+
+
+
+ 1. Administrable.sol
+
+
+This contract serves as the base contract for managing administrator roles within the system.
+
+```
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+contract Administrable {
+ mapping(address => bool) _admins;
+
+ constructor(address[] memory initialAdmins) {
+ for (uint i; i < initialAdmins.length; i++) {
+ _admins[initialAdmins[i]] = true;
+ }
+ }
+}
+```
+* **License and Version**: The first two lines specify the license type and the Solidity compiler version (0.8.19) being used for this contract.
+* **Contract Declaration**: `contract Administrable` declares a new smart contract named `Administrable`.
+* **Mapping**: `mapping(address => bool) _admins;` creates a mapping (a kind of dictionary) where each address (an Ethereum account) is associated with a boolean value. This is used to track whether an address is an admin (true) or not (false).
+* **Constructor**: The constructor function is called when the contract is deployed. It takes an array of addresses (`initialAdmins`) and sets those addresses as admins in the `_admins` mapping.
+
+```
+ modifier onlyAdmins {
+ require(_admins[msg.sender], "Address not allowed to call this method");
+ _;
+ }
+```
+
+* **Modifier**: The `onlyAdmins` modifier is a reusable piece of code that restricts certain functions to be called only by addresses that are marked as admins. The `require` statement checks if the calling address (`msg.sender`) is an admin. If not, it stops execution and returns the specified error message.
+
+```
+ function isAdmin(address _address) public view returns(bool) {
+ return _admins[_address];
+ }
+```
+
+* **isAdmin Function**: This public function checks if a specific address is an admin. It returns true or false based on the `_admins` mapping.
+
+```
+ function addAdmin(address _newAdmin) public onlyAdmins {
+ _admins[_newAdmin] = true;
+ }
+
+ function removeAdmin(address _admin) public onlyAdmins {
+ _admins[_admin] = false;
+ }
+
+```
+ **Admin Management Functions**
+ * `addAdmin`: Allows an existing admin to add a new admin. This function can only be called by an admin due to the `onlyAdmins` modifier.
+ * `removeAdmin`: Allows an admin to remove another admin by setting their status to false in the `_admins` mapping.
+
+
+
+
+
+ 2. AirdropManager.sol
+
+ This contract is responsible for managing different airdrop contracts and facilitating the claiming process.
+
+```
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "./Administrable.sol";
+
+enum AirdropType {
+ CUSTOM,
+ MERKLE
+}
+```
+
+* **Imports**: `import "./Administrable.sol";` imports the `Administrable` contract so that the `AirdropManager` can use its functionality.
+* **Enum Declaration**: The `AirdropType` enum defines two types of airdrops: `CUSTOM` and `MERKLE`. Enums are a way to define a variable that can hold a set of predefined values, which in this case represent different airdrop methods. Currently the Admin can handle 2 different kinds of airdrop: CUSTOM, which consists on a simple allow/not allow claim, and the MERKLE, which consist on a more elaborated merkle tree information validation, which requires to pass a ROOT Hash to the contract, so it can verify itself if the user requesting an amount of tokens has permission or not to do it.
+
+```
+struct AirdropInfo {
+ string airdropName;
+ address airdropAddress;
+ uint256 totalAirdropAmount;
+ uint256 airdropAmountLeft;
+ uint256 claimAmount;
+ uint256 expirationDate;
+ AirdropType airdropType;
+}
+
+```
+
+
+* **Struct Declaration**: `AirdropInfo` is a structure that holds information about an airdrop. It includes:
+ * `airdropName`: A string representing the name of the airdrop.
+ * `airdropAddress`: The contract address that manages the airdrop.
+ * `totalAirdropAmount`: The total amount of tokens allocated for the airdrop.
+ * `airdropAmountLeft`: The remaining tokens available for claiming.
+ * `claimAmount`: The amount of tokens a user can claim.
+ * `expirationDate`: The date when the airdrop ends.
+ * `airdropType`: The type of airdrop (CUSTOM or MERKLE).
+
+```
+interface IAirdrop1155 {
+ function claim(address user, uint256 amount_, bytes32[] calldata proof_) external;
+ function hasClaimed(address _address) external view returns(bool);
+ function hasExpired() external view returns(bool);
+ function allowAddress(address _address) external;
+ function allowAddresses(address[] memory addresses) external;
+ function disallowAddresses(address[] memory addresses) external;
+ function disallowAddress(address _address) external;
+ function isAllowed(address _address) external view returns(bool);
+ function getExpirationDate() external view returns(uint256);
+ function getClaimAmount() external view returns(uint256);
+ function getTotalAirdropAmount() external view returns(uint256);
+ function getAirdropAmountLeft() external view returns(uint256);
+ function getBalance() external view returns(uint256);
+ function getAirdropInfo() external view returns(AirdropInfo memory info);
+ function setRoot(bytes32 _root) external;
+}
+
+```
+
+* **Interface Declaration**: `interface IAirdrop1155` defines a set of functions that other contracts must implement if they want to be used as airdrop contracts. Interfaces are a way to define contracts that will be used in a polymorphic way, meaning different contracts can fulfill the same role but with different implementations. This is implemented for the contract to call functions in airdrop smart contracts.
+
+```
+contract AirdropManager is Administrable {
+ address[] _airdrops;
+
+ constructor (address[] memory initialAdmins) Administrable(initialAdmins) {}
+
+```
+
+* **Contract Inheritance**: `contract AirdropManager is Administrable` means that `AirdropManager` inherits from the `Administrable` contract. This allows it to use admin-related functions and modifiers.
+* **State Variable**: `address[] _airdrops;` is an array that stores the addresses of the airdrop contracts managed by this contract.
+* **Constructor**: The constructor initializes the contract with a list of initial admins by calling the `Administrable` constructor.
+
+```
+event AirdropAdded(address airdropAddress);
+event AirdropRemoved(address airdropAddress);
+```
+
+* **Events**: `AirdropAdded` and `AirdropRemoved` are events that are emitted when an airdrop is added or removed. Events allow external applications (like front-end UIs) to listen for and respond to changes on the blockchain.
+
+```
+function claim(address airdropAddress, address user, uint256 amount, bytes32[] calldata proof) public {
+ IAirdrop1155 airdrop = IAirdrop1155(airdropAddress);
+ airdrop.claim(user, amount, proof);
+}
+```
+
+* **Claim Function**: This public function allows a user to claim their airdrop tokens. It accepts the address of the airdrop contract, the user’s address, the amount they wish to claim, and a proof for Merkle claims. It uses the `claim` function defined in the `IAirdrop1155` interface.
+
+```
+function hasClaimed(address airdropAddress, address user) public view returns(bool) {
+ IAirdrop1155 airdrop = IAirdrop1155(airdropAddress);
+ return airdrop.hasClaimed(user);
+}
+```
+
+* **hasClaimed Function**: This function checks if a user has already claimed their airdrop tokens by calling the corresponding function in the airdrop contract.
+
+```
+function hasExpired(address airdropAddress) public view returns(bool) {
+ IAirdrop1155 airdrop = IAirdrop1155(airdropAddress);
+ return airdrop.hasExpired();
+}
+```
+
+* **hasExpired Function**: This checks if the airdrop has expired by calling the corresponding function in the airdrop contract.
+
+```
+function isAllowed(address airdropAddress, address user) public view returns(bool) {
+ IAirdrop1155 airdrop = IAirdrop1155(airdropAddress);
+ return airdrop.isAllowed(user);
+}
+```
+
+* **isAllowed Function**: This checks if a user is allowed to claim tokens from the specified airdrop.
+
+```
+function getExpirationDate(address airdropAddress) public view returns(uint256) {
+ IAirdrop1155 airdrop = IAirdrop1155(airdropAddress);
+ return airdrop.getExpirationDate();
+}
+```
+
+* **getExpirationDate Function**: Retrieves the expiration date of the airdrop.
+
+```
+function getClaimAmount(address airdropAddress) public view returns(uint256) {
+ IAirdrop1155 airdrop = IAirdrop1155(airdropAddress);
+ return airdrop.getClaimAmount();
+}
+```
+
+* **getClaimAmount Function**: Returns the amount of tokens a user can claim.
+
+```
+function getAirdropInfo(address airdropAddress) public view returns(AirdropInfo memory) {
+ IAirdrop1155 airdrop = IAirdrop1155(airdropAddress);
+ return airdrop.getAirdropInfo();
+}
+```
+
+* **getAirdropInfo Function**: Retrieves all relevant information about the airdrop by calling the corresponding function in the airdrop contract.
+
+```
+function getTotalAirdropAmount(address airdropAddress) public view returns(uint256) {
+ IAirdrop1155 airdrop = IAirdrop1155(
+```
+
+
+
+ 3. CustomAirdrop1155.sol
+
+ This contract would implement the logic specific to airdrops using the ERC-1155 standard (multi-token standard). It allows for the distribution of tokens as part of an airdrop.
+
+
+```
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+```
+
+* **License and Version**: The first two lines specify the license type (MIT) and the Solidity version (0.8.19) for this contract.
+* **Imports**: The contract imports the `Ownable` contract from OpenZeppelin, which provides basic authorization control functions, simplifying the implementation of user permissions.
+
+
+```
+interface IERC1155 {
+ function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) external;
+ function balanceOf(address account, uint256 id) external view returns (uint256);
+}
+```
+
+* **Interface**: `IERC1155` defines a standard interface for ERC-1155 token contracts. This interface declares two functions:
+ * `safeTransferFrom`: Transfers tokens from one address to another safely.
+ * `balanceOf`: Checks the balance of a specific token ID for a given address.
+
+```
+enum AirdropType {
+ CUSTOM,
+ MERKLE
+}
+
+struct AirdropInfo {
+ string airdropName;
+ address airdropAddress;
+ uint256 totalAirdropAmount;
+ uint256 airdropAmountLeft;
+ uint256 claimAmount;
+ uint256 expirationDate;
+ AirdropType airdropType;
+}
+
+```
+
+* **Enum**: `AirdropType` is an enumeration that defines two types of airdrops: `CUSTOM` and `MERKLE`, allowing the contract to handle different airdrop strategies.
+* **Struct**: `AirdropInfo` is a structure that encapsulates essential details about the airdrop, such as:
+ * `airdropName`: The name of the airdrop.
+ * `airdropAddress`: The contract address managing the airdrop.
+ * `totalAirdropAmount`: The total tokens allocated for the airdrop.
+ * `airdropAmountLeft`: Tokens remaining for distribution.
+ * `claimAmount`: Tokens a user can claim at once.
+ * `expirationDate`: When the airdrop expires.
+ * `airdropType`: The type of airdrop.
+
+
+```
+contract CustomAirdrop1155 is Ownable {
+```
+
+* **Contract Definition**: `contract CustomAirdrop1155` declares a new smart contract named `CustomAirdrop1155`, inheriting from `Ownable`. This means it will have owner-related functionalities, such as restricting certain functions to the contract owner.
+
+
+```
+event Claim(address recipient, uint256 amount);
+event AddressAllowed(address allowedAddress);
+event AddressDisallowed(address disallowedAddress);
+
+IERC1155 _tokenContract;
+uint256 _totalAirdropAmount;
+uint256 _airdropAmountLeft;
+uint256 _claimAmount;
+uint256 _expirationDate;
+uint256 _tokenId;
+string _airdropName;
+AirdropType _airdropType;
+
+mapping(address => bool) _allowedAddresses;
+mapping(address => bool) _addressesThatAlreadyClaimed;
+```
+
+* **Events**: The contract defines three events:
+ * `Claim`: Emitted when a user successfully claims their tokens.
+ * `AddressAllowed`: Emitted when an address is granted permission to claim.
+ * `AddressDisallowed`: Emitted when an address is denied permission to claim.
+* **State Variables**:
+ * `_tokenContract`: An instance of the ERC-1155 token contract.
+ * `_totalAirdropAmount`: The total number of tokens allocated for the airdrop.
+ * `_airdropAmountLeft`: The number of tokens remaining to be claimed.
+ * `_claimAmount`: The amount of tokens each user can claim.
+ * `_expirationDate`: The date and time when the airdrop will expire.
+ * `_tokenId`: The specific ID of the token being airdropped.
+ * `_airdropName`: The name of the airdrop.
+ * `_airdropType`: The type of airdrop (CUSTOM or MERKLE).
+* **Mappings**:
+ * `_allowedAddresses`: Keeps track of which addresses are permitted to claim tokens.
+ * `_addressesThatAlreadyClaimed`: Tracks which addresses have already claimed their tokens.
+
+
+```
+constructor(
+ string memory airdropName,
+ address initialOwner,
+ address tokenAddress,
+ uint256 tokenId,
+ uint256 totalAirdropAmount,
+ uint256 claimAmount,
+ uint256 expirationDate,
+ AirdropType airdropType
+) Ownable(initialOwner) {
+ _tokenContract = IERC1155(tokenAddress);
+ _airdropName = airdropName;
+ _tokenId = tokenId;
+ _totalAirdropAmount = totalAirdropAmount;
+ _airdropAmountLeft = totalAirdropAmount;
+ _claimAmount = claimAmount;
+ _expirationDate = expirationDate;
+ _airdropType = airdropType;
+}
+
+
+```
+
+* **Constructor**: This function is executed when the contract is deployed. It initializes various parameters, including:
+ * `airdropName`: The name of the airdrop.
+ * `initialOwner`: The address of the initial owner (who can manage the airdrop).
+ * `tokenAddress`: The address of the ERC-1155 token contract.
+ * `tokenId`: The ID of the token to be distributed.
+ * `totalAirdropAmount`: The total amount of tokens for the airdrop.
+ * `claimAmount`: How many tokens each user can claim at once.
+ * `expirationDate`: When the airdrop will end.
+ * `airdropType`: The type of the airdrop.
+
+The constructor also initializes the `_tokenContract` with the provided token address.
+
+###
+
+```
+function claim(address user, uint256 amount, bytes32[] calldata proof) public onlyOwner {
+ require(isAllowed(user), "Address not allowed to claim this airdrop");
+ require(!hasExpired(), "Airdrop already expired.");
+ require(!hasClaimed(user), "Address already claimed this airdrop.");
+ require(!hasBeenTotallyClaimed(), "Airdrop has been totally claimed already.");
+ require(hasBalanceToClaim(), "Airdrop contract has insufficient token balance.");
+
+ _tokenContract.safeTransferFrom(address(this), user, _tokenId, _claimAmount, '');
+ _airdropAmountLeft -= _claimAmount;
+ _addressesThatAlreadyClaimed[user] = true;
+
+ emit Claim(user, _claimAmount);
+}
+```
+
+* **Claim Function**: This function allows the contract owner to facilitate a token claim for a specified user. It checks several conditions using `require` statements:
+ * The user must be allowed to claim.
+ * The airdrop must not have expired.
+ * The user must not have already claimed.
+ * There must be enough tokens left for claiming.
+
+If all checks pass, the function:
+
+* Transfers the tokens from the airdrop contract to the user using `safeTransferFrom`.
+* Updates the remaining airdrop amount.
+* Marks the user as having claimed.
+
+It then emits the `Claim` event to notify about the successful claim.
+
+###
+
+These functions provide information without modifying the state.
+
+```
+function getAirdropInfo() public view returns(AirdropInfo memory) {
+ return AirdropInfo(_airdropName, address(this), _totalAirdropAmount, _airdropAmountLeft, _claimAmount, _expirationDate, _airdropType);
+}
+```
+
+* **getAirdropInfo Function**: Returns a structured view of the airdrop information using the `AirdropInfo` struct.
+
+```
+function hasBalanceToClaim() public view returns(bool) {
+ return _tokenContract.balanceOf(address(this), _tokenId) >= _claimAmount;
+}
+
+function hasBeenTotallyClaimed() public view returns(bool) {
+ return _airdropAmountLeft < _claimAmount;
+}
+
+function hasClaimed(address _address) public view returns(bool) {
+ return _addressesThatAlreadyClaimed[_address];
+}
+
+function hasExpired() public view returns(bool) {
+ return _expirationDate < block.timestamp;
+}
+```
+
+* **Balance Checks**:
+ * `hasBalanceToClaim`: Checks if the airdrop contract has enough tokens left for a claim.
+ * `hasBeenTotallyClaimed`: Checks if the airdrop has been fully claimed.
+ * `hasClaimed`: Checks if a specific address has already claimed tokens.
+ * `hasExpired`: Checks if the airdrop has expired based on the current timestamp.
+
+###
+
+These functions manage which addresses can claim tokens.
+
+```
+function allowAddress(address _address) public onlyOwner {
+ _allowedAddresses[_address] = true;
+ emit AddressAllowed(_address);
+}
+
+function allowAddresses(address[] memory addresses) public onlyOwner {
+ for (uint i; i < addresses.length; i++) {
+ _allowedAddresses[addresses[i]] = true;
+ emit AddressAllowed(addresses[i]);
+ }
+}
+
+function disallowAddresses(address[] memory addresses) public onlyOwner {
+ for (uint i; i < addresses.length
+```
+
+
+
+
+
+ 4. CustomAirdrop1155ClaimMerkle.sol
+
+This contract likely extends the functionality of `CustomAirdrop1155.sol` by implementing a Merkle tree structure for validating claims. It allows airdrop managers to verify claims against a list of eligible addresses efficiently.
+
+###
+
+```
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
+
+```
+
+* **License and Version**: The first two lines specify the license type (MIT) and the Solidity version (0.8.19) for this contract.
+* **Imports**: The contract imports:
+ * `Ownable` from OpenZeppelin, which provides basic authorization control functions.
+ * `MerkleProof`, which includes utilities for verifying Merkle proofs.
+
+###
+
+```
+interface IERC1155 {
+ function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) external;
+ function balanceOf(address account, uint256 id) external view returns (uint256);
+}
+```
+
+* **Interface**: `IERC1155` defines the standard interface for ERC-1155 token contracts. This interface declares two functions:
+ * `safeTransferFrom`: Safely transfers tokens from one address to another.
+ * `balanceOf`: Retrieves the balance of a specific token ID for a given address.
+
+###
+
+```
+enum AirdropType {
+ CUSTOM,
+ MERKLE
+}
+
+struct AirdropInfo {
+ string airdropName;
+ address airdropAddress;
+ uint256 totalAirdropAmount;
+ uint256 airdropAmountLeft;
+ uint256 claimAmount;
+ uint256 expirationDate;
+ AirdropType airdropType;
+}
+
+```
+
+* **Enum**: `AirdropType` is an enumeration that defines two types of airdrops: `CUSTOM` and `MERKLE`. This helps distinguish between different airdrop mechanisms.
+* **Struct**: `AirdropInfo` holds information about an airdrop, including:
+ * `airdropName`: The name of the airdrop.
+ * `airdropAddress`: The address of the contract managing the airdrop.
+ * `totalAirdropAmount`: Total tokens allocated for the airdrop.
+ * `airdropAmountLeft`: Tokens remaining for distribution.
+ * `claimAmount`: Amount of tokens each user can claim.
+ * `expirationDate`: The expiration date of the airdrop.
+ * `airdropType`: The type of the airdrop.
+
+###
+
+```
+contract CustomAirdrop1155Merkle is Ownable {
+```
+
+* **Contract Definition**: This line declares a new smart contract named `CustomAirdrop1155Merkle`, inheriting from `Ownable`. This means it will have owner-related functionalities to manage permissions.
+
+###
+
+```
+event Claim(address recipient, uint256 amount);
+
+IERC1155 _tokenContract;
+uint256 _totalAirdropAmount;
+uint256 _airdropAmountLeft;
+uint256 _claimAmount;
+uint256 _expirationDate;
+uint256 _tokenId;
+string _airdropName;
+AirdropType _airdropType;
+
+// (account,amount) Merkle Tree root
+bytes32 public root;
+error InvalidProof();
+error UsedLeaf();
+
+mapping(address => bool) _addressesThatAlreadyClaimed;
+mapping(bytes32 => bool) public claimedLeaf;
+
+```
+
+* **Events**: The contract defines one event:
+ * `Claim`: Emitted when a user successfully claims their tokens.
+* **State Variables**:
+ * `_tokenContract`: An instance of the ERC-1155 token contract.
+ * `_totalAirdropAmount`: The total tokens allocated for the airdrop.
+ * `_airdropAmountLeft`: The remaining tokens available for claiming.
+ * `_claimAmount`: The amount of tokens each user can claim.
+ * `_expirationDate`: The expiration date of the airdrop.
+ * `_tokenId`: The ID of the token being airdropped.
+ * `_airdropName`: The name of the airdrop.
+ * `_airdropType`: The type of airdrop (CUSTOM or MERKLE).
+* **Merkle Tree Variables**:
+ * `root`: The Merkle root of the allowed claims.
+ * `InvalidProof`: A custom error thrown when the proof is invalid.
+ * `UsedLeaf`: A custom error thrown when a leaf has already been claimed.
+* **Mappings**:
+ * `_addressesThatAlreadyClaimed`: Keeps track of addresses that have claimed their tokens.
+ * `claimedLeaf`: Tracks which leaves (combinations of user addresses and amounts) have already been claimed.
+
+###
+
+```
+constructor(
+ string memory airdropName,
+ address initialOwner,
+ address tokenAddress,
+ uint256 tokenId,
+ uint256 totalAirdropAmount,
+ uint256 expirationDate,
+ AirdropType airdropType
+) Ownable(initialOwner) {
+ _tokenContract = IERC1155(tokenAddress);
+ _airdropName = airdropName;
+ _tokenId = tokenId;
+ _totalAirdropAmount = totalAirdropAmount;
+ _airdropAmountLeft = totalAirdropAmount;
+ _expirationDate = expirationDate;
+ _airdropType = airdropType;
+}
+
+```
+
+* **Constructor**: This function is executed when the contract is deployed. It initializes various parameters, including:
+ * `airdropName`: The name of the airdrop.
+ * `initialOwner`: The address of the initial owner (who can manage the airdrop).
+ * `tokenAddress`: The address of the ERC-1155 token contract.
+ * `tokenId`: The ID of the token to be distributed.
+ * `totalAirdropAmount`: The total amount of tokens for the airdrop.
+ * `expirationDate`: The expiration date of the airdrop.
+ * `airdropType`: The type of the airdrop.
+
+The constructor also initializes the `_tokenContract` with the provided token address.
+
+###
+
+```
+function setRoot(bytes32 _root) public onlyOwner {
+ root = _root;
+}
+
+```
+
+* **setRoot Function**: This function allows the owner to set the Merkle root for the airdrop, which defines which users are eligible for claiming tokens.
+
+###
+
+```
+function claim(address user, uint256 amount, bytes32[] calldata proof) external onlyOwner {
+ _claim(user, amount, proof);
+}
+```
+
+* **Claim Function**: This function allows the contract owner to initiate a claim for a specified user. It calls the internal `_claim` function, which contains the actual logic for processing the claim.
+
+###
+
+```
+function _claim(address origin_, uint256 amount_, bytes32[] calldata proof_) internal {
+ bytes32 leaf = _buildLeaf(origin_, amount_);
+
+ if (!MerkleProof.verifyCalldata(proof_, root, leaf)) revert InvalidProof();
+ if (claimedLeaf[leaf]) revert UsedLeaf();
+ claimedLeaf[leaf] = true;
+ require(!hasExpired(), "Airdrop already expired.");
+ require(!hasBeenTotallyClaimed(), "Airdrop has been totally claimed already.");
+
+ _tokenContract.safeTransferFrom(address(this), origin_, _tokenId, amount_, '');
+ _airdropAmountLeft -= amount_;
+ _addressesThatAlreadyClaimed[origin_] = true;
+
+ emit Claim(origin_, amount_);
+}
+
+```
+
+* **Internal `_claim` Function**: This function performs the actual claim processing. It:
+ * Builds a Merkle leaf using the user's address and the claim amount.
+ * Verifies the provided Merkle proof against the root. If the proof is invalid, it throws an error.
+ * Checks if the leaf has already been claimed. If so, it throws an error.
+ * Marks the leaf as claimed.
+ * Checks if the airdrop has expired or if all tokens have already been claimed.
+ * Transfers the specified amount of tokens to the user.
+ * Updates the amount of tokens left for the airdrop.
+ * Marks the user as having claimed their tokens.
+ * Emits the `Claim` event.
+
+###
+
+```
+function _buildLeaf(address origin_, uint256 amount_) internal pure returns (bytes32) {
+ return keccak256(bytes.concat(keccak256(abi.encode(origin_, amount_))));
+}
+```
+
+* **Internal `_buildLeaf` Function**: This function creates a leaf node for the Merkle tree by hashing the user's address and the claim amount together. The resulting hash (leaf) will be used for verification.
+
+###
+
+These functions provide information about the airdrop without modifying the state.
+
+```
+function getAirdropInfo() public view returns(AirdropInfo memory) {
+ return AirdropInfo(_airdropName, address(this), _totalAirdropAmount, _airdropAmountLeft, 0, _expirationDate, _airdropType);
+}
+
+function hasBeenTotallyClaimed() public view returns(bool) {
+ return _airdropAmountLeft < 1;
+}
+
+function hasClaimed(address _address) public view returns(bool) {
+ return _addressesThatAlreadyClaimed[_address];
+}
+
+function hasExpired() public view returns(bool) {
+ return _
+```
+
+
+
+
+ 5. Erc1155.sol
+
+This contract implements the ERC-1155 standard, providing the foundational structure for managing multiple tokens and enabling the transfer of various token types in a single contract.
+
+###
+
+```
+// SPDX-License-Identifier: MIT
+// Compatible with OpenZeppelin Contracts ^5.0.0
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+```
+
+* **License and Version**: The first line specifies the license type (MIT). The comment indicates compatibility with OpenZeppelin Contracts version 5.0.0.
+* **Solidity Version**: The `pragma` statement specifies that this contract uses Solidity version 0.8.19 or higher.
+* **Imports**: The contract imports two modules from OpenZeppelin:
+ * `ERC1155`: The base implementation of the ERC-1155 token standard, which allows for the creation of multiple token types in a single contract.
+ * `Ownable`: A contract that provides basic authorization control functions, allowing only the owner of the contract to execute certain functions.
+
+###
+
+```
+contract MyToken is ERC1155, Ownable {
+```
+
+* **Contract Definition**: This line declares a new smart contract named `MyToken`, which inherits from both `ERC1155` and `Ownable`. This means it will have the functionality of an ERC-1155 token as well as ownership control features.
+
+###
+
+```
+constructor(address initialOwner) ERC1155("") Ownable(initialOwner) {}
+```
+
+* **Constructor**: This function is called when the contract is deployed. It initializes the contract with the following:
+ * `initialOwner`: The address of the initial owner of the contract.
+ * `ERC1155("")`: Calls the constructor of the ERC1155 contract with an empty URI string, which can be set later. The URI is usually used to provide metadata about the tokens.
+ * `Ownable(initialOwner)`: Calls the constructor of the Ownable contract to set the initial owner.
+
+###
+
+```
+function setURI(string memory newuri) public onlyOwner {
+ _setURI(newuri);
+}
+```
+
+* **setURI Function**: This public function allows the contract owner to set the URI for the tokens. It uses the `onlyOwner` modifier, ensuring that only the owner can change the URI.
+* **Internal Call**: `_setURI(newuri)` is a function inherited from the ERC1155 contract that updates the token URI.
+
+###
+
+```
+function mint(address account, uint256 id, uint256 amount, bytes memory data)
+ public
+ onlyOwner
+{
+ _mint(account, id, amount, data);
+}
+```
+
+* **mint Function**: This public function allows the contract owner to mint new tokens.
+ * **Parameters**:
+ * `account`: The address that will receive the minted tokens.
+ * `id`: The ID of the token type to mint.
+ * `amount`: The number of tokens to mint.
+ * `data`: Additional data that can be sent along with the minting operation (can be empty).
+* **Internal Call**: `_mint(account, id, amount, data)` is a function inherited from the ERC1155 contract that performs the actual minting of tokens.
+
+###
+
+```
+function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
+ public
+ onlyOwner
+{
+ _mintBatch(to, ids, amounts, data);
+}
+```
+
+* **mintBatch Function**: This public function allows the contract owner to mint multiple types of tokens in a single transaction.
+ * **Parameters**:
+ * `to`: The address that will receive the minted tokens.
+ * `ids`: An array of token IDs to mint.
+ * `amounts`: An array of amounts corresponding to each token ID.
+ * `data`: Additional data that can be sent along with the minting operation (can be empty).
+
+ **Internal Call**: `_mintBatch(to, ids, amounts, data)` is a function inherited from the ERC1155 contract that performs the batch minting of tokens.
+
+
+
+
+
+
+
+
+## Complete Codebase
+> [https://github.com/rsksmart/airdrop-template/tree/main/contracts](https://github.com/rsksmart/airdrop-template/tree/main/contracts)
diff --git a/docs/04-resources/08-runes/Intro-runes.md b/docs/04-resources/08-runes/mockbridge/Intro-runes.md
similarity index 94%
rename from docs/04-resources/08-runes/Intro-runes.md
rename to docs/04-resources/08-runes/mockbridge/Intro-runes.md
index 05a7d4bf..09ded439 100644
--- a/docs/04-resources/08-runes/Intro-runes.md
+++ b/docs/04-resources/08-runes/mockbridge/Intro-runes.md
@@ -1,25 +1,23 @@
---
sidebar_position: 1
-title: Introduction to Runes
-sidebar_label: Introduction to Runes
+title: Introduction to Runes Mock Bridge
+sidebar_label: Introduction
tags: [rsk, rootstock, resources, tutorials, runes, nft, Ethereum, dApps, smart contracts]
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: Mock Bridge, Marketplace, Giveaway Engine"
---
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:
-Here’s the table in a list format in Markdown:
-
- **Mock Bridge**
- - Description: Facilitates transferring Runes between different blockchain networks.
+ - Facilitates transferring Runes between different blockchain networks.
- Repo: [Link](https://github.com/rsksmart/rsk-runes)
- **Marketplace**
- - Description: A platform for trading and exchanging Runes tokens.
+ - A platform for trading and exchanging Runes tokens.
- Repo: N/A
- **Giveaway Engine**
- - Description: A system for distributing tokens in a structured or promotional manner.
+ - A system for distributing tokens in a structured or promotional manner.
- Repo: [Link](https://github.com/rsksmart/airdrop-ui.git)
diff --git a/docs/04-resources/08-runes/mockbridge/_category_.yml b/docs/04-resources/08-runes/mockbridge/_category_.yml
new file mode 100644
index 00000000..8a7469b6
--- /dev/null
+++ b/docs/04-resources/08-runes/mockbridge/_category_.yml
@@ -0,0 +1,6 @@
+label: Runes Mock Bridge
+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/mockbridge
diff --git a/docs/04-resources/08-runes/runes-contracts.md b/docs/04-resources/08-runes/mockbridge/runes-contracts.md
similarity index 73%
rename from docs/04-resources/08-runes/runes-contracts.md
rename to docs/04-resources/08-runes/mockbridge/runes-contracts.md
index b5482bd4..e011d8a3 100644
--- a/docs/04-resources/08-runes/runes-contracts.md
+++ b/docs/04-resources/08-runes/mockbridge/runes-contracts.md
@@ -1,7 +1,7 @@
---
sidebar_position: 3
-title: Runes Contract Explanation walk through
-sidebar_label: Runes Contract Explanation walk through
+title: Runes Mock Bridge Contract Explanation walk through
+sidebar_label: 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."
---
@@ -210,66 +210,3 @@ This function returns the number of **unfrozen** tokens owned by a user for a sp
:::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/mockbridge/runes-deployment.md b/docs/04-resources/08-runes/mockbridge/runes-deployment.md
new file mode 100644
index 00000000..ce70aed1
--- /dev/null
+++ b/docs/04-resources/08-runes/mockbridge/runes-deployment.md
@@ -0,0 +1,67 @@
+---
+sidebar_position: 3
+title: Deploy Runes Mock Bridge Smart Contract
+sidebar_label: Deploy
+tags: [rsk, rootstock, resources, tutorials, deploy, Runes, dApps, smart contracts, Remix IDE, MetaMask]
+description: "The Rootstock Runes Mock Bridge deployment page shows you how to compile and deploy runes on RemixIDE"
+---
+
+To deploy the Runes smart contract using Remix IDE, follow the steps below:
+
+### **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/mockbridge/runes-setup.md
similarity index 99%
rename from docs/04-resources/08-runes/runes-setup.md
rename to docs/04-resources/08-runes/mockbridge/runes-setup.md
index 09ecdda3..bf9839e4 100644
--- a/docs/04-resources/08-runes/runes-setup.md
+++ b/docs/04-resources/08-runes/mockbridge/runes-setup.md
@@ -1,7 +1,7 @@
---
sidebar_position: 2
-title: Runes Setup
-sidebar_label: Runes Setup
+title: Runes Mock Bridge Setup
+sidebar_label: 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."
---
diff --git a/static/img/resources/runes/airdrop/Copy-the-Contract-Address.png b/static/img/resources/runes/airdrop/Copy-the-Contract-Address.png
new file mode 100644
index 00000000..4eb14494
Binary files /dev/null and b/static/img/resources/runes/airdrop/Copy-the-Contract-Address.png differ
diff --git a/static/img/resources/runes/airdrop/Deploy-the-AirdropManager-Contract.png b/static/img/resources/runes/airdrop/Deploy-the-AirdropManager-Contract.png
new file mode 100644
index 00000000..d6c4993b
Binary files /dev/null and b/static/img/resources/runes/airdrop/Deploy-the-AirdropManager-Contract.png differ
diff --git a/static/img/resources/runes/airdrop/airdrop-dashboard.png b/static/img/resources/runes/airdrop/airdrop-dashboard.png
new file mode 100644
index 00000000..24781f11
Binary files /dev/null and b/static/img/resources/runes/airdrop/airdrop-dashboard.png differ
diff --git a/static/img/resources/runes/airdrop/claim-airdrop.png b/static/img/resources/runes/airdrop/claim-airdrop.png
new file mode 100644
index 00000000..fd6bcb86
Binary files /dev/null and b/static/img/resources/runes/airdrop/claim-airdrop.png differ
diff --git a/static/img/resources/runes/airdrop/claimed-airdrop.png b/static/img/resources/runes/airdrop/claimed-airdrop.png
new file mode 100644
index 00000000..b8b04574
Binary files /dev/null and b/static/img/resources/runes/airdrop/claimed-airdrop.png differ
diff --git a/static/img/resources/runes/airdrop/intro-airdrop.png b/static/img/resources/runes/airdrop/intro-airdrop.png
new file mode 100644
index 00000000..46593a24
Binary files /dev/null and b/static/img/resources/runes/airdrop/intro-airdrop.png differ
diff --git a/static/img/resources/runes/airdrop/list-of-Airdrops.png b/static/img/resources/runes/airdrop/list-of-Airdrops.png
new file mode 100644
index 00000000..6dc59700
Binary files /dev/null and b/static/img/resources/runes/airdrop/list-of-Airdrops.png differ
diff --git a/static/img/resources/runes/airdrop/prepare-contract-for-remix.png b/static/img/resources/runes/airdrop/prepare-contract-for-remix.png
new file mode 100644
index 00000000..115a224d
Binary files /dev/null and b/static/img/resources/runes/airdrop/prepare-contract-for-remix.png differ