An in-depth learning track designed for developers to excel in Ocean protocol. Learn how to master the technology that leverages blockchain, decentralized networks, and cryptography to enable secure, privacy-preserving data sharing. Be empowered data owners by giving control over the data while facilitating the commercialization of data through marketplaces.

Ocean Protocol: Master Tokenized AI & Data

Develop a marketplace to tokenize and trade data as NFTs using Ocean Protocol, ensuring secure and transparent data ownership. Empower creators and businesses to monetize datasets while maintaining control over their assets.

# What Are We Building Today?

Hey there developers!! 👋🏼

Congratulations on completing the first and second Ocean Protocol course! 🎉 If you haven't had the chance to complete these yet, we highly recommend doing so before diving into this advanced course. It'll provide you with the foundational knowledge needed to make the most of what we're about to explore.

Now, are you ready to dive deeper into the ocean of decentralized data? You've dipped your toes in the water with Course 1, and in Course 2 you plunged into the exciting world of creating and managing data assets on the Ocean Protocol. You have explore the depths of what's possible with decentralized data! 

Now it’s time to take a step further and build a your own marketplace. Well don’t worry, we are here to guide you through this process step by step.

## Why Ocean Protocol?

The global data market is projected to reach $103 billion by 2027! And Ocean Protocol is your surfboard to ride this massive wave, making data as easy to trade and monetize as posting a photo on social media.

We will customize our marketplace that works both ways for NFTs and datasets. And you will see how helpful Ocean code is too!

## What Will You Get Out of This Course?

By completing this course, you'll gain:

- Deep dive into the coding and customizing your own marketplace
- Creating your own marketplace
- Ocean customized NFT from Metaschool

## Proof of Completion

When you complete this course, you'll receive a special NFT, a digital badge of honor that unlocks many more opportunities on our platform. Here's a sneak peek of what your NFT will look like:

![default nft.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%201%20What%20are%20we%20building%20today/oceanc3%20(1).webp?raw=true)

Now before we move forward, let’s set some house rules first.

1. Kindly do your quick assignments properly.
2. Join [our discord server](https://bit.ly/core-course-discord) and ask all relevant questions there.
3. We are a free open-source platform and if you follow us on [X](https://bit.ly/core-course-twitter) and [LinkedIn](https://bit.ly/core-course-linkedIn), it would be a great support. 🫣
4. You can subscribe to our [YouTube](https://bit.ly/core-course-youtube) channel for exciting videos too. ✨
5. Stay happy and positive!

Alright, data divers, it's time to take the plunge! Let's embark on this exciting voyage into the world of Ocean Protocol!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/1.%20Getting%20Started/Lesson%201%20What%20Are%20We%20Building%20Today.md

What Are We Building Today?

# Setting Up Your Environment

Welcome back, ocean explorers! 🌊 Are you ready to plunge into the world of the Ocean? This lesson will guide you through the basic setup and prepare you for coding. Let’s go!

## Setting Up Your Environment

Let's get our hands dirty with some setup! We'll be using Node.js and nvm (Node Version Manager) to ensure a smooth development experience.

![Frame3560408-ezgif.com-jpg-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%202%20Setting%20Up%20Your%20Environment/Frame3560408-ezgif.com-jpg-to-webp-converter.webp)

1. **Node.js & npm:** Node Js is the engine that powers your JavaScript code, even outside of a web browser. This is super important for blockchain development because it allows you to create and execute code that will interact with the Ocean network directly from your computer. npm is your trusty package manager. It's like a shopping cart for code libraries, making it easy to install and manage all the software components your project needs.
    - **Download & Install Node.js:** Head over to [nodejs.org](https://nodejs.org/) and grab the installer for your operating system (macOS, or Linux). The installer will also include npm. Just follow the on-screen instructions. If you're not sure which one to choose, npm is a great starting point.
    - **Verify Success:** Open your terminal (or command prompt) and type the following commands:
        
        ```bash
        node -v
        npm -v
        ```
        
    
    You should see version numbers for both Node.js and your package manager printed out. If you do, congrats! You've successfully installed Node.js and your package manager.
    
    Make sure you use the 18+ version of the node.
    
2. **Visual Studio Code (VSCode):** This is our code editor of choice. It's a free, powerful tool that makes writing Solidity code (the language for smart contracts) a breeze. It's got a clean interface, tons of customization options, and a huge library of extensions to help you code like a pro.
    - **Download & Install:** Grab it from [code.visualstudio.com](https://code.visualstudio.com/) and follow the simple installation instructions.
3. **Git:** Git is a version control system that lets you track changes to your code, collaborate with others, and revert to previous versions if needed. It's like a time machine for your code!
    - **Download & Install:** Grab it from the official website: [git-scm.com](https://git-scm.com/) and follow the instructions.
4. **Git CLI:** It allows you to connect with git via the terminal, so let’s install it too. You can follow the steps given [here](https://github.com/cli/cli). Once you have installed the Git CLI, let me tell you how you can configure your terminal with it.
    1. Open your terminal.
    2. Run `gh --version` to ensure that you have installed the Git CLI successfully.
    3. Run `gh auth login --web` in your terminal and follow the steps given below:
        1. First, it will ask for your preferred protocol for Git operations. I chose HTTPS, you can choose any.
        2. Second, it will ask you to Authenticate Git with your GitHub credentials, and type `Y`.
        3. Third, you will be able to see a code on your terminal. Copy it.
        4. Then, press Enter. It will open a window in your browser.
        5. Paste the code you copied and authorize your git. You might need to enter your GitHub password if you have yet to log in.
        6. Do not close this terminal!

Awesome, you are all set!! Good job!

## Wrap Up

Congratulations on taking your first steps into the world of Ocean! We've set up your development environment. You're now equipped with the tools to start building your own marketplace. Let’s set up your project in the next lesson without further ado.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/1.%20Getting%20Started/Lesson%202%20Setting%20Up%20Your%20Environment.md

Setting Up Your Environment

# Set up Your First Project

Alright, it's time to get our hands dirty and start building our very first Ocean Protocol project! In this lesson, we'll shift gears and get everything ready to deploy our dApp to the Sepolia test network. Don't worry, we'll guide you through every step of the way, making sure it's smooth sailing!

## Prerequisites: Your Web3 Toolkit

Before we dive into the project setup, let's make sure you have a few things ready:

1. **MetaMask Wallet:**
    - If you haven't already, head over to the [MetaMask website](https://metamask.io/) and install the extension for your browser.
    - Follow the on-screen instructions to create a new wallet or import an existing one.
    - Remember to keep your seed phrase safe and secure - it's the key to your wallet!
    - Add the Sepolia Testnet to your MetaMask. You can find instructions on how to add Sepolia to MetaMask on various online resources or within MetaMask itself.
2. **Sepolia Testnet Ether (SEP)**
    - Just like in the real world, you need some currency to interact with the blockchain. On the Sepolia testnet, we use testnet Ether (SEP).
    - Luckily, there are faucets that provide free SEP for testing purposes. Head over to the Sepolia Faucet ([https://sepolia-faucet.pk910.de/](https://sepolia-faucet.pk910.de/)) and request some SEP to be sent to your MetaMask address.
3. **Alchemy Account and RPC Endpoint**
    - We need a way to communicate with the Sepolia network. Services like [Alchemy](https://www.alchemy.com/) provide RPC endpoints for this purpose
    - Sign up for a free Alchemy account, create a new app, and select the Sepolia network.
    - Copy the "HTTPS" endpoint URL from your Alchemy dashboard. We'll need this later.

## Setting the Stage: Project Initialization

With our toolkit ready, let's create the foundation for our Ocean Protocol project. Well, Ocean has made it super easy for you, we just need to fork a repo. Let’s see how we can do it.

Open your terminal and navigate to where you want to create your project. Then, run the following commands:

```bash
gh repo fork https://github.com/oceanprotocol/market.git --clone
cd market
```

This creates a cozy new directory named `market` and takes you right into it.

1. **Install node modules:** Run the following command:
    
    ```jsx
    npm install
    ```
    
2. **Run the dApp:** Run the following command:
    
    ```bash
    npm start
    ```
    

You will see the following output. How cool it is, it just took us a fork command!

![ocean-ezgif.com-gif-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%203%20Set%20up%20Your%20First%20Project/ocean-ezgif.com-gif-to-webp-converter.webp)

You should also connect your wallet!

![oceanwalletconnect.gif](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%203%20Set%20up%20Your%20First%20Project/oceanwalletconnect.webp)

## Wrap Up

Fantastic! You've successfully taken the first step. Now it’s time to make this marketplace yours! We'll dive into customization in the next lesson. Stay tuned!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/1.%20Getting%20Started/Lesson%203%20Set%20up%20Your%20First%20Project.md

Set up Your First Project

# Own Your Marketplace

Welcome back! We are excited to have you back! In this lesson, you'll learn how to personalize your marketplace by changing its name and updating the logo. These steps are essential for creating a unique identity for your platform. 

We’ll use our code editor, Visual Studio Code (VS Code), for this process as it offers a straightforward way to search and replace text and organize files.

## Changing Your Marketplace Name

1. **Open Your Code Editor**
    - Start by opening your project in a code editor. In this example, we’ll use VS Code, which has powerful search-and-replace functionality.
2. **Using the Search and Replace Function**
    - In the left-hand panel of VS Code, click on the **magnifying glass icon**. This opens up the search and replace interface.
        
        ![oceanc3-ezgif.com-jpg-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%204%20Own%20Your%20Marketplace/oceanc3-ezgif.com-jpg-to-webp-converter.webp)
        
    - Here’s how to replace the old name with your custom marketplace name:
        - **Enter “Ocean Marketplace”** in the first textbox (arrow 1 in the example).
        - **Enter your new marketplace name** in the second textbox (arrow 2). We will be naming it Metaschool Marketplace.
        - There’s a button to the right of the second textbox (arrow 3) that will allow you to **replace all instances at once**.
3. **Confirm the Replacements**
    - If you’d like to review each instance before confirming, you can do so. Otherwise, click the replace-all button to make the changes in one go.
        
        ![oceanc31-ezgif.com-jpg-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%204%20Own%20Your%20Marketplace/oceanc31-ezgif.com-jpg-to-webp-converter.webp)
        
4. **Replacing Other Variants of the Name**
    - Repeat the above steps, this time searching for “Ocean Market” instead of “Ocean Marketplace.”
    - We replaced “Ocean Market” with “Metaschool Market.”

## Updating Your Logo

To make your marketplace visually distinctive, you’ll replace the default logo with your own. We recommend using the SVG format for the best visual quality and scalability.

1. **Locate the Logo File**
    - In your file directory, navigate to `src/@images/logo.svg`.
    - This is where the default logo is stored.
2. **Replace the Logo File**
    - **Delete the existing logo.svg file** in that folder.
    - **Add your logo** by pasting it into the same folder. Ensure it’s in SVG format for compatibility.
3. **Rename Your Logo File**
    - Rename your logo to **`logo.svg`**. This way, the marketplace will automatically pick up your logo without additional changes in the code.

### Step 3: Preview Your Changes

Once you’ve changed the marketplace name and logo, it's time to check how everything looks.

1. **Save All Your Changes**
    - Make sure you save all changes you made in your code editor.
2. **Restart Your Development Server**
    - In your terminal, stop the current build process by pressing **Ctrl + C** (Windows/Linux) or **Cmd + C** (Mac).
    - Start the development server again by running:
        
        ```
        npm start
        ```
        
3. **Preview Your Marketplace**
    - Once the build is complete, navigate to [**http://localhost:8000/**](http://localhost:8000/) to view your updated marketplace.
    - Confirm that your new marketplace name and logo appear correctly.

Here’s what the output looks like for me. Yes, it’s the Metaschool market now!!! What’s yours?

![oceanc33-ezgif.com-jpg-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%204%20Own%20Your%20Marketplace/oceanc33-ezgif.com-jpg-to-webp-converter.webp)

## Wrap Up

That’s it! You’ve successfully changed the name and logo of your marketplace. Customizing these elements is an essential step toward building a brand identity for your platform. Continue experimenting and personalizing other aspects to make it truly your own.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/2.%20Build%20Your%20Own%20Marketplace/Lesson%204%20Own%20Your%20Marketplace.md

Own Your Marketplace

# Customize the Styling of Your Marketplace

Welcome back! You were great in the last lesson by updating the name and logo of your marketplace. In this lesson, we’ll go over how to apply your brand’s colors, background, and fonts to make your marketplace truly unique. This includes updating the background, setting your brand colors, and changing the fonts used across the site. Let’s get started!

## Changing the Background

Let’s begin by replacing the default background with your own custom background color or image.

1. **Open the CSS File**
    - Go to the `src/components/App/index.module.css` file in your project.
2. **Set Your Background**
    - On **line 3**, you’ll see the current background setting (e.g., the default wave background).
        
        ![oceanc32-ezgif.com-jpg-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%205%20Customize%20the%20Styling%20of%20Your%20Marketplace/oceanc32-ezgif.com-jpg-to-webp-converter.webp)
        
    - To apply your own background:
        - **Save your new background image** in the `src/@images/` folder (same folder as your logo).
        - **Update the CSS** by replacing the old background file location with the path to your new background image.
        - We have taken a completely black background and will be using that.
3. **Adjust the Background Position and Repeat**
    - If your background only covers part of the page:
        - Set the background to **start at the top** and **repeat vertically** by updating `background-position` and setting `background-repeat: repeat;`.
        - This will ensure your background image fills the entire page. We will be doing that.
            
            ![oceanc34-ezgif.com-jpg-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%205%20Customize%20the%20Styling%20of%20Your%20Marketplace/oceanc34-ezgif.com-jpg-to-webp-converter.webp)
            

### Preview

1. **Save All Your Changes**
    - Make sure to save each file after making updates.
2. **Restart Your Development Server**
    - Stop the server if it’s running by pressing **Ctrl + C** (Windows/Linux) or **Cmd + C** (Mac).
    - Restart the server with `npm start`.
3. **Check Your Marketplace**
    - Head to [**http://localhost:8000/**](http://localhost:8000/) and verify that your background, colors, and fonts now match your branding.

    ![oceanc35-ezgif.com-jpg-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%205%20Customize%20the%20Styling%20of%20Your%20Marketplace/oceanc35-ezgif.com-jpg-to-webp-converter.webp)

## Updating Brand Colors

Now, let’s update the color scheme of your marketplace to align with your brand.

1. **Open the Color Variables File**
    - Go to `src/global/_variables.css`.
    - This file contains global color variables, which define the primary colors used across the site.
2. **Set Your Brand Colors**
    - Review the current color variables, such as `-primary-color` and `-secondary-color`.
    - Replace these values with your brand’s color codes. For example:
        
        ```css
        --primary-color: #YourPrimaryColorCode;
        --secondary-color: #YourSecondaryColorCode;
        ```
        
3. **Experiment with Colors**
    - Feel free to get creative and change as many colors as you need to achieve the look you want.
    - **Save each change** to see how it affects your marketplace in real-time.
    - We haven’t changed this since the purple color matches our theme. But you should go with your own style and show us how it turned out!

## Customizing Fonts

Fonts play an essential role in setting the tone for your brand, so let’s update them to fit your style.

1. **Choose Your Font**
    - If you already have a brand font, you’re ready to go!
    - If not, visit [Google Fonts](https://fonts.google.com/) to explore font options. Google Fonts allows you to preview fonts and provides easy-to-follow instructions for importing them into your project.
2. **Import the Font**
    - If using Google Fonts, copy the provided `@import` code snippet and paste it at the **top of the** `src/stylesGlobal/_variables.css` **file**.
3. **Set the New Font**
    - In the same file (`src/global/_variables.css`), scroll down to **lines 36 to 41** where the font settings are defined.
    - Replace the old font family names with your new font(s). For example:
        
        ```css
        font-family: 'YourFontName', sans-serif;
        ```
        
        I have changed my font, can you see the difference?
        
        ![oceanc36-ezgif.com-jpg-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%205%20Customize%20the%20Styling%20of%20Your%20Marketplace/oceanc36-ezgif.com-jpg-to-webp-converter.webp)
        
4. **Save and Preview**
    - As with colors, save each change and refresh the page to see how the new font fits with your marketplace.

### Preview

Just iterating the steps for you again:

1. **Save All Your Changes**
    - Make sure to save each file after making updates.
2. **Restart Your Development Server**
    - Stop the server if it’s running by pressing **Ctrl + C** (Windows/Linux) or **Cmd + C** (Mac).
    - Restart the server with `npm start`.
3. **Check Your Marketplace**
    - Head to [**http://localhost:8000/**](http://localhost:8000/) and verify that your background, colors, and fonts now match your branding.

## Wrap up

Congratulations! You’ve successfully customized the styling of your marketplace. Personalizing these design elements is crucial to building a brand identity that stands out. Continue experimenting with these settings until you’re satisfied with the overall look.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/2.%20Build%20Your%20Own%20Marketplace/Lesson%205%20Customize%20the%20Styling%20of%20Your%20Marketplace.md

Customize the Styling of Your Marketplace

# Customize the Publish Form on Your Marketplace

Kudos on customizing the dApp so far! In this lesson, we’ll walk through how to update the publish form on your marketplace. Since your marketplace is focused on photos rather than datasets, we’ll modify the text, asset types, and visual elements to create a more relevant experience for your users. Let’s dive in!

## Update Publish Form Text

First, we’ll change the publish form to clarify that it’s meant for publishing and selling photos, not datasets.

1. **Locate the Text Configuration File**
    - Open `content/publish/index.json`.
2. **Edit the Form Text**
    - Find any mentions of “datasets” and change the language to reflect “photos.”
    - Update any descriptive text to explain that this form is specifically for users to upload and sell their photos.
    - We have updated it like this:
        
        ```json
        {
          "title": "Publish",
          "description": "Highlight the important features of your photo to make it more discoverable and catch the interest of the consumers.",
          "warning": "Publishing into a test network first is strongly recommended. Please familiarize yourself with [the market](https://oceanprotocol.com/technology/marketplaces), [the risks](https://blog.oceanprotocol.com/on-staking-on-data-in-ocean-market-3d8e09eb0a13), and the [Terms of Use](/terms).",
          "tooltipAvailableNetworks": "Assets are published to the network your wallet is connected to. These networks are currently supported:"
        }
        ```
        
3. **Save Your Changes**
    - Save the file to apply the new text to your publish form.

## Change Asset Type to “Photo”

To align with your marketplace’s focus on photos, we’ll replace the “dataset” asset type with “photo” in the publish form.

1. **Open the Asset Type File**
    - Go to `src/components/Publish/Metadata/index.tsx`.
2. **Edit the Asset Type Label**
    - On **line 16**, replace “dataset” with “Photo”.
        
        ![oceanc38-ezgif.com-jpg-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%206%20Customize%20the%20Publish%20Form%20on%20Your%20Market/oceanc38-ezgif.com-jpg-to-webp-converter.webp)
        
    
    Keep your patience, we will soon see the results.
    

## Customize the SVG Waves for Data NFTs

Ocean Market includes an SVG wave generator to create images for Data NFTs. Let’s change these waves to use your brand colors for a cohesive look.

1. **Open the SVG Waves File**
    - Navigate to `src/@utils/SvgWaves.ts`.
2. **Change Wave Colors**
    - Look at **lines 27 to 30** where the wave colors are specified.
        
        ![oceanc39-ezgif.com-jpg-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%206%20Customize%20the%20Publish%20Form%20on%20Your%20Market/oceanc39-ezgif.com-jpg-to-webp-converter.webp)
        
    - Replace the current pink color with your brand color. For example:
        
        ```tsx
        waveColor: '#YourBrandColor'
        ```
        
3. **Optional: Customize the SVG Design**
    - For more customization, look at **lines 53 to 64**:
        
        ![oceanc310-ezgif.com-jpg-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%206%20Customize%20the%20Publish%20Form%20on%20Your%20Market/oceanc310-ezgif.com-jpg-to-webp-converter.webp)
        
        - **Change Layer Count**: Adjust the number of layers from 4 to 5, or experiment with different values to see how it affects the visual depth.
        - **Modify Wave Patterns**: Adjust parameters like wave height, amplitude, or frequency to create a unique look.

## Preview Your Customized Publish Form

1. **Save All Changes**
    - Make sure to save all updates to your files.
2. **Restart the Development Server**
    - If your server is running, stop it by pressing **Ctrl + C** (Windows/Linux) or **Cmd + C** (Mac).
    - Restart with `npm start`.
3. **Preview Your Changes**
    - Navigate to **http://localhost:8000/publish** and check that the publish form now invites users to publish photos, offers “Photo” as an asset type, and displays the SVG waves in your brand colors.

![oceanform-ezgif.com-gif-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/Lesson%206%20Customize%20the%20Publish%20Form%20on%20Your%20Market/oceanform.webp)

## Wrap Up

Your publish page is now fully customized for your photo marketplace, complete with new text, asset type, and branding colors. This personalization will provide a seamless experience for your users, reinforcing your marketplace's unique identity. Great work!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/2.%20Build%20Your%20Own%20Marketplace/Lesson%206%20Customize%20the%20Publish%20Form%20on%20Your%20Market.md

Customize the Publish Form on Your Marketplace

# Wrap up

Congratulations! You've completed customizing your marketplace. Yes, that’s awesome. You are cool!!!

## Building Your Own Marketplace

Here’s a quick recap of how to personalize your marketplace:

1. **Change the Marketplace Name and Logo**: We used VS Code’s search-and-replace feature to quickly update all instances of “Ocean Marketplace” with your marketplace’s new name.
2. **Customize the Styling**: Updated your color variables in `_variables.css` to apply your brand colors throughout the site for a cohesive look.
3. **Modify the Publish Form**: Changed the asset type label in `index.tsx` from “dataset” to “Photo” to make the form relevant to your marketplace’s focus on photos.

With these key customizations, your marketplace can be uniquely branded and ready for your audience!

## ⚒️ A Call to Contribute

Great news! This course, like all projects on our platform, is 100% open-source. You can find the tutorial markdown files in our [repository](https://github.com/0xmetaschool/Learning-Projects). If you spot any issues or have ideas for improvements, we encourage you to contribute. We at Ocean Protocol love community contributions and acknowledge contributors on our [Discord](https://discord.com/invite/vbVMUwXWgc) and GitHub.

While you're contributing:

1. Don't forget to star ⭐️ our repository. We'd be incredibly grateful! ❤️
2. We're committed to remaining a free educational platform. Please consider following us on [X (formerly Twitter)](https://x.com/0xmetaschool) and [LinkedIn](https://www.linkedin.com/company/0xmetaschool/) to support our mission. 🫶
3. Subscribe to our [YouTube](https://www.notion.so/Lesson-23-Wrap-Up-650d58347f8744b182f515e1f5ac6a7f?pvs=21) channel for exciting videos. ✨

## 🎊 Congratulations!

You've completed the third course of Ocean Protocol track and have your own marketplace.

Remember, the ocean of possibilities is vast, and you've just begun to explore its depths. Keep building, keep learning, and keep pushing the boundaries of what's possible with decentralized data.

WAGMI! Sail on, data explorer! 🌊🚀

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C3%20Build%20Decentralized%20Marketplace%20on%20Ocean%20Protocol/3.%20Wrap%20It%20Up/Lesson%207%20Wrap%20up.md

Wrap up

Build Decentralized Marketplace on Ocean Protocol

Unlock the power of data with our Ocean Protocol course! Gain a deep understanding of its mission, architecture, and role in transforming the data economy. Join us to master this cutting-edge technology and shape the future of data and AI!

# What Are We Learning Today?

Hey there fellas 👋, GM. We are very excited to bring the first-ever learning tutorial for developers in the Ocean Protocol on the Metaschool platform. Exciting right?

So, what exactly is the Ocean? Ocean Protocol is an open-source protocol designed to unlock the value of data for AI. Integrating blockchain technology and decentralized architecture establishes a secure and transparent sharing and exchange ecosystem for data and AI algorithms. This protocol empowers data and algorithms owners to retain control over their assets while enabling them to monetize their assets through various economic models.

![slide1 (1).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%201%20What%20Are%20We%20Learning%20Today/slide1_(1).webp?raw=true)

The core objective of Ocean Protocol is to foster a thriving data economy by providing the necessary tools and infrastructure for data scientists and enthusiasts. It facilitates the creation of decentralized data and AI models marketplaces where users can publish, discover, and consume data assets. The protocol incentivizes network participation through the ASI (formerly OCEAN) token, rewarding users for contributing to data liquidity, data mining and platform security.

Before moving forward, let's delve into the tutorial's curriculum and explore the specific skills and knowledge you will acquire upon completion.

## Course Overview

We will:

1. Understand the problem Ocean Protocol is solving.
2. Understand the initial development and growth prospects of the Ocean Protocol.
3. Understand the mission and vision of the Ocean Protocol.
4. Get a deep understanding of what exactly Ocean Protocol is and how it solves data-driven problems.
5. Understand the different opportunities Ocean protocol is giving to the developers.
6. Understand the architecture of the Ocean Protocol in detail.

## Who exactly should take this course?

This Ocean Protocol course is for blockchain enthusiasts excited to know how Ocean Protocol brings AI empowerment and for the peeps who want to contribute to the Ocean Protocol ecosystem.

## What will you be getting out of this course?

You will be getting the following outcomes when you complete this course:

1. Deep understanding of Ocean Protocol.
2. Architectural understanding of the Ocean Protocol.
3. Claim your NFT on course completion

## Proof of completion
If you complete this course, you will get a special NFT, a utility token, which will unlock many more opportunities on the Metaschool platform. Here is what the NFT looks like.

![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20C1%20/Lesson%201%20What%20Are%20We%20Learning%20Today/oceanc1.webp)


Now before we move forward, let’s set some house rules first.

1. Kindly do your quick assignments properly.
2. Join [our discord server](https://bit.ly/core-course-discord) and ask all relevant questions there.
3. We are a free open-source platform and if you follow us on [X](https://bit.ly/core-course-twitter) and [LinkedIn](https://bit.ly/core-course-linkedIn), it would be a great support. 🫣
4. You can subscribe to our [YouTube](https://bit.ly/core-course-youtube) channel for exciting videos too. ✨
5. Stay happy and positive!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C1%20Introduction%20to%20Ocean%20Protocol/1.%20Getting%20Started%20with%20Ocean%20Protocol/1.%20What%20Are%20We%20Learning%20Today.md

What Are We Learning Today?

# The Origin of Ocean Protocol

Hey there, everyone!! We're thrilled you've decided to join us again and take your knowledge to the next level!

Before we dive into the Ocean Protocol, let's take a step back and understand why it was created. What's the big problem it aims to solve? And how does the Ocean Protocol come to the rescue? 

Before diving into the problem let’s revise the AI and blockchain, what problems they are solving separately, and how combining them can make changes. Let's find out together!

## The love for AI and Blockchain

Bruce Pon and Trent McConaghy, the co-founders behind Ocean Protocol, are huge fans of AI. Why? Because AI makes life easier and tackles big challenges. Imagine this: AI can take a huge research paper and summarize it, or even help computer programs evolve and make a difference. Trent finds this super fascinating! As he puts it:

![qoute-1-ezgif.com-optipng.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%202%20The%20Origin%20of%20Ocean%20Protocol/qoute-1-ezgif.com-optipng.webp?raw=true)

McConaghy's journey with blockchain began in 2013 when he and Bruce Pon co-founded Ascribe, a platform that used the Bitcoin blockchain to protect intellectual property (in the form of NFTs). This experience sparked his interest in the potential of blockchain to create a more secure and decentralized world.

Fast forward to 2016, Bruce and Trent wondered, "What if we could combine the magic of AI with the power of blockchain? How epic would that be?"

Picture this: Just like how blockchain can keep your cryptocurrency safe, it can also ensure that AI systems run smoothly and securely without a hitch. How exciting is that?

With stars in their eyes, they began exploring all the problems in the AI world that blockchain could fix. Let's dive into one of the major issues that blockchain can tackle.

## The problem

In the AI world, the biggest challenge is striking the right balance between leveraging data's potential and respecting user privacy.
Imagine this: Big companies like Google and Facebook have mountains of data and tons of AI know-how, but they can't just share it all with the world. Why? Because much of this data is personal and private—think medical records, financial information, or even just your daily habits. Sharing this data publicly would be both illegal and unethical.

Our world thrives on data, but the key is finding ways to share the *right kind* of data. This means focusing on data that's been anonymized or aggregated so that it doesn't reveal anyone's identity or sensitive information. Think about traffic patterns across a city or general trends in what people like to buy online. When this kind of non-personal data is shared responsibly, it can open up a world of possibilities for AI innovation.

![slide2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%202%20The%20Origin%20of%20Ocean%20Protocol/slide2.webp?raw=true)

Picture having access to anonymized data about how people use Google Maps. You could develop apps that predict traffic jams with incredible accuracy, helping everyone plan their routes more efficiently. Or imagine using aggregated data about online recipes to create a smart kitchen assistant that suggests personalized meal plans or even guides you through cooking a dish step-by-step.

The future of AI lies in finding creative and ethical ways to share data that benefit everyone while ensuring that individual privacy is always protected. To get a visual understanding of how Ocean Protocol is working towards this future, you can watch their informative video: [Ocean Protocol - Building a New Data Economy](https://www.youtube.com/watch?v=4P72ZelkEpQ).

## The solution

The problem itself holds the key to the solution! The answer? A super cool platform that lets everyone access data easily and securely.

Enter the marketplace! Imagine a decentralized marketplace where anyone can offer and access datasets and algorithms - just like hugging face but fully self-sovereign and decentralized. It's like an online bazaar for data and models! One person can sell their assets, and anyone else can buy them safely and securely through this platform.

![slide3.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%202%20The%20Origin%20of%20Ocean%20Protocol/slide3.webp?raw=true)

Picture this: Just like Etsy lets you buy handmade crafts from around the world, this data marketplace lets you buy and sell valuable data and algorithms. It’s a win-win for everyone, making data accessible and usable for all sorts of amazing projects!

## Initial development

In May 2017, the Ocean Protocol team unveiled a prototype marketplace for self-driving car data at the NYC Consensus. They even dabbled with zero-knowledge proofs to keep data super private.

But, like a homemade rocket that didn't quite reach the stars, this prototype didn't perform as well as hoped. It just wasn’t fast enough for the high-speed world of industrial development.

Imagine trying to race a go-kart in a Formula 1 race—it’s fun, but it just won’t keep up! Trent and his team learned a lot from this experiment, gearing up for even better solutions ahead.

## Launch and vision

In early 2017, a Singapore startup's CEO from Centralized Data Exchange saw the huge potential in decentralized tech and started working together with Trent and Bruce. 

Together they created an entire ecosystem of marketplaces, exchanges, and ways to supply, consume, and trade data. They created a network, a protocol, and a whole ecosystem to make this dream come true. That’s how the idea of the Ocean was born. Ocean would handle storing metadata, linking to data, and much more.

Imagine the Ocean as a vast digital sea where many marketplaces can float, all accessing the same treasure troves of data. It’s like having multiple ports where ships (marketplaces) can dock and trade valuable goods (data).

Trent McConaghy and his team believe Ocean will unlock their vision of a global data commons. The design of Ocean’s tokens reflects this ambitious goal, making data sharing as easy as trading Pokémon cards at recess!

## That’s a wrap

Ocean Protocol is a fantastic platform that tackles the big challenges in the world of AI. Imagine it as a giant, friendly octopus, spreading its tentacles to help everyone get the data they need.

The team is working hand-in-hand with DEX, other marketplaces, data regulators, data suppliers, and data consumers to turn this vision into reality.

In our next adventure, we'll dive deep into the Ocean Protocol, exploring its depths and discovering how it all works. Get ready to make a splash!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C1%20Introduction%20to%20Ocean%20Protocol/1.%20Getting%20Started%20with%20Ocean%20Protocol/2.%20The%20Origin%20of%20Ocean%20Protocol.md

The Origin of Ocean Protocol

# Understanding Ocean Protocol

Hey there! Ready to dive into the world of Ocean Protocol? Don't worry, we'll take it nice and easy. Grab a cup of coffee (or tea, if that's your thing), and let's chat about this cool technology that's making waves in the world of AI and data.

## What's the big deal with Data and AI, anyway?

Before we jump into Ocean Protocol, let's talk about why data and AI are such hot topics these days. You know how your phone seems to know exactly what you want to watch or buy? That's all thanks to AI-powered by vast amounts of data. Companies collect information about what we like, what we do, and even where we go. This data helps AI systems make smart guesses about what we might want next.

But here's the thing: most of the time, we don't have much say in how our data is used, and a lot of valuable data is locked away in silos. This means AI development can be slower and less diverse than it could be. Imagine if AI could access more varied data - we might solve big problems faster!

That's where Ocean Protocol swims in to save the day!

## So, what exactly is Ocean Protocol?

Ocean Protocol is like a giant, digital farmers' market for data. Instead of veggies and fruits, people buy and sell information and AI algorithms. It's a decentralized data exchange protocol designed to unlock the potential of data and AI to solve problems and improve lives.

Here's what makes it special:

1. You can sell your data or AI models if you want to - all whilst keeping them private.
2. AI researchers and companies can buy the data they need to train better AI systems.
3. Everyone plays by fair rules, thanks to some clever blockchain technology and clear traceability. 

The best part? It's all decentralized, which is a fancy way of saying no single company or person is in charge of the data - other than the data owner itself. It's kind of like how Bitcoin works but for data and AI instead of money.

Technically speaking, Ocean Protocol is a decentralized data exchange protocol built on blockchain technology. It uses smart contracts to facilitate secure and transparent data transactions.

## Who's Who in the Ocean Protocol world

Let's meet the main characters in this data and AI world:

![Main Component of Ocean protocol (2)](https://github.com/user-attachments/assets/f7f065c5-9bf1-400b-a308-0f61376cf7af)


### Data Providers

These are the folks who have data to sell. Maybe you've been tracking your fitness routine for years, or you're a weather enthusiast with a backyard weather station. With Ocean Protocol, you can package up that data and put it up for sale.

The cool thing is that your data never actually touches Ocean Protocol. It stays safely wherever you've stored it (like on your computer or in the cloud). Ocean just helps you sell access to it.

In technical terms, when you publish data on Ocean Protocol, you're creating a Data NFT (a unique ERC721 token) and minting Datatokens (ERC20 tokens) that grant access to your dataset.

### Data Marketplaces

These are websites or apps built using Ocean Protocol where data providers and buyers can meet up. Think of them like eBay or Amazon but for data. These marketplaces or dApps help you find the data or AI models you're looking for or sell the ones you have.

### Data Consumers

These are the people or companies looking to buy data assets. Maybe it's a startup working on a new fitness app, or a researcher studying climate patterns, or a data scientists looking to sell access to its algorithms. They come to Ocean Protocol marketplaces to find or sell the AI assets they want.

### Curators

Curators are the quality control experts of the Ocean ecosystem. They earn ASI tokens to maintain valuable public datasets. Think of them like librarians but for data. They help organize, verify, and highlight the most useful and reliable datasets, making it easier for everyone to find high-quality data.

### Developers

Developers are the builders in the Ocean world. They can be incentivized with ASI tokens for creating marketplaces and applications that bring communities together. These could be specialized data marketplaces for specific industries, tools that make it easier to analyze data or innovative apps that use Ocean Protocol in new and exciting ways. They're like the architects and construction workers, building the infrastructure that makes the Ocean ecosystem thrive.

## How does it all work?

Okay, let's walk through how you might use Ocean Protocol. Don't worry if some of this sounds a bit techy – the idea is to give you a general feel for how things flow.

![User flow for Ocean (2).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%203%20Understanding%20Ocean%20Protocol/User_flow_for_Ocean_(2).webp?raw=true)

1. **Packaging your data**: Let's say you want to sell that fitness data we talked about earlier. First, you'd upload your data to a secure place (like Google Drive or your own server).
2. **Secure storage**: Ocean Protocol cleverly uses encryption techniques to keep your data safe. It encrypts the URL where your data is actually stored and only decrypts it for authorized users who have the correct data tokens. This ensures that your data remains secure and accessible only to those with permission.
3. **Creating a data asset**: Next, you'd use Ocean Protocol to create a "data asset." This is like creating a listing for your data. You'd describe what kind of data it is, set a price, and decide who's allowed to buy it.
4. **Listing on a Marketplace**: Your data asset then shows up on Ocean Protocol marketplaces. It's visible to potential buyers, but they can't actually see your data yet – just the description you provided.
5. **Making a sale**: When someone wants to buy your data, they'll make a request through the marketplace. This is where Brizo steps in to handle all the nitty-gritty details.
6. **Share Data Asset**: Ocean Protocol uses smart contracts and tokengating to control access to data. When someone wants to buy data, the system automatically checks if they have the required datatokens. If they do, the encrypted URL of the data source is decrypted, allowing access. This process is entirely automated, ensuring secure and efficient data sharing without the need for manual verification.
7. **Getting paid**: Once the buyer has received the data, you get paid! The payment is usually in ASI tokens.

From a technical perspective, this process involves interacting with various components of the Ocean Protocol stack, including Keeper Contracts for on-chain registration and transaction management, and potentially the Compute-to-Data feature for privacy-preserving data usage.

## Why should you care?

Ocean Protocol is trying to solve some pretty big problems in the world of AI and data:

![Ocean protocol_ Why should you care.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%203%20Understanding%20Ocean%20Protocol/Ocean_protocol__Why_should_you_care.webp?raw=true)

1. **Data Silos**: By making it easy to share data securely, Ocean helps break down the data silos that are slowing down AI innovation.
2. **AI Democratization**: With easier access to diverse data and AI models, more people and companies can participate in AI development, not just the tech giants.
3. **Privacy and Control**: You get to decide who sees your data or uses your AI models and how they're used. No more feeling like your valuable assets are out of your control.
4. **New Opportunities**: Have valuable data or AI skills? Now you can monetize them without giving up control.
5. **Better Research**: Scientists and AI researchers could get access to data and models that were previously locked away, potentially leading to breakthroughs in fields like healthcare, climate science, and more.

## Wrapping Up

And there you have it – a friendly intro to Ocean Protocol! It's a pretty exciting technology that could change how we think about, use, and benefit from data and AI. Instead of data and AI knowledge being hoarded by a few big companies, it could become a resource we all actively manage, share, and benefit from. 

Don't worry if some of the technical terms we've mentioned seem a bit confusing right now. In future lessons, we'll break down these technical jargons and concepts one by one. In fact, in our next lesson (Lesson 4), we'll dive deep into the architecture of Ocean Protocol. We'll explore how all the components we've briefly touched upon fit together to create this powerful ecosystem.

Get ready to put on your technical hat as we unravel the layers and components that make Ocean Protocol tick. We'll break down the blockchain foundation, the middleware, the application layer, and more. It's going to be an exciting journey into the inner workings of this innovative platform!
Keep your curiosity flowing, and prepare to dive deeper into the ocean of possibilities!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C1%20Introduction%20to%20Ocean%20Protocol/1.%20Getting%20Started%20with%20Ocean%20Protocol/3.%20Understanding%20Ocean%20Protocol.md

Understanding Ocean Protocol

# Understanding Ocean Protocol's Core Components

Helloooo developers!! In our last lesson, we got acquainted with the basics of Ocean Protocol and its key players. Now, it's time to dive deeper into the technical waters of Ocean Protocol's architecture. Don't worry if you're not a tech expert – we'll break everything down into digestible chunks. 

Today, we're going to explore how Ocean Protocol is built from the ground up, layer by layer and learn about key concepts before we deep dive into the architecture. By the end of this lesson, you'll have a clear overview of Ocean Protocol's core components. So, take a deep breath, and let's dive in!

## Ocean Protocol Architecture: A Simple Overview

Ocean Protocol's architecture is designed to facilitate secure, transparent, and efficient data sharing and AI services. It's built-in layers, each with specific functions and components. Let's take a look at these layers:

![Ocean C1 L4 Gif 1.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%204%20Understanding%20Ocean%20Protocol's%20Core%20Component/Ocean_C1_L4_Gif_1.webp?raw=true)

### The Foundational Blockchain Layer

This is the base layer of Ocean Protocol. It's built on blockchain technology, providing the security, transparency, and decentralization Ocean Protocol needs. Key components in this layer include: Smart contracts, Data NFTs (Non-Fungible Tokens, following the ERC721 standard), Datatokens (following the ERC20 standard), etc.

### The Middle Layer

This layer provides tools and services that developers and applications use to interact with Ocean Protocol. It includes: Libraries like Ocean.js (for JavaScript) and Ocean.py (for Python), Ocean Nodes - which handle various backend processes, and the Compute-to-Data environment, which allows for privacy-preserving computations.

### The Application Layer

This is where users actually interact with Ocean Protocol. It includes: Ocean Market - the main decentralized marketplace for data, and other third-party applications built on Ocean Protocol.

### The Wallet Layer

This top layer allows users to manage their digital assets within the Ocean Protocol ecosystem. It primarily consists of Web3 wallets that can hold and transfer Data NFTs and Datatokens.

These layers work together like a well-oiled machine - or should we say, a well-encrypted data ocean? Now that we've dipped our toes into the Ocean Protocol's architecture, let's dive deeper and explore some key terms. Don't worry, we won't need scuba gear for this adventure!

## Key Terms for Understanding Ocean Protocol Architecture

Before we jump into the Ocean Protocol pool, let's learn some cool words. These words are like the special tools in our data toolbox. Don't worry if you don't remember them all right away - we're here to have fun and learn together! These terms form the building blocks of Ocean Protocol, and understanding them will significantly enhance our grasp of how the entire system functions.

- DID (Decentralized Identifiers)
- DDOs (Decentralized Data Objects)
- Metadata
- Data NFTs
- Datatokens
- Compute-to-Data

![Ocean C1 L4 gif 2 (2) (1).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%204%20Understanding%20Ocean%20Protocol's%20Core%20Component/Ocean_C1_L4_gif_2_(2)_(1).webp?raw=true)

Each of these plays a vital role in Ocean Protocol's ecosystem, enabling secure data sharing, access control, privacy-preserving computations, and decentralized identity management. By getting acquainted with these terms, you'll be better equipped to understand the intricate workings of Ocean Protocol's architectural layers. So, ready to dive deeper and see how all these pieces fit together? Don't worry, We'll be right here to explain things as we go. It's gonna be a fun ride!

### Decentralized Identifiers (DIDs) in Ocean Protocol

Decentralized Identifiers, or DIDs, are a crucial component in Ocean Protocol's data ecosystem. Think of a DID as a unique identification for each piece of data or asset within the network. It's like giving each fish in the ocean its own special name tag. Just as you wouldn't mix up Nemo the clownfish with Dory the blue tang, DIDs make sure every bit of data in Ocean Protocol stands out in the vast sea of information.

**What makes DIDs special?**

1. **Decentralized Nature**: Unlike traditional identifiers that rely on central authorities (like how a government issues passports), DIDs operate without any central controlling entity. This decentralization aligns with Ocean Protocol's goal of creating a more open and transparent data economy.
2. **Verifiability**: DIDs allow for easy verification of the data asset's authenticity. When you encounter a DID, you can be confident that it truly represents the data asset it claims to, without needing to trust a third party.
3. **Persistence**: Once created, a DID remains valid and unchanged, providing a stable reference point for the data asset throughout its lifecycle.
4. **Resolvability**: Each DID can be "resolved" to reveal more information about the data asset it represents. This resolution process leads to a DID document, which contains metadata and other crucial details about the asset.

**How DIDs work in Ocean Protocol**

In Ocean Protocol, when a data owner publishes a new dataset or service, it's assigned a unique DID. This DID serves several important functions:

1. **Identification**: It provides a clear, unambiguous way to refer to that specific data asset within the Ocean ecosystem.
2. **Discovery**: DIDs help in the process of finding and accessing data. When users search for data in Ocean Protocol, they can use DIDs to pinpoint exact datasets.
3. **Metadata Association**:  In Ocean Protocol, each data asset is associated with a unique Decentralized Identifier (DID), which is a string of characters and numbers. This DID points to a Decentralized Identifier Document (DDO) containing the asset's metadata. When you publish an asset to the Ocean market, a Data NFT, Data token, and DDO are created simultaneously. The DID, obtained when minting the NFT, can be used with a resolver to fetch the metadata stored in the DDO. This metadata helps potential users understand the dataset's contents, quality, origin, and other important characteristics.

By using DIDs, Ocean Protocol creates a robust, decentralized system for managing data assets. This system ensures that data can be shared, discovered, and utilized efficiently while maintaining the security and integrity that's crucial in today's data-driven world.

### DDOs (Decentralized Data Objects) in Ocean Protocol

DDOs are a crucial component of Ocean Protocol's data management system. They are like super-detailed labels for data in Ocean Protocol. Imagine if every suitcase at the airport had a tag that told you everything about what's inside, who packed it, and where it's been. That's what DDOs do for data!

![Ocean L4 gif3.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%204%20Understanding%20Ocean%20Protocol's%20Core%20Component/Ocean_L4_gif3.webp?raw=true)

Let's break down how they work and their role in Ocean:

1. **Structure and Content:**
    - A DDO is a JSON object, which means it's structured in a key-value pair format that's both human-readable and machine-parsable.
    - It contains several key pieces of information about a data asset:
        - **Metadata**: Essential information about the asset (name, description, creator).
        - **Services**: Defines access for an asset, each represented by its datatoken. At least one service is required for accessibility.
        - **Credentials**: Optional fine-grained permissions using "allow" and "deny" lists, enhancing access control beyond datatoken ownership.
        - **NFT Details**: Information about the associated NFT (address, name, symbol).
        - **State**: Indicates the asset's current status (e.g., Active, End-of-life, Deprecated) affecting discoverability and ordering.
        - **Datatokens**: Lists the datatokens associated with the asset's services.
        - **Event Information**: Records details about the last creation or update transaction of the DDO.
        - **Purgatory**: Contains the asset's purgatory status, influencing user actions in marketplace interfaces.
        - **Statistics**: Various statistical fields about the asset.
        - **Compute-to-Data**: For applicable assets, includes additional fields like compute attributes, publisher-trusted algorithms, and consumer parameters.
2. **Relationship with DIDs:**
    - Each DDO is associated with a unique DID (Decentralized Identifier).
    - This relationship allows for a decentralized yet verifiable way to manage asset information.
3. **Use in Asset Interaction:**
    - The DDO provides all the necessary information for interacting with a data asset.
    - It specifies how to access the asset, what operations can be performed, and under what conditions.
    - This includes information about associated Data Tokens or NFTs, which control access rights.
4. **Storage and Retrieval:**
    - For GDPR compliance and enhanced privacy, DDOs are typically stored on-chain in an encrypted form.
    - A metadata cache service called Aquarius is used to efficiently store and retrieve DDOs. Aquarius is run directly via Ocean Nodes.
    - Only authorized parties can decrypt and read the DDOs
5. **Security and Access Control:**
    - The encryption of DDOs on-chain ensures that sensitive metadata is protected.
    - Access to decrypt and read DDOs can be controlled, allowing for fine-grained permissions.

In practice, when a data owner publishes a dataset on Ocean Protocol, a DDO is created and associated with a new DID. This DDO then becomes the go-to source of information for that dataset within the Ocean ecosystem. When a user wants to access or purchase the dataset, they interact with it through the information and mechanisms specified in the DDO.

### Metadata

Metadata is essential for asset discovery and evaluation in Ocean Protocol. It provides key information about data assets without exposing the actual data.

Key aspects:

- Content: Includes asset name, creation date, author, license, categories, tags, and description
- Structure: Part of the DID Document (DDO), stored as a JSON object
- Storage: Encrypted on-chain for GDPR compliance
- Access: Retrievable via metadata caches like Aquarius
- Usage: Enables users to find and assess relevant datasets efficiently
- Requirement: Mandatory for all datasets listed in Ocean-powered dApps

Metadata plays a crucial role in Ocean's ecosystem by facilitating data discovery while maintaining privacy and security. It allows users to make informed decisions about data assets without accessing the raw data itself.

## Wrap up

In this chapter, we explored the foundational elements of Ocean Protocol's architecture. We examined the protocol's layered structure and delved into three key components: Decentralized Identifiers (DIDs), Decentralized Data Objects (DDOs), and Metadata. These elements work together to create a robust system for unique asset identification, comprehensive data description, and efficient discovery.

By understanding these core components, we've laid the groundwork for grasping Ocean Protocol's decentralized data marketplace. In our next chapter, we'll build upon this foundation, exploring Data NFTs, Datatokens, and the Compute-to-Data feature, further unraveling the intricacies of this innovative data-sharing platform.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C1%20Introduction%20to%20Ocean%20Protocol/2.%20Ecosystem%20and%20Architecture%20of%20Ocean%20Protocol/4.%20Understanding%20Ocean%20Protocol's%20Core%20Components.md

Understanding Ocean Protocol's Core Components

# Data NFTs, Datatokens, and Compute-to-Data

Hey there, data friends! Welcome back to our Ocean Protocol fun time! Remember how we learned about the big picture last time? Well, this time we're going to look at some really cool stuff inside Ocean. We're going to talk about three super neat things that make Ocean Protocol special. We'll be covering Data NFTs, Datatokens, and the groundbreaking Compute-to-Data feature.
These things make Ocean Protocol really awesome for sharing and making money with data. Don't worry if it sounds tricky - we'll explain everything step by step. It's going to be fun, like finding treasure in a big ocean of information! Are you ready to dive in and learn more? Let's go!

![Ocean L5 gif1 (1).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%205%20Data%20NFTs,%20Datatokens,%20and%20Compute-to-Data/Ocean_L5_gif1_(1).webp?raw=true)

## Data NFTs

Imagine you have a super-special trading card - it's shiny, one-of-a-kind, and has your name on it. That's kind of what Data NFTs are in Ocean Protocol! These digital treasures represent ownership of data. Just as each trading card is unique, each Data NFT stands for a special piece of data that someone owns or has the rights to use. 

Data NFTs are a cornerstone of ownership and licensing in Ocean Protocol. They represent unique digital assets, specifically the ownership or exclusive license of a data asset on the blockchain. Let’s understand its key features:

**Key aspects of Data NFTs in Ocean Protocol:**

1. Creation Process:
    - When a user publishes a dataset on Ocean Protocol it automatically creates a new NFT.
    - This NFT serves as proof of the publisher's claim to the base intellectual property (IP) of the data asset.
2. Smart Contract Functionality:
    - The Data NFT smart contract is multifaceted, holding:
        - Metadata about the data asset
        - Role assignments (e.g., who can mint datatokens to use as access licenses)
        - Fee settings for accessing the data
        - An open-ended key-value store for custom fields
3. Technical Implementation:
    - Built on the ERC721 standard, ensuring compatibility with Ethereum and similar networks.
    - Utilizes the ERC721Factory contract, allowing base IP holders to create their own ERC721 contract instances.
    - Employs the ERC1167 proxy approach on the ERC721 template to optimize gas fees.
4. Ownership and Control:
    - The NFT holder has control over the associated data asset.
    - They can set access terms, pricing, and manage datatoken minting.
5. Interoperability:
    - Being based on a widely-adopted standard (ERC721), these NFTs can interact with various blockchain ecosystems and marketplaces.

Data NFTs form the foundation of Ocean Protocol's data ownership and licensing system, enabling a decentralized and transparent way to manage valuable data assets.

## Datatokens

Now, let's say you want to share your trading cards(Data NFTs) with your friends, but you want to decide who gets to come up and play. That's where Datatokens come in! They're like the secret passwords or special badges you give to your friends so they can access your trading card. In Ocean Protocol, Datatokens are the keys that unlock access to specific data NFT.

Technically, datatokens are the access control mechanism in Ocean Protocol, representing licenses to access specific data assets. They play a crucial role in the ecosystem's data economy.

**Key aspects of Datatokens:**

1. Nature and Purpose:
    - ERC20-compliant tokens representing access rights to specific data assets.
    - Each Data Token is linked to a particular Data NFT.
    - They act as sub-licenses from the base IP owner (Data NFT holder).
2. Value Derivation:
    - The value of Datatokens is based on:
        - Availability of the underlying dataset
        - Scarcity of access rights
        - Demand for the data
3. Functionality in the Ecosystem:
    - Enable easy trading, sharing, and accessing of data assets.
    - Allow users to consume associated datasets under predefined terms.
4. Technical Implementation:
    - Built on the ERC20 standard, ensuring wide compatibility with existing blockchain tools and platforms.
    - Multiple ERC20 Data Token contracts can be created for a single Data NFT.
    - Different Data Token contracts for the same NFT can represent varying license terms or access durations.
5. Flexibility and Customization:
    - Data owners can create multiple types of access rights for the same dataset.
    - This allows for tiered access, time-limited licenses, or other custom arrangements.
6. Economic Model:
    - Datatokens facilitate a liquid market for data access rights.
    - They can be traded on decentralized exchanges, creating a dynamic pricing mechanism for data.

Datatokens are the key to unlocking value in Ocean Protocol's data marketplace, allowing for granular control over data access while enabling a fluid economy around data assets.

## Compute-to-Data

Compute-to-Data (C2D) is an innovative feature in Ocean Protocol that addresses the challenge of utilizing valuable private data while maintaining strict privacy and control.

**Key aspects of Compute-to-Data:**

1. Core Concept:
    - Instead of moving data to where computation happens, C2D brings computation to the data.
    - Allows data owners to offer compute access to their private data without exposing the raw data.
2. Privacy Preservation:
    - Enables use of sensitive or proprietary data in computations without revealing the underlying data.
    - Maintains data owner's control over their asset throughout the process.
3. Process Flow:
    - Data remains in a secure environment controlled by the owner.
    - Approved algorithms or queries are sent to the data.
    - Computation occurs in a secure, isolated environment.
    - Only the computed results are returned, not the raw data.
4. Security Measures:
    - Secure transmission of algorithms to the data environment.
    - Execution in isolated environments to prevent data leakage.
    - Use of Confidential-EVM technology through Oasis Sapphire
    - Potential use of hardware-level security technologies like Intel SGX or ARM TrustZone for enhanced protection.
5. Use Cases:
    - Ideal for scenarios involving sensitive data, such as medical research, financial analysis, or proprietary business data.
    - Enables collaborative research and analysis without compromising data privacy.
6. Advantages:
    - Unlocks value from previously inaccessible data.
    - Encourages data sharing and collaboration in sensitive industries.
    - Reduces legal and compliance risks associated with data sharing.

Compute-to-Data represents a paradigm shift in how data can be utilized, offering a solution to the long-standing challenge of leveraging private data for broader benefits while maintaining strict control and privacy.

These three components work together to create a secure, flexible, and privacy-preserving data ecosystem:

- Data NFTs establish ownership and control over data assets
- Datatokens provide granular access control and enable monetization
- C2D allows for utilization of data while maintaining privacy and control

## Wrap up

In this lesson, we've explored three key components that form the backbone of Ocean Protocol's data ecosystem: Data NFTs, Datatokens, and Compute-to-Data. We've seen how Data NFTs establish ownership of data assets, Datatokens enable granular access control and monetization, and Compute-to-Data allows for data utilization while preserving privacy. These elements work in harmony to create a secure, flexible, and privacy-preserving marketplace for data.

Understanding these components is crucial for grasping the full potential of Ocean Protocol. In our next lesson, we'll build upon this knowledge as we deep dive into Ocean Protocol's architecture, exploring in detail the layers we introduced previously. We'll examine how these components fit into the broader architectural framework, providing you with a comprehensive understanding of how Ocean Protocol operates from the ground up.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C1%20Introduction%20to%20Ocean%20Protocol/2.%20Ecosystem%20and%20Architecture%20of%20Ocean%20Protocol/5.%20Data%20NFTs%2C%20Datatokens%2C%20and%20Compute-to-Data.md

Data NFTs, Datatokens, and Compute-to-Data

# Deep dive into Ocean’s Architecture

Hey, there developers, we hope you are doing great and coding epic stuff. We have been on a journey inside Ocean protocol and in this lesson, we're going to unravel the intricate architecture that makes decentralized data sharing possible. We'll explore the four key layers that form the backbone of Ocean Protocol: the Foundational Layer, the Middle Layer, the Application Layer, and the Wallets Layer. 

To bring these concepts to life, we'll follow the journey of a hospital's anonymized patient dataset as it navigates through each layer. By the end of this lesson, you'll understand how these layers work together to enable secure, transparent, and valuable data exchange in the Ocean ecosystem. Get ready to dive deep into an ocean of innovation and emerge with a clear understanding of how Ocean Protocol is revolutionizing data sharing!

## Layer 1: The Foundational Layer

The Foundational Blockchain Layer serves as the bedrock of Ocean Protocol, providing a decentralized and immutable ledger for all transactions and data asset representations. This layer leverages blockchain technology to ensure transparency, security, and trust in the ecosystem.
From a fun perspective, think of this layer as the "DNA" of Ocean Protocol. Just as DNA carries the essential information for life, this layer carries the essential information for the entire data ecosystem. It's like a digital vault where the "treasures" (data assets) are securely stored and their ownership is irrefutably recorded.

![Ocean C1 L6 Gif 1 (1).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%206%20Deep%20dive%20into%20Ocean%E2%80%99s%20Architecture/Ocean_C1_L6_Gif_1_(1).webp?raw=true)

### Key Components

1. Smart Contracts: Self-executing contracts with predefined rules encoded directly into the blockchain.
2. Data NFTs: Non-fungible tokens representing unique ownership or rights to specific datasets.
3. Datatokens: Fungible tokens granting access to datasets, following the ERC20 standard.
4. Metadata: Descriptive information about datasets, stored on-chain in an encrypted format.

Technically, this layer utilizes smart contracts on Ethereum and other compatible blockchains. These smart contracts automate and enforce the rules of data ownership, access, and transactions without the need for intermediaries.

## Layer 2: The Middle Layer

The Middle Layer acts as the bridge between the blockchain foundation and the user-facing applications. It's the "nervous system" of Ocean Protocol, processing requests, managing data access, and orchestrating complex operations.
Imagine this layer as a busy port in a coastal city. Just as a port manages the flow of goods between ships and the mainland, this layer manages the flow of data and computations between the blockchain and the users.

![Ocean C1 L6 gif 2 (1).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%206%20Deep%20dive%20into%20Ocean%E2%80%99s%20Architecture/Ocean_C1_L6_gif_2_(1).webp?raw=true)

### Key Components

1. **Libraries (Ocean.js and Ocean.py):**
These are the Swiss Army knives for developers in the Ocean ecosystem. They provide a rich set of tools for interacting with the protocol:
    - Minting of data NFTs and datatokens
    - Support for multiple types of assets (flat files, API calls, on-chain calls, algorithms)
    - Ordering Compute-to-Data (C2D) jobs
    
    Ocean.js, the JavaScript library, and Ocean.py, the Python library, serve as powerful bridges between traditional programming environments and the decentralized world of Ocean Protocol. They simplify complex processes like data tokenization, asset management, and smart contract interactions, making it easier for developers to build decentralized applications and data scientists to leverage blockchain technology.
    
2. **Ocean Nodes:**
These are the multitasking marvels of the middle layer, replacing and enhancing the roles of previous components like Aquarius, Provider, and the Subgraph. Ocean Nodes are comprehensive middleware services that handle:
    - Metadata caching and management
    - Asset searching and retrieving
    - Multichain support
    - Pricing schema implementation
    - Order and transaction processing
    - and more…
    
    Ocean Nodes use libp2p for network communication, ensuring efficient and secure data handling across the ecosystem. They act as the central nervous system of Ocean Protocol, coordinating various functions and ensuring smooth operations across multiple chains.
    
3. **Compute-to-Data (C2D) Environment:**
This is the crown jewel of Ocean Protocol's privacy-preserving features. The C2D environment enables a paradigm shift in data processing:
    - Instead of moving data to computations, it brings computations to the data
    - Enables secure and private data analysis without exposing raw data
    - Facilitates collaborative research on sensitive datasets
    - Provides a framework for data owners to monetize their data while maintaining control.
    
    C2D represents a groundbreaking approach to data utilization, allowing valuable insights to be extracted from sensitive data without compromising privacy or security.
    

Technically, this layer consists of various off-chain services and libraries that interact with the blockchain, handle data storage and retrieval, and manage computations. It's designed to be scalable and efficient, offloading heavy computations from the blockchain while maintaining security.

## Layer 3: The Application Layer

The Application Layer is the user-facing part of Ocean Protocol. It's where data publishers, consumers, and developers interact with the ecosystem through intuitive interfaces.

Think of this layer as the storefronts in a bustling marketplace. Just as storefronts display goods and facilitate transactions, this layer showcases datasets and enables easy publishing, discovery, and consumption of data.

![Ocean C1 L6 gif 3 (1).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%206%20Deep%20dive%20into%20Ocean%E2%80%99s%20Architecture/Ocean_C1_L6_gif_3_(1).webp?raw=true)

### Key Components

1. Ocean Market: A decentralized marketplace for data exchange.
2. Third-party applications: Other platforms built on top of Ocean Protocol.
3. Data publisher interfaces: Tools for easily listing and managing datasets.
4. Data consumer interfaces: Platforms for discovering, purchasing, and using datasets.

Technically, this layer consists of decentralized applications (dApps) that interact with the lower layers of Ocean Protocol. These dApps provide user-friendly interfaces for complex blockchain operations, making it easy for non-technical users to participate in the data economy.

## Layer 4: The Wallet Layer

The Wallets layer is the personal interface for users to manage their assets and interactions within Ocean Protocol. It's the gateway for individual participation in the data ecosystem.

Imagine this layer as a combination of a digital wallet and a keychain. Just like you use a wallet to store money and a keychain to access different locks, this layer lets users store their tokens and access various parts of the Ocean Protocol ecosystem.

![Ocean C1 L6 gif 4 (1).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%206%20Deep%20dive%20into%20Ocean%E2%80%99s%20Architecture/Ocean_C1_L6_gif_4_(1).webp?raw=true)

### Key Components

1. Web3 Wallets: Digital wallets compatible with Ocean Protocol, capable of holding and managing various types of tokens.
2. Key management systems: Secure storage and handling of cryptographic keys.
3. Transaction signing interfaces: User-friendly ways to approve and sign blockchain transactions.

Technically, this layer consists of Web3 wallet applications that can interact with blockchain networks. These wallets manage cryptographic keys, sign transactions, and hold digital assets like Data NFTs and Datatokens.

## User Flow: Publishing and Accessing a Data Asset

Now, let's walk through a complete example of how these layers interact when a hospital publishes anonymized patient records and a researcher accesses this data. This example will demonstrate how a user interacts with Ocean Protocol, starting from the application layer and moving through the other layers.

### Step 1: Data Publication (Hospital's Perspective)

1. **Interaction with dApp (Layer 3)**
    - The data provider accesses their custom-built data marketplace, a decentralized application in the Accessible Application Layer.
    - They use the user-friendly interface to input information about their anonymized patient records dataset.
2. **Wallet Integration (Layer 4)**
    - The administrator connects their Web3 wallet to the marketplace.
    - This wallet will be used to sign transactions and store tokens related to the dataset.
3. **Asset Tokenization (Layer 2 -> Layer 1)**
    - Behind the scenes, Ocean.js library (Layer 2) is called to initiate the tokenization process.
    - This triggers the creation of a Data NFT and Datatokens on the blockchain (Layer 1).
4. **Metadata and Data Storage (Layer 2)**
    - The Ocean Node (Layer 2) handles the storage of the actual dataset off-chain.
    - It also manages the encryption of the dataset and its metadata.
    - The metadata is cached for quick retrieval during data discovery.
5. **Smart Contract Deployment (Layer 1)**
    - Smart contracts are deployed on the blockchain to manage access rules, pricing, and usage terms for the dataset.
6. **Compute-to-Data Setup (Layer 2)**
    - The Compute-to-Data environment is configured to allow secure computations on the dataset.

### Step 2: Data Discovery and Access (Researcher's Perspective)

1. **Data Discovery (Layer 3)**
    - A medical researcher browses Marketplace built on Ocean Protocol.
    - They discover the hospital's anonymized patient records dataset.
2. **Wallet Connection (Layer 4)**
    - The researcher connects their Web3 wallet to the application.
3. **Data Purchase (Layer 3 -> Layer 1)**
    - The researcher initiates a purchase of Datatokens for the desired dataset.
    - This transaction is recorded on the blockchain (Layer 1).
4. **Access Request (Layer 3 -> Layer 2 -> Layer 1)**
    - The researcher requests access to the dataset or to run a Compute-to-Data job.
    - This request is processed by the Ocean Node (Layer 2).
    - The node checks permissions against the smart contract (Layer 1).
5. **Data Delivery or Computation (Layer 2)**
    - If approved for direct access, the Ocean Node securely streams the data to the researcher.
    - For a Compute-to-Data job, the researcher's algorithm is sent to the dataset's location and executed there.
6. **Result Delivery (Layer 2 -> Layer 3)**
    - The results (either the dataset or the computation results) are delivered back to the researcher through the application interface.

Throughout this process, the four layers of Ocean Protocol work in harmony:

- Layer 3 (Application) provides the user interface for both the hospital and the researcher.
- Layer 4 (Wallets) manages the cryptographic keys and signatures needed for secure transactions.
- Layer 2 (Middle Layer) handles the complex backend processes, data management, and computations.
- Layer 1 (Blockchain) ensures all transactions and ownership rights are securely and transparently recorded.

This example demonstrates how Ocean Protocol's layered architecture enables secure, transparent, and valuable data exchange, balancing the needs of data privacy, security, and fair value exchange in a decentralized ecosystem.

By leveraging Ocean Protocol to build your own custom marketplace, you can create a tailored data exchange platform that meets your specific needs and those of your community. This approach empowers you to foster innovation, drive data-driven insights, and unlock the full potential of your data assets while maintaining control over your ecosystem.

## Wrap-up

In this lesson, we've navigated the four layers of Ocean Protocol's architecture, seeing how they work together to enable secure and transparent data sharing. Through our hospital dataset journey, we've witnessed the practical application of this innovative system. In our next lesson, "Ocean Protocol Ecosystem: Use Cases and Opportunities," we'll explore how this architecture opens up exciting possibilities across various industries, revolutionizing the way we share and monetize data.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C1%20Introduction%20to%20Ocean%20Protocol/2.%20Ecosystem%20and%20Architecture%20of%20Ocean%20Protocol/6.%20Deep%20dive%20into%20Ocean%E2%80%99s%20Architecture.md

Deep dive into Ocean’s Architecture

# Ocean Protocol Ecosystem: Use Cases and Opportunities

Hey there, data enthusiasts! Ready to dive deeper into the Ocean? Not the actual ocean, but the fascinating world of Ocean Protocol! We've already covered the basics, so now it's time to explore the practical applications and exciting opportunities this revolutionary platform offers. In this lesson, we're going to unpack the different types of datatokens and how they work in real-world scenarios, explore how data can be treated as a valuable financial asset (yes, just like stocks or bonds!), and dive into the intersection of Ocean Protocol and Decentralized Finance (DeFi).

But that's not all – we'll also discover the diverse opportunities for builders, data scientists, investors, and community advocates within the Ocean Protocol ecosystem. And to top it off, we'll peek into the future of data sharing and its potential impact on various industries.

So, grab your virtual scuba gear, and let's plunge into the exciting ecosystem of Ocean Protocol! By the end of this lesson, you'll have a clear understanding of the use cases and opportunities in the Ocean ecosystem.

Let's look at some ways Ocean Protocol can be used in different industries. These examples show how data sharing can make a real difference in various fields.

![Ocean Protocol (9).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%207%20Ocean%20Protocol%20Ecosystem%20Use%20Cases%20and%20Opportunities/Ocean_Protocol_(9).webp?raw=true)

**1. Exclusive Research Data Access**

Imagine a marine biology institute has just discovered a new deep-sea creature. They want to share their findings, but also protect their work. With Ocean Protocol, they can tokenize their dataset, which includes the creature's genome sequence and research notes. Now, other researchers can request access to this data. It's a great way for the institute to collaborate while keeping control of their valuable discovery.

**2. Weather Data Subscriptions**

Have you ever wondered where weather apps get their data? A meteorological organization could use Ocean Protocol to offer their global temperature data. They could sell monthly subscriptions, giving access to climate researchers, farmers, and even other weather app developers. This way, high-quality weather data becomes more widely available, potentially improving forecasts for everyone.

**3. Comprehensive Environmental Analysis**

Environmental issues are complex and often require looking at many factors. Imagine if different environmental agencies could easily share their data. With Ocean Protocol, they could bundle data on temperature, rainfall, and air quality from around the world. City planners or environmental scientists could then access this combined data to make better decisions about sustainable development in their areas.

**4. Medical Research Collaboration**

Rare diseases are hard to study because there aren't many cases. But what if hospitals could safely share patient data? Using Ocean Protocol, a group of hospitals could pool their anonymized data on rare diseases. Researchers and pharmaceutical companies could then access this larger dataset, potentially speeding up the discovery of new treatments while keeping patient information secure.

**5. Financial Market Insights**

We know that staying on top of financial markets is tough. Investment firms could use Ocean Protocol to share their market analysis and real-time data. Traders or financial advisors could subscribe to this information, helping them make more informed decisions. It's a way to level the playing field, giving more people access to high-quality financial data.

**6. Smart City Optimization**

Did you know that the cities we live in generate a lot of data - traffic patterns, energy use, waste management, and more. City governments could use Ocean Protocol to securely share this data. Tech companies and city planners could then use it to develop better solutions for urban living. For example, they might create more efficient traffic systems or improve energy use in buildings.

Wow, we've just scratched the surface of what's possible with Ocean Protocol, haven't we? From  medical discoveries to smart cities, the potential is huge. But here's where things get really interesting. What if we told you that all this data isn't just useful – it could actually be valuable in a way you might not expect? Hang onto your hats, because we're about to dive into a concept that might sound a bit out there at first: data as a financial asset. Intrigued? Let's explore this wild idea together!

## Data as a Financial Asset

Now, let's talk about something that might blow your mind a little: data as a financial asset. Sounds strange? Let me explain with a fun example.

Remember when Michael Jackson bought the rights to the Beatles' music catalog? He wasn't buying CDs or vinyl records. He was buying the rights to the music - the intellectual property (IP). And guess what? He made a fortune from it!

Similarly, data can be treated as a valuable asset. Imagine you've developed a fitness app that collects users' daily step counts, heart rates, and calories burned. That's valuable information! Health insurance companies, fitness equipment manufacturers, and even city planners would love to get their hands on this data to develop new products, adjust insurance premiums, or plan public health initiatives. With Ocean Protocol, you can tokenize this fitness data and sell access to it, just like Michael Jackson did with the Beatles' songs.

But it gets even better. Remember Bowie Bonds? (If you don't, no worries - I'll explain!) David Bowie, the iconic musician, once issued bonds based on the future earnings from his music catalog. Investors bought these bonds, essentially lending Bowie money in exchange for a share of his future royalties.

Now, imagine doing the same with your fitness app data. You could potentially use your datatoken as collateral to get a loan to expand your app's features or market it to a wider audience. The lender would see the potential future earnings from your data as a valuable asset. Mind-blowing, isn't it?

This approach turns your users' aggregated, anonymized fitness data into a financial asset, opening up new possibilities for monetization while still maintaining user privacy. It's a win-win situation: you get to fund your app's growth, and businesses get access to valuable insights. Welcome to the new world of data finance!

## Ocean Protocol and Decentralized Finance (DeFi)

Okay, let's dive even deeper. Have you heard about DeFi? It's short for Decentralized Finance, and it's all about doing financial stuff without banks or other middlemen. Ocean Protocol is jumping into this pool (ocean pun intended!) with both feet.

![Ocean C1 L7 Gif 2 (1).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%207%20Ocean%20Protocol%20Ecosystem%20Use%20Cases%20and%20Opportunities/Ocean_C1_L7_Gif_2_(1).webp?raw=true)

Here are some cool things you can do:

1. **Data DEXes and CEXes:**
Imagine a stock exchange, but instead of stocks, people are trading access to datasets. That's what data exchanges are all about. You could trade your fitness app data for someone else's data on nutrition trends or workout effectiveness.
2. **Data stablecoins and lending:**
Remember how we talked about using data as collateral? Well, you could potentially get a loan in a special "data stablecoin" by putting up your valuable fitness datasets as collateral. This could help you fund new features for your app without giving up ownership of your data.
3. **Data insurance:**
What if someone buys access to your fitness data, but it turns out to be inaccurate or incomplete? Data insurance could protect both buyers and sellers in such scenarios, ensuring that everyone's interests are safeguarded.
4. **Data baskets and indexes:**
Just like you can buy a basket of stocks in an index fund, you could invest in a basket of datatokens. Imagine a "Health and Fitness Index" that gives you access to various health-related datasets, including your fitness app data, nutrition databases, and medical research findings.

We know, it might sound a bit complex at first, but it's not too different from how we already handle money and investments in the digital age. Just as we've gotten used to online banking and stock trading apps, dealing with datatokens and data finance could soon become second nature. The exciting part is that you can be at the forefront of this data revolution!

## Opportunities for Different Stakeholders

So, you're excited and want to get involved? Great! Ocean Protocol offers a wide range of opportunities for various skill sets and interests. Let's explore where you might fit in:

![Ocean C1 L7 gif 3 (1).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Ocean%20C1%20/Lesson%207%20Ocean%20Protocol%20Ecosystem%20Use%20Cases%20and%20Opportunities/Ocean_C1_L7_gif_3_(1).webp?raw=true)

1. **For Builders:**
    - Create innovative AI-powered applications using datatokens. For example, develop a "Personal Health Predictor" app that uses aggregated fitness data to provide personalized health insights and recommendations.
    - Develop secure and efficient APIs that leverage datatokens for access control. This could include a nutrition API that provides detailed nutritional information for thousands of foods, accessible only through datatokens.
    - Build your own specialized data marketplace. Imagine creating the "HealthData Hub" - a platform where researchers, pharmaceutical companies, and healthcare providers can securely buy, sell, and exchange valuable health-related datasets.
    - Implement privacy-preserving computation solutions that allow data analysis without exposing raw data, using Ocean's Compute-to-Data feature.
2. **For Data Scientists:**
    - Utilize the [ocean.py](http://ocean.py/) library to seamlessly integrate Ocean Protocol into your data pipelines and machine learning workflows.
    - Participate in Ocean's Predictoor platform, where you can submit crypto price predictions and earn rewards based on accuracy. This is a great way to apply and monetize your predictive modeling skills.
    - Engage in data science challenges focused on real-world problems. For instance, participate in a challenge to predict disease outbreaks using anonymized health data, with substantial prizes for the best models.
    - Develop and sell advanced algorithms or machine learning models as datatokens, allowing others to use your intellectual property securely.
3. **For OCEAN Token Holders:**
    - Engage in Data Farming by providing liquidity to datatoken pools, earning rewards while supporting the data economy.
    - Participate in Predictoor, Ocean's decentralized price feed oracle. As a Predictoor, you can submit price predictions for various crypto assets and earn rewards based on the accuracy of your predictions.
4. **Become an Ocean Ambassador:**
    - Organize local meetups or online webinars to educate others about the potential of Ocean Protocol and the data economy.
    - Create content such as tutorials, case studies, or blog posts that demonstrate real-world applications of Ocean Protocol.
    - Collaborate with universities or research institutions to integrate Ocean Protocol into data science and blockchain curricula.
    - Represent Ocean Protocol at industry conferences and events, fostering partnerships and adoption.

Remember, these categories aren't mutually exclusive. You might start as a data scientist, then move into building your own data marketplace, and eventually become an ambassador for the protocol. The beauty of Ocean Protocol is that it offers a dynamic ecosystem where you can grow and evolve your involvement over time.

Whether you're looking to monetize your skills, contribute to cutting-edge technology, or be part of a movement transforming the data economy, Ocean Protocol provides a platform for your ambitions. So, where do you see yourself making waves in this new data ocean?

## Community: Social Media and Engagement

Stay connected with Ocean Protocol through various channels.

- [Twitter](https://twitter.com/OceanProtocol): Quick updates and insights
- [Telegram](https://t.me/oceanprotocol_community): Lively community discussions
- [Discord](https://discord.gg/TnXjkR5): In-depth conversations and support
- [GitHub](https://github.com/oceanprotocol): Track technical progress and contribute
- [Ocean Blog](https://blog.oceanprotocol.com/): Detailed project updates and articles

Engage with these platforms to stay informed and participate in shaping the future of decentralized data sharing.

## Wrapping Up

In this lesson, we've explored Ocean Protocol's role in transforming data into a valuable asset and its integration with DeFi. We've discovered opportunities for various stakeholders, from builders to investors, including participation in Data Farming and Predictoor. We've also learned how to engage with the Ocean community. 

You now understand how Ocean Protocol is revolutionizing data sharing and monetization, opening new possibilities in the decentralized data economy. You're equipped to be part of this exciting journey!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C1%20Introduction%20to%20Ocean%20Protocol/2.%20Ecosystem%20and%20Architecture%20of%20Ocean%20Protocol/7.%20Ocean%20Protocol%20Ecosystem%20Use%20Cases%20and%20Opportunities.md

Ocean Protocol Ecosystem: Use Cases and Opportunities

# Wrap up

Alright, let's wrap it up and celebrate your incredible journey! It's time to take a moment and reflect on everything you've learned in this course. Let's summarize what you've learned and how it can empower you in the world of Ocean Protocol.

## Origin and Understanding of Ocean Protocol

We studied the origin of Ocean Protocol and why Ocean Protocol was built in the first place.  We understood the problem statement and how it all started, and we learned about its mission, its initial development, and the launch and growth of Ocean Protocol. We also understood Ocean Protocol and its main actors. 

## Ecosystem and Architecture of Ocean Protocol

Here we learned about Ocean Protocol architecture, the different layers it has, opportunities for developers and scientists, and much more. 

## ⚒️ A small yet important request

Here is a great news for you! This is a 100% open-source project like all the other projects on our platform. You can find the tutorial markdown files here. If you find any issues in the course, please feel free to resolve them. We, at Metaschool, love love love contributions by our community and acknowledge the contributors on our [Discord](https://discord.com/invite/vbVMUwXWgc) and GitHub, too.

While you’re contributing:

1. Don’t forget to star ⭐️ our [repository](https://github.com/0xmetaschool/Learning-Projects). We will be very thankful! ❤️
2. We are a completely free platform and we aim to stay the same, so please consider following us on [X](https://bit.ly/stacks-course) and [LinkedIn](https://bit.ly/stacks-course-linkedin) as well. 🫶
3. Subscribe to our [YouTube](https://www.youtube.com/@0xmetaschool) channel for exciting videos. ✨

## 🎊 Congratulations

You have completed the tutorial and are now equipped with in-depth knowledge about Ocean Protocol. We wish you luck!

WAGMI! Peace out! ✌🏻🔮

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C1%20Introduction%20to%20Ocean%20Protocol/3.%20Wrap%20Up/8.%20Wrap%20up.md

Introduction to Ocean Protocol

Gain hands-on experience with Ocean Protocol. Learn to set up your development environment, create data assets, and publish them to the testnet. Understand the underlying architecture and the role of Data NFTs in unlocking data value.

# What are we building today?

Hey there developers!!

Congratulations on completing the first Ocean Protocol course! 🎉 If you haven't had the chance to complete it yet, we highly recommend doing so before diving into this advanced course. It'll provide you with the foundational knowledge you'll need to make the most of what we're about to explore.

Now, are you ready to dive deeper into the ocean of decentralized data? You've dipped your toes in the water with Course 1, and now it's time to plunge into the exciting world of creating and managing data assets on the Ocean Protocol. This course is your scuba gear, helping you explore the depths of what's possible with decentralized data!

## Why Ocean Protocol? Why Now?

Let's talk big waves and bigger opportunities. The global data market is projected to reach a staggering $103 billion by 2027! And Ocean Protocol? It's your surfboard to ride this massive wave, making data as easy to trade and monetize as posting a photo on social media.

But before we grab our virtual surfboards, let's take a quick look at what's in store for this thrilling course.

## Course Overview

Here's what you can expect from this deep dive:

- **Data Assets: The New Digital Gold** - Explore the foundation of Ocean Protocol's ecosystem
- **NFTs with a Twist: Data NFTs Explained** - Uncover how Ocean Protocol represents data ownership
- **Datatokens: Your Key to the Data Vault** - Learn about the access control mechanism for data assets
- **Ocean.js Unveiled**: Get hands-on with the powerful JavaScript library that'll be your Swiss Army knife for interacting with Ocean Protocol.
- **Build Your First Data NFT**: Create a unique digital representation of your data asset.
- **Publish Like a Pro**: Learn the ins and outs of publishing your data asset.

## What Will You Get Out of This Course?

By completing this course, you'll gain:

- A deep understanding of data assets and their value in the digital economy
- Mastery of Data NFTs and how they represent data ownership on the blockchain
- Proficiency in using datatokens for flexible data access control
- Hands-on experience with Ocean.js for interacting with the Ocean Protocol ecosystem
- Practical skills in deploying data assets to a live blockchain testnet

## Proof of Completion

When you complete this course, you'll receive a special NFT, a digital badge of honor that unlocks many more opportunities on our platform. Here's a sneak peek of what your NFT will look like:

![default nft.gif](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20c2%20Building%20On%20Ocean/Lesson%201%20What%20are%20we%20building%20today/oceanc2-nft.webp)

## House Rules

Before we set sail, let's establish some guidelines:

1. Complete all quick assignments thoroughly - they're your stepping stones to mastery!
2. Join our [Discord server](https://discord.gg/Jf4ArqVb) and dive into discussions with fellow Ocean explorers.
3. We're an open-source platform. Following us on [X (formerly Twitter)](https://x.com/0xmetaschool) and [LinkedIn](https://www.linkedin.com/company/0xmetaschool/) would be a great source of support! 🐠
4. Subscribe to our [YouTube](https://www.youtube.com/@0xmetaschool/) channel for exciting video content. 🎥
5. Stay curious, stay positive, and enjoy the journey!

Alright, data divers, it's time to take the plunge! Let's embark on this exciting voyage into the world of Ocean Protocol! 🌊🚀

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C2%20Building%20on%20Ocean%20Protocol/1.%20Getting%20Started/1.%20What%20are%20we%20building%20today.md

What are we building today?

# Understanding Data Assets and Data NFTs

Welcome devs! Are you ready to dive deeper into the world of Ocean Protocol? Let's explore the core concepts that make this ecosystem tick.

In this lesson, we'll explore the core concepts of Ocean Protocol: data assets, Data NFTs, and datatokens. Building on what you learned in Course 1, we'll delve deeper into these topics to give you a comprehensive understanding of how Ocean Protocol manages, tokenizes, and facilitates the exchange of data.

![1.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20c2%20Building%20On%20Ocean/Lesson%202%20Understanding%20Data%20Assets%20and%20Data%20NFTs/1.webp)

## Data Assets: The Foundation of Ocean Protocol

Before we begin, take a moment to think about what "data asset" might mean to you. What kinds of data do you interact with daily that could be considered valuable?

### What are Data Assets?

Data assets are the fundamental units of value in Ocean Protocol. They can be any type of data or data-related service that holds value and can be exchanged.

**Key points about data assets:**

1. Types of data assets:
    - Datasets (e.g., financial data, scientific research data, IoT sensor data)
    - Algorithms or Machine Learning models
    - Data services (e.g., data cleaning, data analysis)
2. Data assets remain under the control of the data owner.
3. Owners can set terms for access and usage of their data assets.

![2.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20c2%20Building%20On%20Ocean/Lesson%202%20Understanding%20Data%20Assets%20and%20Data%20NFTs/2.webp)

### Key Features of Data Assets

1. **Discoverability**: Metadata makes data assets searchable and discoverable in the Ocean ecosystem
2. **Accessibility**: Access to data assets is controlled through tokenization
3. **Verifiability**: The blockchain provides a transparent record of data asset provenance and transactions
4. **Privacy**: Data assets can be utilized while maintaining privacy through advanced features like Compute-to-Data

Now that you understand data assets, can you think of a data asset you own or would like to create? How might it be valuable in the Ocean Protocol ecosystem?

## Data NFTs: Representing Ownership of Data Assets

As we explore Data NFTs, consider how you typically prove ownership of something valuable. How might this concept of ownership translate to the digital world, particularly when it comes to data? In the realm of Ocean Protocol, Data NFTs (Non-Fungible Tokens) serve as the answer to this question, representing a groundbreaking approach to establishing and verifying data ownership.

Data NFTs in Ocean Protocol represent the ownership or exclusive license of a data asset on the blockchain. Think of them as unique digital certificates that prove your ownership of a specific dataset.

![3.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20c2%20Building%20On%20Ocean/Lesson%202%20Understanding%20Data%20Assets%20and%20Data%20NFTs/3.webp)

### Key Features of Data NFTs

1. **Unique Representation**: Each Data NFT is a unique token representing a specific data asset.
2. **Ownership Proof**: They serve as verifiable proof of data asset ownership or licensing rights.
3. **Control Mechanism**: NFT holders can manage access rights, pricing, and other aspects of their data assets.
4. **Transferability**: Ownership of data assets can be transferred by trading the associated NFTs.

### Technical Implementation

- Data NFTs use the ERC721 standard, ensuring compatibility with Ethereum and similar networks.
- The ERC721Factory contract allows data asset owners to create their own ERC721 contract instances.
- Gas fees are optimized using the ERC1167 proxy approach on the ERC721 template.

Reflecting on Data NFTs, how do you think this concept could change the way we think about data ownership and rights?

## Datatokens: Access Keys to Data Assets

As we dive into the concept of datatokens, let's pause for a moment to consider:

How do you typically gain access to digital content or services? Think about streaming platforms, online courses, or software subscriptions. Now, imagine a system where access to these services is managed through tokens. How might this tokenization change the way we interact with digital content?

In Ocean Protocol, this concept becomes a reality through datatokens. While Data NFTs represent ownership of data assets, datatokens serve a different but complementary purpose:

- Datatokens represent licenses to access specific data assets.
- They are ERC20-compliant tokens, functioning as access control mechanisms within the Ocean Protocol ecosystem.
- In essence, datatokens are the keys that unlock access to valuable data resources.

This tokenized approach to data access opens up new possibilities for flexible, granular control over how data is shared and monetized. Let's explore the key features of datatokens to understand how they achieve this.

![4.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20c2%20Building%20On%20Ocean/Lesson%202%20Understanding%20Data%20Assets%20and%20Data%20NFTs/4.webp)

### Key Features of Datatokens

1. **Access Control**: They function as keys that unlock access to data assets.
2. **Fungibility**: Unlike Data NFTs, datatokens are fungible (ERC20) tokens.
3. **Flexible Licensing**: Multiple datatoken types can exist for a single Data NFT, allowing varied access terms.
4. **Tradability**: Datatokens can be bought, sold, or traded on decentralized exchanges.

### Technical Implementation

- Datatokens use the ERC20 standard, ensuring wide compatibility with existing blockchain tools and platforms.
- Typically, owning 1.0 datatokens grants the ability to consume the corresponding dataset.

Now that you understand datatokens, can you envision how they might be used in your industry or field of study?

## The Relationship Between Data Assets, Data NFTs, and Datatokens

Let's tie it all together. How do you think these three components might work in harmony?

To understand how these components work together, consider this analogy:

- The data asset is like a valuable painting
- The Data NFT is like the certificate of authenticity for the painting
- Datatokens are like tickets to view the painting in a gallery

In practice:

1. When you publish a data asset, you create a Data NFT (claiming ownership/base IP)
2. You can then create one or more datatoken contracts associated with this Data NFT
3. Each datatoken contract represents a specific type of license or access right to your data asset.

## Use Cases for Data Assets, Data NFTs, and Datatokens

As we explore use cases, think about how these concepts could be applied in your own work or projects.

![5.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20c2%20Building%20On%20Ocean/Lesson%202%20Understanding%20Data%20Assets%20and%20Data%20NFTs/5.webp)

1. **Data Marketplaces**:
    - Create decentralized data marketplaces where data providers can sell access to their data assets
    - Buyers can purchase datatokens to access specific datasets or services
2. **Scientific Research Collaboration**:
    - Researchers can tokenize their datasets as Data NFTs
    - Grant access to other researchers through datatokens while maintaining ownership and control
3. **IoT Data Monetization**:
    - IoT device owners can tokenize their sensor data
    - Sell real-time or historical data access through datatokens
4. **AI/ML Model Access**:
    - AI developers can tokenize their trained models as data assets
    - Provide licensed access to these models through datatokens
5. **Data-as-a-Service (DaaS)**:
    - Companies can offer data services (e.g., data cleaning, analysis) as tokenized assets
    - Clients purchase datatokens to access these services
6. **Decentralized Data Governance**:
    - Use Data NFTs to represent ownership stakes in shared datasets
    - Implement decentralized decision-making for data management through NFT ownership
7. **Intellectual Property Management**:
    - Represent patents or other IP as Data NFTs
    - License access to IP through datatokens
8. **Privacy-Preserving Data Collaboration**:
    - Use Data NFTs and datatokens to facilitate secure, privacy-preserving data sharing in sensitive industries like healthcare or finance

Understanding the interplay between data assets, Data NFTs, and datatokens is crucial for navigating the Ocean Protocol ecosystem. These components work together to create a secure, flexible, and efficient data economy:

- Data assets are the valuable information or services being shared and utilized
- Data NFTs establish ownership and control over data assets
- Datatokens provide granular access control and enable monetization

Now that we've covered these core concepts, take a moment to reflect. How might Ocean Protocol's approach to data ownership and access change the way we think about and interact with data in the digital age? What possibilities do you see for your own data or in your field of work?

## Wrap up

Congratulations on completing this deep dive into Ocean Protocol's core concepts! We've explored the trio that forms the backbone of the ecosystem: data assets as valuable digital resources, Data NFTs for establishing ownership, and datatokens for flexible access control and monetization. 

These components work in harmony to create a secure, transparent, and efficient data economy, opening up new possibilities for data sharing, collaboration, and monetization. As you move forward, consider how these concepts might apply to your own data or projects. 

The knowledge you've gained here is your stepping stone into the exciting world of building with Ocean Protocol. Get ready to put these concepts into action in our upcoming lessons!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C2%20Building%20on%20Ocean%20Protocol/1.%20Getting%20Started/2.%20Understanding%20Data%20Assets%20and%20Data%20NFTs.md

Understanding Data Assets and Data NFTs

# Ocean.js and Basic setup

Welcome back, ocean explorers! 🌊 Are you ready to take the plunge into the world of Ocean.js? In this lesson, we'll introduce you to this powerful JavaScript library and guide you through the basic setup. Get ready to unlock the potential of decentralized data services!

## What is Ocean.js?

Before we dive in, take a moment to consider: How do you typically interact with data in your projects? How might a decentralized approach change your workflow?

Ocean.js is a JavaScript library that enables you to privately and securely publish, exchange, and consume data. It's your toolkit for navigating the ocean of decentralized data services.

![6.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20c2%20Building%20On%20Ocean/Lesson%203%20Ocean%20js%20and%20Basic%20setup/6.webp)

### Key Capabilities of Ocean.js:

1. **Publish** data services: Create downloadable files or set up compute-to-data services.
2. **Create** ERC721 data NFTs for each service and ERC20 datatokens for access.
3. **Sell** datatokens for a fixed price or auction off data NFTs.
4. **Transfer** data NFTs & datatokens seamlessly.

## Ocean.js Architecture: A Modular Approach

Ocean.js adopts a modular architecture, making it easy to use and integrate into your projects. Let's break down its structure:

1. **Types**: Definitions for TypeScript support
2. **Config**: Configuration settings for Ocean.js
3. **Contracts**: Interfaces for interacting with smart contracts
4. **Services**: Core functionalities of Ocean Protocol
5. **Utils**: Utility functions for common tasks

This modular approach allows you to import only the components you need, keeping your code clean and efficient.

## Setting Up Your Environment

Now that we understand what Ocean.js is, let's get our hands dirty with some setup! We'll be using Node.js and nvm (Node Version Manager) to ensure a smooth development experience.

1. **Node.js & npm:** Node Js is the engine that powers your JavaScript code, even outside of a web browser. This is super important for blockchain development because it allows you to create and execute code that will interact with the Ocean network directly from your computer. npm is your trusty package manager. It's like a shopping cart for code libraries, making it easy to install and manage all the software components your project needs.
    - **Download & Install Node.js:** Head over to [nodejs.org](https://nodejs.org/) and grab the installer for your operating system (macOS, or Linux). The installer will also include npm. Just follow the on-screen instructions. If you're not sure which one to choose, npm is a great starting point.
    - **Verify Success:** Open your terminal (or command prompt) and type the following commands:
        
        ```bash
        node -v
        npm -v
        ```
        
    
    You should see version numbers for both Node.js and your package manager printed out. If you do, congrats! You've successfully installed Node.js and your package manager.
    
2. **Visual Studio Code (VSCode):** This is our code editor of choice. It's a free, powerful tool that makes writing Solidity code (the language for smart contracts) a breeze. It's got a clean interface, tons of customization options, and a huge library of extensions to help you code like a pro.
    - **Download & Install:** Grab it from [code.visualstudio.com](https://code.visualstudio.com/) and follow the simple installation instructions.
3. Now, let's create a new project and install Ocean.js:

```bash
mkdir my-ocean-project
cd my-ocean-project
npm init -y
npm install @oceanprotocol/lib
```

Congratulations! You've just set up your development environment and installed Ocean.js. You're now ready to start building decentralized data solutions!

## Real-World Applications: Ocean.js in Action

To inspire your journey with Ocean.js, let's explore some exciting use cases:

1. [**Decentralized Data Marketplace**](https://github.com/oceanprotocol/market): Create a platform for peer-to-peer online workshops.
2. [**Music NFTs Marketplace**](https://github.com/oceanprotocol/waves): Build a marketplace for on-demand music NFTs.
3. [**Tokengated Content**](https://github.com/oceanprotocol/token-gating-template): Develop a platform for buying and selling AI-generated art.
4. [**E-Books On-Demand**](https://www.figma.com/proto/xReYRMMnhrynRsNqdy63tT/OceanReads?type=design&node-id=28-380&scaling=min-zoom&page-id=28%3A380&starting-point-node-id=135%3A92): Design a peer-to-peer platform for reading e-books.
5. [**Decentralized Ticketing Mobile App**](https://www.figma.com/proto/lu5ODNDwIrJmlM0WqBeBJ3/OceanTickets?page-id=75%3A386&type=design&node-id=336-126&viewport=131%2C706%2C0.19&t=ia9UyDUfZxZQS4k1-1&scaling=scale-down&starting-point-node-id=336%3A126): Create an end-to-end solution for buying, selling, and trading tickets.

These examples showcase the versatility of Ocean.js in creating innovative, decentralized solutions across various industries.

## Wrap Up

Congratulations on taking your first steps into the world of Ocean.js! We've explored what Ocean.js is, its modular architecture, and how to set up your development environment. You're now equipped with the tools to start building decentralized data solutions.

As you move forward, consider the possibilities Ocean.js opens up for your projects. How might you use it to revolutionize data sharing and monetization in your field?

In our next lesson, we'll dive deeper into Ocean.js, learning how to set up your first project. Get ready to make waves in the decentralized data ocean! 🌊🚀

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C2%20Building%20on%20Ocean%20Protocol/2.%20Building%20the%20dApp/3.%20Ocean%20js%20and%20Basic%20setup.md

Ocean.js and Basic setup

# Set up Your First Project

Alright, it's time to get our hands dirty and start building our very first Ocean Protocol project! 

![Course-media.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20c2%20Building%20On%20Ocean/Lesson%204%20Set%20up%20Your%20First%20Project/Course-media.webp)

 In this lesson, we'll shift gears  and get everything ready to deploy our data NFT to the sepolia test network. Don't worry, we'll guide you through every step of the way, making sure it's smooth sailing!

### Prerequisites: Your Web3 Toolkit

Before we dive into the project setup, let's make sure you have a few things ready:

1. **MetaMask Wallet:**
    - If you haven't already, head over to the [MetaMask website](https://metamask.io/) and install the extension for your browser.
    - Follow the on-screen instructions to create a new wallet or import an existing one.
    - Remember to keep your seed phrase safe and secure - it's the key to your wallet!
    - Add the Sepolia Testnet to your MetaMask. You can find instructions on how to add Sepolia to MetaMask on various online resources or within MetaMask itself.
2. **Sepolia Testnet Ether (SEP)**
    - Just like in the real world, you need some currency to interact with the blockchain. On the Sepolia testnet, we use testnet Ether (SEP).
    - Luckily, there are faucets that provide free SEP for testing purposes. Head over to the Sepolia Faucet ([https://sepolia-faucet.pk910.de/](https://sepolia-faucet.pk910.de/)) and request some SEP to be sent to your MetaMask address.
3. **Alchemy Account and RPC Endpoint**
    - We need a way to communicate with the Sepolia network. Services like [Alchemy](https://www.alchemy.com/) provide RPC endpoints for this purpose
    - Sign up for a free Alchemy account, create a new app, and select the Sepolia network.
    - Copy the "HTTPS" endpoint URL from your Alchemy dashboard. We'll need this later.

### Setting the Stage: Project Initialization

With our toolkit ready, let's create the foundation for our Ocean Protocol project. Think of this as building the launchpad for our data NFT rocket!

1. **Create Your Project's Home**
    
    Open your terminal and navigate to where you want to create your project. Then, run these commands:
    
    ```jsx
    mkdir my-first-ocean-project 
    cd my-first-ocean-project
    ```
    
    This creates a cozy new directory named `my-first-ocean-project` and takes you right into it.
    
2. **Initialize with npm**
    
    Now let's tell our computer this is a Node.js project and get it ready to manage all the cool tools (dependencies) we'll be using. Run this:
    
    ```jsx
    npm init -y
    ```
    
    This sets up a `package.json` file, which is like a recipe book for your project, keeping track of all the ingredients (dependencies) it needs.
    

### Gathering the Tools: Installing Dependencies

Just like a chef needs the right ingredients, our project needs the right tools to work its magic. Let's install the necessary dependencies, including the powerful Ocean.js library.

```jsx
npm i @oceanprotocol/lib@latest dotenv crypto-js ethers@5.7.2 @truffle/hdwallet-provider
```

This command installs the core Ocean.js library along with other essential packages. These packages will help us interact with the blockchain, manage environment variables, and handle other important tasks behind the scenes.

### The `.env` File: Your Project's Control Panel

Think of the `.env` file as the control panel for your project. It's where you store important settings and secrets, keeping them organized and easily accessible.

Inside your project directory, create a new file named `.env`. We'll populate it with the following content:

```jsx
OCEAN_NETWORK=sepolia
OCEAN_NETWORK_URL="your-sepolia-rpc-url-from-alchemy" 
PRIVATE_KEY="your-metamask-account-private-key"

AQUARIUS_URL=https://v4.aquarius.oceanprotocol.com/
PROVIDER_URL=https://v4.provider.oceanprotocol.com
```

Remember those values you got from Alchemy and MetaMask? It's time to use them!

- Replace `"your-sepolia-rpc-url-from-alchemy"` with the actual RPC endpoint URL you copied from Alchemy. This is how your project will communicate with the Sepolia network.
- Replace `"your-metamask-account-private-key"` with the private key of the MetaMask account you'll be using. Again, **never share your private key with anyone!**

### The `config.js` File: Bridging the Gap

Now, let's create the `config.js` file. This file acts as the bridge between your project and the Ocean Protocol network. It reads the environment variables from your `.env` file and creates the necessary configuration objects for seamless interaction. Think of it as the translator that helps your project understand and communicate with the blockchain.

In your project directory, create a new file named `config.js` and paste the provided code into it. This code sets up the connection to the blockchain, initializes an Aquarius instance for metadata handling, and prepares your project to interact with Ocean smart contracts.:

```jsx
/**
* This configuration file establishes the connection between your project
* and the Ocean Protocol network. It reads environment variables from the
* '.env' file and creates the necessary configuration objects for interacting
* with Ocean smart contracts.
*/

require("dotenv").config(); // Load environment variables from .env
const {
  Aquarius,               // For interacting with the metadata store
  ConfigHelper,           // Helper to get network-specific configurations
  configHelperNetworks,   // Predefined network configurations
} = require("@oceanprotocol/lib");
const ethers = require("ethers");  // Ethereum library for blockchain interaction
const fs = require("fs");                // For file system operations
const { homedir } =  require("os");       // To get the user's home directory

/**
* Asynchronously retrieves the Ocean Protocol configuration.
*
* This function reads environment variables, sets up a provider for
* blockchain interaction, and initializes an Aquarius instance for metadata.
* It also handles special configurations for local development environments
* using Barge.
*
* @returns {Promise<Object>} An object containing the Ocean configuration.
*/
async function oceanConfig() {
  // Create a provider based on the OCEAN_NETWORK_URL environment variable
  // or fallback to a default network
  const provider = new ethers.providers.JsonRpcProvider(
    process.env.OCEAN_NETWORK_URL || configHelperNetworks[1].nodeUri
  );

  // Create a wallet instance using the private key from the environment
  const publisherAccount = new ethers.Wallet(process.env.PRIVATE_KEY, provider);

  // Get the initial Ocean configuration based on the detected network chain ID
  let oceanConfig = new ConfigHelper().getConfig(
    parseInt(String((await publisherAccount.provider.getNetwork()).chainId))
  );

  // Initialize an Aquarius instance for metadata interaction
  const aquarius = new Aquarius(oceanConfig?.metadataCacheUri);

  // Add the publisher and consumer accounts (same in this case) and Aquarius to the configuration
  oceanConfig = {
    ...oceanConfig,
    publisherAccount: publisherAccount,
    consumerAccount: publisherAccount,
    aquarius: aquarius,
  };

  return oceanConfig;
}

// Export the oceanConfig function for use in other parts of your project
module.exports = {
  oceanConfig,
};
```

Alright! By now, your project directory should look like this:

![project.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20c2%20Building%20On%20Ocean/Lesson%204%20Set%20up%20Your%20First%20Project/project.webp)

### Wrapping Up

Fantastic! You've successfully prepared your project for deployment on the Sepolia testnet. We've created a project structure, installed the necessary tools, configured your environment, and set up the bridge to the Ocean Protocol network.

In the next lesson, we'll dive into creating your data NFT and deploying it to the Sepolia testnet. Get ready to experience the thrill of interacting with a live test network and unleashing the power of your data!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C2%20Building%20on%20Ocean%20Protocol/2.%20Building%20the%20dApp/4.%20Set%20up%20Your%20First%20Project.md

# Creating and Publishing a Data NFT

Alright, it's time to take our Ocean Protocol project to the next level! In this lesson, we're going to create our very first data asset and deploy it directly to the Sepolia testnet.

Think of a data asset as a digital package containing your valuable data. To make it easily accessible and tradable on the Ocean Market, we'll wrap it up in a special kind of token called a **data NFT** (Non-Fungible Token). This NFT will act as a unique representation of your data, holding all the essential information about it.

![Course-media (1).webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20c2%20Building%20On%20Ocean/Lesson%205%20Creating%20and%20Publishing%20a%20Data%20NFT/Course-media_(1).webp)

### Defining Metadata - Your NFT's Digital Identity

Before we create the NFT, let's define its metadata. Metadata is like an ID card for your NFT, providing essential details about the underlying data asset.

- **Name and Symbol**: Give your NFT a descriptive name and a short, recognizable symbol.
- **Token URI**: This is a link to a JSON file that contains more extensive information about your data asset, such as its description, author, license, and even a preview or sample.
- **Attributes**: These are additional key-value pairs that provide specific details about the data asset, such as its format, size, category, or any other relevant characteristics
    
    ![nft.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20c2%20Building%20On%20Ocean/Lesson%205%20Creating%20and%20Publishing%20a%20Data%20NFT/nft.webp)
    

## Creating the Data NFT - Bringing it to Life

Now, let's use Ocean.js to create our data NFT on the local blockchain environment provided by Barge. We'll leverage the `NftFactory` contract to handle the NFT creation process.

1. **Create a Script**
    
    In your project directory, create a new file named `create_data_nft.js`. This is where we'll write the JavaScript code to create our NFT.
    
2. **Craft the Code**
    
    Let's break down the code step-by-step so you understand what's happening:
    
    - **Import necessary modules:**
        
        ```jsx
        const { oceanConfig } = require("./config.js");
        const { ZERO_ADDRESS, NftFactory } = require("@oceanprotocol/lib");
        ```
        
        We're bringing in the `oceanConfig` from our configuration file and the `NftFactory` from the Ocean.js library. These will be our main tools for this task.
        
    - **Define the NFT creation function:**
        
        ```jsx
        const createOceanDataNFT = async () => {
          let config = await oceanConfig();
        
          // Create an instance of the NFT Factory contract
          const nftFactory = new NftFactory(
            config.nftFactoryAddress,
            config.publisherAccount
          );
        ```
        
        This function will do the heavy lifting. We start by fetching our Ocean configuration and then create an instance of the `NftFactory` contract. This instance will allow us to interact with the NFT Factory on the blockchain.
        
    - **Get the publisher's address**
        
        ```jsx
          const publisherAddress = await config.publisherAccount.getAddress();
        ```
        
        We need to know who's creating this NFT. This line gets the address of the account that will be the initial owner of the NFT.
        
    - **Set the NFT's metadata**
        
        ```jsx
          // Define the parameters for the data NFT
          const nftParams = {
            name: "My First Ocean Data NFT", 
            symbol: "MFOD", 
            templateIndex: 1,
            tokenURI: "https://example.com/my-data-nft-metadata.json", 
            transferable: true, 
            owner: publisherAddress, 
          };
        ```
        
        Here's where we define the NFT's identity. We give it a name, a symbol, and point to a `tokenURI` where we'll store more detailed information about the data asset. We also make it transferable so it can be traded on the Ocean Market.
        
    - **Create the NFT and handle the result:**
        
        ```jsx
          // Create the data NFT and get its address
          const dataNftAddress = await nftFactory.createNFT(nftParams);
          console.log(`Created Data NFT at address: ${dataNftAddress}`);
        
          return dataNftAddress;
        };
        
        // Execute the NFT creation process
        createOceanDataNFT()
          .then((nftAddress) => {
            console.log(`DataNft address ${nftAddress}`);
            process.exit();
          })
          .catch((err) => {
            console.error(err);
            process.exit(1);
          });
        ```
        
        Finally, we call the `createNFT` function to actually create the NFT on the blockchain. We then log the address of the newly created NFT and handle any potential errors during the process
        
3. **Put it all together**
    
    Now, let's combine all the code snippets into a complete script:
    
    ```jsx
    /**
     * This script creates a data NFT (non-fungible token) on the Ocean Protocol
     * using the Ocean.js library.
     *
     * Prerequisites:
     * - Ensure that the '.env' file and 'config.js' are correctly set up
     *   with your Ocean Protocol configuration.
     */
    
    const { oceanConfig } = require("./config.js");
    const { ZERO_ADDRESS, NftFactory } = require("@oceanprotocol/lib");
    
    /**
     * Creates a data NFT on the Ocean Protocol.
     *
     * @returns {Promise<string>} The Ethereum address of the newly created data NFT.
     */
    const createOceanDataNFT = async () => {
      let config = await oceanConfig();
    
      // Create an instance of the NFT Factory contract
      const nftFactory = new NftFactory(
        config.nftFactoryAddress,
        config.publisherAccount
      );
    
      const publisherAddress = await config.publisherAccount.getAddress();
    
      // Define the parameters for the data NFT
      const nftParams = {
        name: "My First Ocean Data NFT", 
        symbol: "MFOD", 
        templateIndex: 1,
        tokenURI: "https://example.com/my-data-nft-metadata.json", 
        transferable: true, 
        owner: publisherAddress, 
      };
    
      // Create the data NFT and get its address
      const dataNftAddress = await nftFactory.createNFT(nftParams);
    
      return dataNftAddress;
    };
    
    // Execute the NFT creation process
    createOceanDataNFT()
      .then((nftAddress) => {
        console.log(`DataNft address ${nftAddress}`);
        process.exit();
      })
      .catch((err) => {
        console.error(err);
        process.exit(1);
      });
    ```
    
    **4. Run the Script and Witness the Magic!**
    
    Now, let's see your code in action! Head back to your terminal, make sure you're in your project directory (`my-first-ocean-project`), and run the following command:
    
    ```jsx
    node create_data_nft.js
    ```
    
    Keep an eye on your terminal. If everything goes smoothly, you'll see a message proudly announcing the address of your newly minted data NFT. This unique address is like a digital fingerprint, identifying your NFT on the blockchain. 
    
    ![terminal.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20c2%20Building%20On%20Ocean/Lesson%205%20Creating%20and%20Publishing%20a%20Data%20NFT/terminal.webp)
    
    You can even copy this address and view the transaction details on the Sepolia Etherscan block explorer: [https://sepolia.etherscan.io/](https://sepolia.etherscan.io/)
    
    ![Course-media2-ezgif.com-gif-to-webp-converter.webp](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/Ocean%20c2%20Building%20On%20Ocean/Lesson%205%20Creating%20and%20Publishing%20a%20Data%20NFT/Course-media2-ezgif.com-gif-to-webp-converter.webp)
    

## Wrap-up

Congratulations! You've successfully deployed your first data NFT to a live testnet. You've learned how to create an NFT representing your data asset, and then take it to the next level by deploying it on the Sepolia testnet. This is a major milestone in your journey towards becoming an Ocean Protocol developer.

Remember, the skills and knowledge you've gained in this course are just the beginning. The Ocean Protocol ecosystem is vast and full of possibilities. Keep exploring, building, and experimenting, and you'll be well on your way to unlocking the true potential of decentralized data!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C2%20Building%20on%20Ocean%20Protocol/2.%20Building%20the%20dApp/5.%20Creating%20and%20Publishing%20a%20Data%20NFT.md

Creating and Publishing a Data NFT

# Wrap up

Congratulations, data pioneers! You've navigated through the depths of Ocean Protocol and emerged with a treasure trove of knowledge and skills. Let's take a moment to reflect on your incredible journey and all that you've accomplished.

## 🏗️ Building Your First Data NFT

One of the most exciting parts of this course was creating your very own data NFT! Remember when we:

1. Set up our development environment with Ocean.js
2. Defined the metadata for our NFT, giving it a unique digital identity
3. Used Ocean.js to mint our NFT directly on the Sepolia testnet

These steps laid the foundation for understanding how data assets are represented and managed in the Ocean ecosystem.

## 🚀 Deploying to a Live Testnet

From the start, you dove into the deep end by working with a live testnet environment. You experienced firsthand how to:

1. Configure your project for the Sepolia testnet
2. Use MetaMask to manage your testnet funds
3. Deploy your NFT to a public blockchain, making it visible and accessible on Etherscan

This practical experience prepared you for real-world interactions with the Ocean Protocol network, bridging the gap between local development and live blockchain environments.

## 🌐 Understanding the Ocean Ecosystem

Beyond the technical skills, you've gained a deep understanding of:

1. Data assets and their role in the new data economy
2. The relationship between data NFTs, datatokens, and data assets
3. How Ocean Protocol enables secure, privacy-preserving data sharing and monetization

This knowledge positions you at the forefront of the decentralized data revolution.

## ⚒️ A Call to Contribute

Great news! This course, like all projects on our platform, is 100% open-source. You can find the tutorial markdown files in our [repository](https://github.com/0xmetaschool/Learning-Projects). If you spot any issues or have ideas for improvements, we encourage you to contribute. We at Ocean Protocol love community contributions and acknowledge contributors on our [Discord](https://discord.com/invite/vbVMUwXWgc) and GitHub.

While you're contributing:

1. Don't forget to star ⭐️ our repository. We'd be incredibly grateful! ❤️
2. We're committed to remaining a free educational platform. Please consider following us on [X (formerly Twitter)](https://x.com/0xmetaschool) and [LinkedIn](https://www.linkedin.com/company/0xmetaschool/) to support our mission. 🫶
3. Subscribe to our [YouTube](https://www.notion.so/Lesson-23-Wrap-Up-650d58347f8744b182f515e1f5ac6a7f?pvs=21) channel for exciting videos. ✨

## 🎊 Congratulations!

You've completed Ocean Protocol Course 2 and are now equipped with the in-depth knowledge to start building in the exciting world of decentralized data sharing and monetization. Your skills in creating data NFTs, managing data assets, and interacting with the Ocean Protocol ecosystem are in high demand in this rapidly evolving field.

Remember, the ocean of possibilities is vast, and you've just begun to explore its depths. Keep building, keep learning, and keep pushing the boundaries of what's possible with decentralized data.

WAGMI! Sail on, data explorer! 🌊🚀

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Ocean%20C2%20Building%20on%20Ocean%20Protocol/3.%20Let%E2%80%99s%20Wrap%20It%20Up/6.%20Wrap%20up.md

Warden Protocol

30 days of solidity

Fuel Marathon

Aptos Marathon

Core Marathon

Sui Marathon

Ocean Protocol: Master Tokenized AI & Data

AI Tools

Ocean Protocol: Master Tokenized AI & Data