Merge pull request #1447 from oceanprotocol/node-docs

Ocean Node Docs Update

SUMMARY.md

@@ -25,6 +25,8 @@
   * [Liquidity Pools \[deprecated\]](user-guides/remove-liquidity-pools.md)
 * [💻 Developers](developers/README.md)
   * [Architecture Overview](developers/architecture.md)
+  * [Ocean Nodes](developers/ocean-node/README.md)
+    * [Node Architecture](developers/ocean-node/node-architecture.md)
   * [Contracts](developers/contracts/README.md)
     * [Data NFTs](developers/contracts/data-nfts.md)
     * [Datatokens](developers/contracts/datatokens.md)
@@ -45,14 +47,6 @@
   * [Get API Keys for Blockchain Access](developers/get-api-keys-for-blockchain-access.md)
   * [Barge](developers/barge/README.md)
     * [Local Setup](developers/barge/local-setup-ganache.md)
-  * [Subgraph](developers/subgraph/README.md)
-    * [Get data NFTs](developers/subgraph/list-data-nfts.md)
-    * [Get data NFT information](developers/subgraph/get-data-nft-information.md)
-    * [Get datatokens](developers/subgraph/list-datatokens.md)
-    * [Get datatoken information](developers/subgraph/get-datatoken-information.md)
-    * [Get datatoken buyers](developers/subgraph/get-datatoken-buyers.md)
-    * [Get fixed-rate exchanges](developers/subgraph/list-fixed-rate-exchanges.md)
-    * [Get veOCEAN stats](developers/subgraph/get-veocean-stats.md)
   * [Ocean.js](developers/ocean.js/README.md)
     * [Configuration](developers/ocean.js/configuration.md)
     * [Creating a data NFT](developers/ocean.js/creating-datanft.md)
@@ -74,19 +68,28 @@
     * [Workflow](developers/compute-to-data/compute-workflow.md)
     * [Writing Algorithms](developers/compute-to-data/compute-to-data-algorithms.md)
     * [Compute Options](developers/compute-to-data/compute-options.md)
-  * [Aquarius](developers/aquarius/README.md)
-    * [Asset Requests](developers/aquarius/asset-requests.md)
-    * [Chain Requests](developers/aquarius/chain-requests.md)
-    * [Other Requests](developers/aquarius/other-requests.md)
-  * [Provider](developers/provider/README.md)
-    * [General Endpoints](developers/provider/general-endpoints.md)
-    * [Encryption / Decryption](developers/provider/encryption-decryption.md)
-    * [Compute Endpoints](developers/provider/compute-endpoints.md)
-    * [Authentication Endpoints](developers/provider/authentication-endpoints.md)
   * [Uploader](developers/uploader/README.md)
     * [Uploader.js](developers/uploader/uploader-js.md)
     * [Uploader UI](developers/uploader/uploader-ui.md)
     * [Uploader UI to Market](developers/uploader/uploader-ui-marketplace.md)
+  * [Old Infrastructure](developers/old-infrastructure/README.md)
+    * [Aquarius](developers/old-infrastructure/aquarius/README.md)
+      * [Asset Requests](developers/old-infrastructure/aquarius/asset-requests.md)
+      * [Chain Requests](developers/old-infrastructure/aquarius/chain-requests.md)
+      * [Other Requests](developers/old-infrastructure/aquarius/other-requests.md)
+    * [Provider](developers/old-infrastructure/provider/README.md)
+      * [General Endpoints](developers/old-infrastructure/provider/general-endpoints.md)
+      * [Encryption / Decryption](developers/old-infrastructure/provider/encryption-decryption.md)
+      * [Compute Endpoints](developers/old-infrastructure/provider/compute-endpoints.md)
+      * [Authentication Endpoints](developers/old-infrastructure/provider/authentication-endpoints.md)
+    * [Subgraph](developers/old-infrastructure/subgraph/README.md)
+      * [Get data NFTs](developers/old-infrastructure/subgraph/list-data-nfts.md)
+      * [Get data NFT information](developers/old-infrastructure/subgraph/get-data-nft-information.md)
+      * [Get datatokens](developers/old-infrastructure/subgraph/list-datatokens.md)
+      * [Get datatoken information](developers/old-infrastructure/subgraph/get-datatoken-information.md)
+      * [Get datatoken buyers](developers/old-infrastructure/subgraph/get-datatoken-buyers.md)
+      * [Get fixed-rate exchanges](developers/old-infrastructure/subgraph/list-fixed-rate-exchanges.md)
+      * [Get veOCEAN stats](developers/old-infrastructure/subgraph/get-veocean-stats.md)
   * [Developer FAQ](developers/dev-faq.md)
 * [📊 Data Scientists](data-scientists/README.md)
   * [Ocean.py](data-scientists/ocean.py/README.md)

developers/README.md

@@ -21,7 +21,7 @@ Example live dapps:
 ## How do developers start using Ocean?
 
 * **App level:** [**Use an Ocean Template**](https://oceanprotocol.com/templates).
-* **Library level:** [**Use ocean.js**](ocean.js/) is a library built for the key environment of dApp developers: JavaScript. Import it & use it your frontend or NodeJS.
+* **Library level:** [**Use ocean.js**](ocean.js) is a library built for the key environment of dApp developers: JavaScript. Import it & use it your frontend or NodeJS.
 * **Contract level:** [**Call Ocean contracts**](contracts/) on Eth mainnet [or other chains](../discover/networks/).
 
 ## Developer Docs Quick-links
@@ -31,11 +31,11 @@ Example live dapps:
 * Schemas: [Metadata](metadata.md), [identifiers/DIDs](identifiers.md), [identifier objects/DDOs](ddo-specification.md), [storage](storage.md), [fine-grained permissions](fg-permissions.md)
 * Components:
   * [Barge](barge/) - local chain for testing
-  * [Ocean subgraph](subgraph/) - grabbing event data from the chain
+  * [Ocean subgraph](old-infrastructure/subgraph/) - grabbing event data from the chain
   * [Ocean CLI](ocean-cli/) - command-line interface
   * [Compute-to-data](compute-to-data/) - practical privacy approach
-  * [Aquarius](aquarius/) - metadata cache
-  * [Provider](provider/) - handshaking for access control
+  * [Aquarius](old-infrastructure/aquarius/) - metadata cache
+  * [Provider](old-infrastructure/provider/) - handshaking for access control
 * [FAQ](dev-faq.md)
 
 ***

developers/architecture.md

@@ -6,7 +6,7 @@ description: Ocean Protocol Architecture Adventure!
 
 Embark on an exploration of the innovative realm of Ocean Protocol, where data flows seamlessly and AI achieves new heights. Dive into the intricately layered architecture that converges data and services, fostering a harmonious collaboration. Let us delve deep and uncover the profound design of Ocean Protocol.🐬
 
-<figure><img src="../.gitbook/assets/architecture/architecture_overview.png" alt=""><figcaption><p>Overview of the Ocean Protocol Architecture</p></figcaption></figure>
+<figure><img src="../.gitbook/assets/image.webp" alt=""><figcaption><p>Overview of the Ocean Protocol Architecture</p></figcaption></figure>
 
 ### Layer 1: The Foundational Blockchain Layer
 
@@ -20,18 +20,33 @@ Above the smart contracts, you'll find essential [libraries](architecture.md#lib
 
 #### Libraries
 
-These libraries include [Ocean.js](ocean.js/), a JavaScript library, and [Ocean.py](../data-scientists/ocean.py/), a Python library. They serve as powerful tools for developers, enabling integration and interaction with the protocol.
+These libraries include [Ocean.js](ocean.js), a JavaScript library, and [Ocean.py](../data-scientists/ocean.py), a Python library. They serve as powerful tools for developers, enabling integration and interaction with the protocol.
 
-1. [Ocean.js](ocean.js/): Ocean.js is a JavaScript library that serves as a powerful tool for developers looking to integrate their applications with the Ocean Protocol ecosystem. Designed to facilitate interaction with the protocol, Ocean.js provides a comprehensive set of functionalities, including data tokenization, asset management, and smart contract interaction. Ocean.js simplifies the process of implementing data access controls, building dApps, and exploring data sets within a decentralized environment.
-2. [Ocean.py](../data-scientists/ocean.py/): Ocean.py is a Python library that empowers developers to integrate their applications with the Ocean Protocol ecosystem. With its rich set of functionalities, Ocean.py provides a comprehensive toolkit for interacting with the protocol. Developers and [data scientists](../data-scientists/) can leverage Ocean.py to perform a wide range of tasks, including data tokenization, asset management, and smart contract interactions. This library serves as a bridge between Python and the decentralized world of Ocean Protocol, enabling you to harness the power of decentralized data.
+1. [Ocean.js](ocean.js): Ocean.js is a JavaScript library that serves as a powerful tool for developers looking to integrate their applications with the Ocean Protocol ecosystem. Designed to facilitate interaction with the protocol, Ocean.js provides a comprehensive set of functionalities, including data tokenization, asset management, and smart contract interaction. Ocean.js simplifies the process of implementing data access controls, building dApps, and exploring data sets within a decentralized environment.
+2. [Ocean.py](../data-scientists/ocean.py): Ocean.py is a Python library that empowers developers to integrate their applications with the Ocean Protocol ecosystem. With its rich set of functionalities, Ocean.py provides a comprehensive toolkit for interacting with the protocol. Developers and [data scientists](../data-scientists/) can leverage Ocean.py to perform a wide range of tasks, including data tokenization, asset management, and smart contract interactions. This library serves as a bridge between Python and the decentralized world of Ocean Protocol, enabling you to harness the power of decentralized data.
 
-#### Middleware components
+#### Ocean Nodes
 
-Additionally, in supporting the discovery process, middleware components come into play:
+Ocean Node is a single component which runs all core middleware services within the Ocean stack. It replaces the roles of Aquarius, Provider and the Subgraph. It integrates the Indexer for metadata management and the Provider for secure data access. It ensures efficient and reliable interactions within the Ocean Protocol network.
 
-1. [Aquarius](aquarius/): Aquarius acts as a metadata cache, enhancing search efficiency by caching on-chain data into Elasticsearch. By accelerating metadata retrieval, Aquarius enables faster and more efficient data discovery.
-2. [Provider](provider/): The Provider component plays a crucial role in facilitating various operations within the ecosystem. It assists in asset downloading, handles [DDO](ddo-specification.md) (Decentralized Data Object) encryption, and establishes communication with the operator-service for Compute-to-Data jobs. This ensures secure and streamlined interactions between different participants.
-3. [Subgraph](subgraph/): The Subgraph is an off-chain service that utilizes GraphQL to offer efficient access to information related to datatokens, users, and balances. By leveraging the subgraph, data retrieval becomes faster compared to an on-chain query. This enhances the overall performance and responsiveness of applications that rely on accessing this information.
+Ocean Nodes handles network communication through libp2p, supports secure data handling, and enables flexible compute-to-data operations.&#x20;
+
+The functions of Ocean nodes include:
+
+* It is crucial in handling the asset downloads, it streams the purchased data directly to the buyer.
+* It conducts the permission an access checks during the consume flow.&#x20;
+* The Node handles [DDO](https://docs.oceanprotocol.com/developers/ddo-specification) (Decentralized Data Object) encryption.
+* It establishes communication with the operator-service for initiating Compute-to-Data jobs.
+* It provides a metadata cache, enhancing search efficiency by caching on-chain data into a Typesense database. This enables faster and more efficient data discovery.
+* It supports multiple chains.
+
+#### Old components
+
+Previously Ocean used the following middleware components:
+
+1. [Aquarius](old-infrastructure/aquarius/)
+2. [Provider](old-infrastructure/provider/)
+3. [Subgraph](old-infrastructure/subgraph/)
 
 #### Compute-to-Data
 

developers/barge/README.md

@@ -6,7 +6,7 @@ description: 🧑🏽‍💻 Local Development Environment for Ocean Protocol
 
 The Barge component of Ocean Protocol is a powerful tool designed to simplify the development process by providing Docker Compose files for running the full Ocean Protocol stack locally. It allows developers to set up and configure the various services required by Ocean Protocol for local testing and development purposes.
 
-By using the Barge component, developers can spin up an environment that includes default versions of [Aquarius](../aquarius/README.md), [Provider](../provider/README.md), [Subgraph](../subgraph/README.md), and [Compute-to-Data](../compute-to-data/README.md). Additionally, it deploys all the [smart contracts](../contracts/README.md) from the ocean-contracts repository, ensuring a complete and functional local setup. Barge component also starts additional services like [Ganache](https://trufflesuite.com/ganache/), which is a local blockchain simulator used for smart contract development, and [Elasticsearch](https://www.elastic.co/elasticsearch/), a powerful search and analytics engine required by Aquarius for efficient indexing and querying of data sets. A full list of components and exposed ports is available in the GitHub [repository](https://github.com/oceanprotocol/barge#component-versions-and-exposed-ports).
+By using the Barge component, developers can spin up an environment that includes default versions of [Aquarius](../old-infrastructure/aquarius/), [Provider](../old-infrastructure/provider/), [Subgraph](../old-infrastructure/subgraph/), and [Compute-to-Data](../compute-to-data/). Additionally, it deploys all the [smart contracts](../contracts/) from the ocean-contracts repository, ensuring a complete and functional local setup. Barge component also starts additional services like [Ganache](https://trufflesuite.com/ganache/), which is a local blockchain simulator used for smart contract development, and [Elasticsearch](https://www.elastic.co/elasticsearch/), a powerful search and analytics engine required by Aquarius for efficient indexing and querying of data sets. A full list of components and exposed ports is available in the GitHub [repository](https://github.com/oceanprotocol/barge#component-versions-and-exposed-ports).
 
 <figure><img src="../../.gitbook/assets/components/barge.png" alt=""><figcaption><p>Load Ocean components locally by using Barge</p></figcaption></figure>
 
@@ -17,6 +17,5 @@ By utilizing the Barge component, developers gain the freedom to conduct experim
 {% hint style="warning" %}
 ⚠️ We've got an important heads-up about Barge that we want to share with you. Brace yourself, because **Barge is not for the faint-hearted**! Here's the deal: the barge works great on Linux, but we need to be honest about its limitations on macOS. And, well, it doesn't work at all on Windows. Sorry, Windows users!
 
-To make things easier for everyone, we **strongly** recommend giving a try first on a **testnet**. Everything is configured already so it should be sufficient for your needs as well. Visit the [networks](../../discover/networks/README.md) page to have clarity on the available test networks. ⚠️
-
+To make things easier for everyone, we **strongly** recommend giving a try first on a **testnet**. Everything is configured already so it should be sufficient for your needs as well. Visit the [networks](../../discover/networks/) page to have clarity on the available test networks. ⚠️
 {% endhint %}

developers/community-monetization.md

@@ -32,7 +32,7 @@ Another new opportunity is using your own **ERC20** token in your dApp, where it
 
 Now this is a completely brand new opportunity to start generating [revenue](contracts/revenue.md) — running your own [provider](https://github.com/oceanprotocol/provider). We have been aware for a while now that many of you haven’t taken up the opportunity to run your own provider, and the reason seems obvious — there aren’t strong enough incentives to do so.
 
-For those that aren’t aware, [Ocean Provider](provider/README.md) is the proxy service that’s responsible for encrypting/ decrypting the data and streaming it to the consumer. It also validates if the user is allowed to access a particular data asset or service. It’s a crucial component in Ocean’s architecture.
+For those that aren’t aware, [Ocean Provider](old-infrastructure/provider/) is the proxy service that’s responsible for encrypting/ decrypting the data and streaming it to the consumer. It also validates if the user is allowed to access a particular data asset or service. It’s a crucial component in Ocean’s architecture.
 
 Now, as mentioned above, fees are now paid to the individual or organization running the provider whenever a user downloads a data asset. The fees for downloading an asset are set as a cost per MB. In addition, there is also a provider fee that is paid whenever a compute job is run, which is set as a price per minute.
 
@@ -40,8 +40,6 @@ The download and compute fees can both be set to any absolute amount and you can
 
 Additionally, provider fees are not limited to data consumption — they can also be used to charge for compute resources. So, for example, this means a provider can charge a fixed fee of 15 DAI to reserve compute resources for 1 hour. This has a huge upside for both the user and the provider host. From the user’s perspective, this means that they can now reserve a suitable amount of compute resources according to what they require. For the host of the provider, this presents another great opportunity to create an income.
 
-
-**Benefits to the Ocean Community**
-We’re always looking to give back to the Ocean community and collecting fees is an important part of that. As mentioned above, the Ocean Protocol Foundation retains the ability to implement community fees on data consumption. The tokens that we receive will either be burned or invested in the community via projects that they are building. These investments will take place either through [Data Farming](../data-farming/README.md), [Ocean Shipyard](https://oceanprotocol.com/shipyard), or Ocean Ventures.
+**Benefits to the Ocean Community** We’re always looking to give back to the Ocean community and collecting fees is an important part of that. As mentioned above, the Ocean Protocol Foundation retains the ability to implement community fees on data consumption. The tokens that we receive will either be burned or invested in the community via projects that they are building. These investments will take place either through [Data Farming](../data-farming/), [Ocean Shipyard](https://oceanprotocol.com/shipyard), or Ocean Ventures.
 
 Projects that utilize OCEAN or H2O are subject to a 0.1% fee. In the case of projects that opt to use different tokens, an additional 0.1% fee will be applied. We want to support marketplaces that use other tokens but we also recognize that they don’t bring the same wider benefit to the Ocean community, so we feel this small additional fee is proportionate.

developers/compute-to-data/README.md

@@ -1,5 +1,5 @@
 ---
-description: Monetise your data while preserving privacy
+description: Compute to data version 2 (C2dv2)
 ---
 
 # Compute to data
@@ -29,14 +29,14 @@ We suggest reading these guides to get an understanding of how compute-to-data w
 
 ### User Guides
 
-* [How to write compute to data algorithms](broken-reference)
-* [How to publish a compute-to-data algorithm](broken-reference)
-* [How to publish a dataset for compute to data](broken-reference)
+* [How to write compute to data algorithms](broken-reference/)
+* [How to publish a compute-to-data algorithm](broken-reference/)
+* [How to publish a dataset for compute to data](broken-reference/)
 
 ### Developer Guides
 
 * [How to use compute to data with ocean.js](../ocean.js/cod-asset.md)
-* [How to use compute to data with ocean.py](../../data-scientists/ocean.py/)
+* [How to use compute to data with ocean.py](../../data-scientists/ocean.py)
 
 ### Infrastructure Deployment Guides
 

developers/compute-to-data/compute-to-data-architecture.md

@@ -24,7 +24,7 @@ The interaction between the Consumer and the Provider follows a specific workflo
 Throughout the computation process, the Consumer has the ability to check the status of the job by making a query to the Provider using the `getJobDetails(XXXX)` function, providing the job identifier (`XXXX`) as a reference.
 
 {% hint style="info" %}
-You have the option to initiate a compute job using one or more data assets. You can explore this functionality by utilizing the [ocean.py](../../data-scientists/ocean.py/) and [ocean.js](../ocean.js/) libraries.
+You have the option to initiate a compute job using one or more data assets. You can explore this functionality by utilizing the [ocean.py](../../data-scientists/ocean.py) and [ocean.js](../ocean.js) libraries.
 {% endhint %}
 
 Now, let's delve into the inner workings of the Provider. Initially, it verifies whether the Consumer has sent the appropriate datatokens to gain access to the desired data. Once validated, the Provider interacts with the Operator-Service, a microservice responsible for coordinating the job execution. The Provider submits a request to the Operator-Service, which subsequently forwards the request to the Operator-Engine, the actual compute system in operation.
@@ -46,9 +46,9 @@ Before the flow can begin, these pre-conditions must be met:
 
 ### Access Control using Ocean Provider
 
-Similar to the `access service`, the `compute service` within Ocean Protocol relies on the [Ocean Provider](../provider/), which is a crucial component managed by the asset Publishers. The role of the Ocean Provider is to facilitate interactions with users and handle the fundamental aspects of a Publisher's infrastructure, enabling seamless integration into the Ocean Protocol ecosystem. It serves as the primary interface for direct interaction with the infrastructure where the data is located.
+Similar to the `access service`, the `compute service` within Ocean Protocol relies on the [Ocean Provider](../old-infrastructure/provider/), which is a crucial component managed by the asset Publishers. The role of the Ocean Provider is to facilitate interactions with users and handle the fundamental aspects of a Publisher's infrastructure, enabling seamless integration into the Ocean Protocol ecosystem. It serves as the primary interface for direct interaction with the infrastructure where the data is located.
 
-The [Ocean Provider](../provider/) encompasses the necessary credentials to establish secure and authorized interactions with the underlying infrastructure. Initially, this infrastructure may be hosted in cloud providers, although it also has the flexibility to extend to on-premise environments if required. By encompassing the necessary credentials, the Ocean Provider ensures the smooth and controlled access to the infrastructure, allowing Publishers to effectively leverage the compute service within Ocean Protocol.
+The [Ocean Provider](../old-infrastructure/provider/) encompasses the necessary credentials to establish secure and authorized interactions with the underlying infrastructure. Initially, this infrastructure may be hosted in cloud providers, although it also has the flexibility to extend to on-premise environments if required. By encompassing the necessary credentials, the Ocean Provider ensures the smooth and controlled access to the infrastructure, allowing Publishers to effectively leverage the compute service within Ocean Protocol.
 
 ### Operator Service
 

developers/contracts/README.md

@@ -6,7 +6,7 @@ description: Empowering the Decentralised Data Economy
 
 The suite of smart contracts serve as the backbone of the decentralized data economy. These contracts facilitate secure, transparent, and efficient interactions among data providers, consumers, and ecosystem participants.
 
-The smart contracts have been deployed across multiple [networks](../../discover/networks/README.md) and are readily accessible through the GitHub [repository](https://github.com/oceanprotocol/contracts/tree/main/contracts). They introduced significant enhancements that encompass the following key **features**:
+The smart contracts have been deployed across multiple [networks](../../discover/networks/) and are readily accessible through the GitHub [repository](https://github.com/oceanprotocol/contracts/tree/main/contracts). They introduced significant enhancements that encompass the following key **features**:
 
 ### [**Data NFTs**](data-nfts.md) **for Enhanced Data IP Management**
 
@@ -20,16 +20,15 @@ By utilizing ERC721 tokens, Ocean **grants data creators greater flexibility and
 
 <figure><img src="../../.gitbook/assets/contracts/v4_contracts_overview.png" alt=""><figcaption><p>Ocean Protocol Smart Contracts</p></figcaption></figure>
 
-
 ### [**Community monetization**](../community-monetization.md), to help the community create sustainable businesses.
 
 Ocean brings forth enhanced opportunities for dApp owners, creating a conducive environment for the emergence of a thriving market of **third-party Providers**.
 
 With Ocean, dApp owners can unlock additional benefits. Firstly, the smart contracts empower dApp owners to collect [fees](fees.md) not only during **data consumption** but also through **fixed-rate exchanges**. This expanded revenue model allows owners to derive more value from the ecosystem. Moreover, in Ocean, the dApp operator has the authority to determine the fee value, providing them with **increased control** over their pricing strategies.
 
-In addition to empowering dApp owners, Ocean facilitates the participation of third-party [Providers](../provider/README.md) who can offer compute services in exchange for a fee. This paves the way for the development of a diverse marketplace of Providers. This model supports both centralized trusted providers, where data publishers and consumers have established trust relationships, as well as trustless providers that leverage decentralization or other privacy-preserving mechanisms.
+In addition to empowering dApp owners, Ocean facilitates the participation of third-party [Providers](../old-infrastructure/provider/) who can offer compute services in exchange for a fee. This paves the way for the development of a diverse marketplace of Providers. This model supports both centralized trusted providers, where data publishers and consumers have established trust relationships, as well as trustless providers that leverage decentralization or other privacy-preserving mechanisms.
 
-By enabling a marketplace of [Providers](../provider/README.md), Ocean fosters competition, innovation, and choice. It creates an ecosystem where various providers can offer their compute services, catering to the diverse needs of data publishers and consumers. Whether based on trust or privacy-preserving mechanisms, this expansion in provider options enhances the overall functionality and accessibility of the Ocean Protocol ecosystem.
+By enabling a marketplace of [Providers](../old-infrastructure/provider/), Ocean fosters competition, innovation, and choice. It creates an ecosystem where various providers can offer their compute services, catering to the diverse needs of data publishers and consumers. Whether based on trust or privacy-preserving mechanisms, this expansion in provider options enhances the overall functionality and accessibility of the Ocean Protocol ecosystem.
 
 Key features of the smart contracts:
 

developers/contracts/fees.md

@@ -18,21 +18,19 @@ When you publish an asset on the Ocean marketplace, there are currently no charg
 However, if you're building a custom marketplace, you have the flexibility to include a publishing fee by adding an extra transaction in the publish flow. Depending on your marketplace's unique use case, you, as the marketplace owner, can decide whether or not to implement this fee. We believe in giving you the freedom to tailor your marketplace to your specific needs and preferences.
 
 | Value in Ocean Market |     Value in Other Markets     |
-| :---------------------: | :------------------------------: |
+| :-------------------: | :----------------------------: |
 |           0%          | Customizable in market config. |
 
-
 ### Swap fee
 
-Swap fees are incurred as a transaction cost whenever someone exchanges one type of token for another within a [fixed rate exchange](./pricing-schemas.md#fixed-pricing). These exchanges can involve swapping a datatoken for a basetoken, like OCEAN or H2O, or vice versa, where basetoken is exchanged for datatoken. The specific value of the swap fee depends on the type of token being used in the exchange.
+Swap fees are incurred as a transaction cost whenever someone exchanges one type of token for another within a [fixed rate exchange](pricing-schemas.md#fixed-pricing). These exchanges can involve swapping a datatoken for a basetoken, like OCEAN or H2O, or vice versa, where basetoken is exchanged for datatoken. The specific value of the swap fee depends on the type of token being used in the exchange.
 
 The swap fee values are set at the smart contract level and can only be modified by the Ocean Protocol Foundation (OPF).
 
 | Value for OCCEAN or H2O | Value for other ERC20 tokens |
-| :-----------------------: | :-----------------------------: |
+| :---------------------: | :--------------------------: |
 |           0.1%          |             0.2%             |
 
-
 ### Consume(aka. Order) fee
 
 When a user exchanges a [datatoken](datatokens.md) for the privilege of downloading an asset or initiating a compute job that utilizes the asset, consume fees come into play. These fees are associated with accessing an asset and include:
@@ -45,7 +43,7 @@ When a user exchanges a [datatoken](datatokens.md) for the privilege of download
 2. **Consume Market** Consumption Fee
    * A market can specify what fee it wants on the order function.
 3. **Provider** Consumption Fees
-   * Defined by the [Provider](../provider/README.md) for any consumption.
+   * Defined by the [Provider](../old-infrastructure/provider/) for any consumption.
    * Expressed in: Address, Token, Amount (absolute), Timeout.
    * You can retrieve them when calling the initialize endpoint.
    * Eg: A provider can charge a fixed fee of 10 USDT per consume, irrespective of the pricing schema used (e.g., fixed rate with ETH, BTC, dispenser).
@@ -93,24 +91,24 @@ Each of these fees plays a role in ensuring fair compensation and supporting the
 
 ### Provider fee
 
-[Providers](../provider/README.md) facilitate data consumption, initiate compute jobs, encrypt and decrypt DDOs, and verify user access to specific data assets or services.
+[Providers](../old-infrastructure/provider/) facilitate data consumption, initiate compute jobs, encrypt and decrypt DDOs, and verify user access to specific data assets or services.
 
 Provider fees serve as [compensation](../community-monetization.md#3.-running-your-own-provider) to the individuals or organizations operating their own provider instances when users request assets.
 
-* Defined by the [Provider](../provider/README.md) for any consumption.
+* Defined by the [Provider](../old-infrastructure/provider/) for any consumption.
 * Expressed in: Address, Token, Amount (absolute), Timeout.
 * You can retrieve them when calling the initialize endpoint.
 * These fees can be set as a **fixed amount** rather than a percentage.
 * Providers have the flexibility to specify the token in which the fees must be paid, which can differ from the token used in the consuming market.
-* Provider fees can be utilized to charge for [computing](../compute-to-data/README.md) resources. Consumers can select the desired payment amount based on the compute resources required to execute an algorithm within the [Compute-to-Data](../compute-to-data/README.md) environment, aligning with their specific needs.
+* Provider fees can be utilized to charge for [computing](../compute-to-data/) resources. Consumers can select the desired payment amount based on the compute resources required to execute an algorithm within the [Compute-to-Data](../compute-to-data/) environment, aligning with their specific needs.
 * Eg: A provider can charge a fixed fee of 10 USDT per consume, irrespective of the pricing schema used (e.g., fixed rate with ETH, BTC, dispenser).
 * Eg: A provider may impose a fixed fee of 15 DAI to reserve compute resources for 1 hour, enabling the initiation of compute jobs.
 
 These fees play a crucial role in incentivizing individuals and organizations to operate provider instances and charge consumers based on their resource usage. By doing so, they contribute to the growth and sustainability of the Ocean Protocol ecosystem.
 
 | Type                                                                         |      OPF Provider      | 3rd party Provider                                                   |
-| ---------------------------------------------------------------------------- | :--------------------: | --------------------------------------------------------------------- |
-| Token to charge the fee: `PROVIDER_FEE_TOKEN`                                |          OCEAN         | <p>Customizable by the Provider Owner. <br>E.g. <code>USDC</code></p> |
+| ---------------------------------------------------------------------------- | :--------------------: | -------------------------------------------------------------------- |
+| Token to charge the fee: `PROVIDER_FEE_TOKEN`                                |          OCEAN         | <p>Customizable by the Provider Owner.<br>E.g. <code>USDC</code></p> |
 | Download: `COST_PER_MB`                                                      |            0           | Customizable in the Provider `envvars`.                              |
 | <p>Compute: <code>COST_PER_MIN</code><br>Environment: 1 CPU, 60 secs max</p> |            0           | Customizable in the OperatorEngine `envvars`.                        |
 | <p>Compute: <code>COST_PER_MIN</code><br>Environment: 1 CPU, 1 hour max</p>  |      1.0 OCEAN/min     | Customizable in the OperatorEngine `envvars`.                        |

developers/metadata.md

@@ -40,11 +40,11 @@ An _asset_ in Ocean represents a downloadable file, compute service, or similar.
 
 An _asset_ has a DID and DDO. The DDO should include metadata about the asset, and define access in at least one [service](ddo-specification.md#services). Only _owners_ or _delegated users_ can modify the DDO.
 
-All DDOs are stored on-chain in encrypted form to be fully GDPR-compatible. A metadata cache like [_Aquarius_](aquarius/README.md) can help in reading, decrypting, and searching through encrypted DDO data from the chain. Because the file URLs are encrypted on top of the full DDO encryption, returning unencrypted DDOs e.g. via an API is safe to do as the file URLs will still stay encrypted.
+All DDOs are stored on-chain in encrypted form to be fully GDPR-compatible. A metadata cache like [_Aquarius_](old-infrastructure/aquarius/) can help in reading, decrypting, and searching through encrypted DDO data from the chain. Because the file URLs are encrypted on top of the full DDO encryption, returning unencrypted DDOs e.g. via an API is safe to do as the file URLs will still stay encrypted.
 
 #### Publishing & Retrieving DDOs
 
-The DDO is stored on-chain as part of the NFT contract and stored in encrypted form using the private key of the [_Provider_](provider/README.md). To resolve it, a metadata cache like [_Aquarius_](aquarius/README.md) must query the [Provider](provider/README.md) to decrypt the DDO.
+The DDO is stored on-chain as part of the NFT contract and stored in encrypted form using the private key of the [_Provider_](old-infrastructure/provider/). To resolve it, a metadata cache like [_Aquarius_](old-infrastructure/aquarius/) must query the [Provider](old-infrastructure/provider/) to decrypt the DDO.
 
 Here is the flow:
 
@@ -56,7 +56,7 @@ To set up the metadata for an asset, you'll need to call the [**setMetaData**](h
 * **\_metaDataDecryptorUrl** - You create the DDO and then the Provider encrypts it with its private key. Only that Provider can decrypt it.
 * **\_metaDataDecryptorAddress** - The decryptor address.
 * **flags** - Additional information to represent the state of the data. One of two values: 0 - plain text, 1 - compressed, 2 - encrypted. Used by Aquarius.
-* **data -** The [DDO](ddo-specification.md) of the asset. You create the DDO as a JSON, send it to the [Provider](provider/README.md) that encrypts it, and then you set it up at the contract level.
+* **data -** The [DDO](ddo-specification.md) of the asset. You create the DDO as a JSON, send it to the [Provider](old-infrastructure/provider/) that encrypts it, and then you set it up at the contract level.
 * **\_metaDataHash** - Hash of the clear data **generated before the encryption.** It is used by Provider to check the validity of the data after decryption.
 * **\_metadataProofs** - Array with signatures of entities who validated data (before the encryption). Pass an empty array if you don't have any.
 

developers/ocean-node/README.md

@@ -0,0 +1,55 @@
+---
+description: The new Ocean stack
+---
+
+# Ocean Nodes
+
+Ocean Nodes are a vital part of the Ocean Protocol core technology stack. The Ocean Nodes monorepo that replaces the three previous components: [Provider](../old-infrastructure/provider/), [Aquarius](../old-infrastructure/aquarius/) and [subgraph](../old-infrastructure/subgraph/). It has been designed to significantly simplify the process of starting the Ocean stack - it runs everything you need with one simple command.
+
+It integrates multiple services for secure and efficient data operations, utilizing technologies like libp2p for peer-to-peer communication. Its modular and scalable architecture supports various use cases, from simple data retrieval to complex compute-to-data (C2D) tasks.
+
+The node is structured into separate layers, including the network layer for communication, and the components layer for core services like the Indexer and Provider. This layered architecture ensures efficient data management and high security.
+
+Flexibility and extensibility are key features of Ocean Node, allowing multiple compute engines, such as Docker and Kubernetes, to be managed within the same framework. The orchestration layer coordinates interactions between the core node and execution environments, ensuring the smooth operation of compute tasks.
+
+For details on how to run a node see the [readme](https://github.com/oceanprotocol/ocean-node/) in the GitHub repository.
+
+#### Ocean Nodes replace the Provider: <a href="#what-does-the-provider-do" id="what-does-the-provider-do"></a>
+
+* The Node is the only component that can access your data
+* It performs checks on-chain for buyer permissions and payments
+* Encrypts the URL and metadata during publish
+* Decrypts the URL when the dataset is downloaded or a compute job is started
+* Provides access to data assets by streaming data (and never the URL)
+* Provides compute services (connects to C2D environment)
+* Typically run by the Data owner
+
+#### Ocean Nodes replace Aquarius: <a href="#what-does-aquarius-do" id="what-does-aquarius-do"></a>
+
+* A new component called Indexer replaces the functionality of Aquarius.
+* The indexer acts as a cache for on-chain data. It stores the metadata from the smart contract events off-chain in a Typesense database.
+* It monitors events: It continually checks for MetadataCreated and MetadataUpdated events, processing these events and updating them in the database.
+* Serves as an API: It provides a REST API that fetches data from the off-chain datastore.
+* Offers easy query access: The API provides a convenient method to access metadata without scanning the blockchain.
+
+**Ocean Nodes replace the Subgraph:**
+
+* Indexing the data from the smart contact events.
+* The data is indexed and updated in real-time.
+* Providing an API which receives and responds to queries.
+* Simplifying the development experience for anyone building on Ocean.
+
+### API
+
+For details on all of the HTTP endpoints exposed by the Ocean Nodes API, refer to the API.md file in the github repository.
+
+{% embed url="https://github.com/oceanprotocol/ocean-node/blob/develop/API.md" %}
+
+### Compute to Data (C2D)
+
+The Ocean nodes provide a convenient and easy way to run a compute-to-data environment. This gives you the opportunity to monetize your node as you can charge fees for using the C2D environment and there are also additional incentives provided Ocean Protocol Foundation (OPF). Soon we will also be releasing C2D V2 which will provide different environments and new ways to pay for computation.
+
+For more details on the C2D V2 architecture, refer to the documentation in the repository:\
+
+
+{% embed url="https://github.com/oceanprotocol/ocean-node/blob/develop/docs/C2DV2.md" %}

developers/ocean-node/node-architecture.md

@@ -0,0 +1,77 @@
+# Node Architecture
+
+Ocean Nodes are the core infrastructure component within the Ocean Protocol ecosystem, designed to facilitate decentralized data exchange and management. It operates by leveraging a multi-layered architecture that includes network, components, and module layers.
+
+Key features include secure peer-to-peer communication via libp2p, flexible and secure encryption solutions, and support for various Compute-to-Data (C2D) operations.
+
+Ocean Node's modular design allows for customization and scalability, enabling seamless integration of its core services—such as the Indexer for metadata management and the Provider for secure data transactions—ensuring robust and efficient decentralized data operations.
+
+### Architecture Overview
+
+The Node stack is divided into the following layers:
+
+* Network layer (libp2p & HTTP API)
+* Components layer (Indexer, Provider)
+* Modules layer
+
+<figure><picture><source srcset="../../.gitbook/assets/OceanNode-arhitecture.drawio.png" media="(prefers-color-scheme: dark)"><img src="../../.gitbook/assets/OceanNode-arhitecture.drawio (light).png" alt=""></picture><figcaption><p>Ocean Nodes Infrastructure diagram</p></figcaption></figure>
+
+### Features
+
+* libp2p supports ECDSA key pairs, and node identity should be defined as a public key.
+* Multiple ways of storing URLs:
+  * Choose one node and use that private key to encrypt URLs (enterprise approach).
+  * Choose several nodes, so your files can be accessed even if one node goes down (given at least one node is still alive).
+* Supports multiple C2D types:
+  * Light Docker only (for edge nodes).
+  * Ocean C2D (Kubernetes).
+* Each component can be enabled/disabled on startup (e.g., start node without Indexer).
+
+### Nodes and Network Model
+
+Nodes can receive user requests in two ways:
+
+* HTTP API
+* libp2p from another node
+
+They are merged into a common object and passed to the appropriate component.
+
+Nodes should be able to forward requests between them if the local database is missing objects. (Example: Alice wants to get DDO id #123 from Node A. Node A checks its local database. If the DDO is found, it is sent back to Alice. If not, Node A can query the network and retrieve the DDO from another node that has it.)
+
+Nodes' libp2p implementation:
+
+* Should support core protocols (ping, identify, kad-dht for peering, circuit relay for connections).
+* For peer discovery, we should support both mDNS & Kademlia DHT.
+* All Ocean Nodes should subscribe to the topic: OceanProtocol. If any interesting messages are received, each node is going to reply.
+
+### Components & Modules
+
+#### Indexer
+
+An off-chain, multi-chain metadata & chain events cache. It continually monitors the chains for well-known events and caches them (V4 equivalence: Aquarius).
+
+Features:
+
+* Monitors MetadataCreated, MetadataUpdated, MetadataState and stores DDOs in the database.
+* Validates DDOs according to multiple SHACL schemas. When hosting a node, you can provide your own SHACL schema or use the ones provided.
+* Provides proof for valid DDOs.
+* Monitors all transactions and events from the data token contracts. This includes minting tokens, creating pricing schema (fixed & free pricing), and orders.
+* Allows queries for all the above.
+
+#### Provider
+
+* Performs checks on-chain for buyer permissions and payments.
+* The provider is crucial in checking that all the relevant fees have been paid before the consumer is able to download the asset. See the [Fees page](../contracts/fees.md) for details on all of the different types of fees.
+* Encrypts the URL and metadata during publishing.
+* Decrypts the URL when the dataset is downloaded or a compute job is started.
+* Encrypts/decrypts files before storage/while accessing.
+* Provides access to data assets by streaming data (and never the URL).
+* Provides compute services.
+* The node operator can charge provider fees, compensating the individuals or organizations operating their own node when users request assets.
+* Currently, we are providing the legacy Ocean C2D compute services (which run in Kubernetes) via the node. In the future, we will soon be releasing C2D V2 which will also allow connections to multiple C2D engines: light, Ocean C2D, and third parties.
+
+For more details on the C2D V2 architecture, refer to the documentation in the repository:
+
+{% embed url="https://github.com/oceanprotocol/ocean-node/blob/develop/docs/C2DV2.md" %}
+
+###

developers/old-infrastructure/README.md

@@ -0,0 +1,7 @@
+# Old Infrastructure
+
+Ocean Protocol is now using Ocean Nodes for all backend infrastructure. Previously we used these three components: 
+
+1. [Aquarius](aquarius/): Aquarius is a metadata cache used to enhance search efficiency by caching on-chain data into Elasticsearch. By accelerating metadata retrieval, Aquarius enables faster and more efficient data discovery.
+2. [Provider](provider/): The Provider component was used to facilitate various operations within the ecosystem. It assists in asset downloading, handles [DDO](../ddo-specification.md) (Decentralized Data Object) encryption, and establishes communication with the operator-service for Compute-to-Data jobs. This ensures secure and streamlined interactions between different participants.
+3. [Subgraph](subgraph/): The Subgraph is an off-chain service that utilizes GraphQL to offer efficient access to information related to datatokens, users, and balances. By leveraging the subgraph, data retrieval becomes faster compared to an on-chain query. This enhances the overall performance and responsiveness of applications that rely on accessing this information.

developers/old-infrastructure/aquarius/README.md

@@ -8,7 +8,7 @@ The core job of Aquarius is to continually look out for new metadata being creat
 
 Aquarius has its own interface (API) that allows you to easily query this metadata. With Aquarius, you don't need to do the time-consuming task of scanning the data chains yourself. It offers you a convenient shortcut to the information you need. It's ideal for when you need a search feature within your dApp.
 
-<figure><img src="../../.gitbook/assets/components/aquarius.png" alt=""><figcaption><p>Aquarius high level overview</p></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/components/aquarius.png" alt=""><figcaption><p>Aquarius high level overview</p></figcaption></figure>
 
 ### What does Aquarius do?
 

developers/old-infrastructure/provider/README.md

@@ -26,7 +26,7 @@ Additionally, the Provider service offers compute services by establishing a con
 * Provides compute services (connects to C2D environment)
 * Typically run by the Data owner
 
-<figure><img src="../../.gitbook/assets/components/provider.png" alt=""><figcaption><p>Ocean Provider - publish &#x26; consume</p></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/components/provider.png" alt=""><figcaption><p>Ocean Provider - publish &#x26; consume</p></figcaption></figure>
 
 In the publishing process, the provider plays a crucial role by encrypting the DDO using its private key. Then, the encrypted DDO is stored on the blockchain.
 
@@ -46,4 +46,4 @@ We recommend checking the README in the Provider [GitHub repository](https://git
 
 The following pages in this section specify the endpoints for Ocean Provider that have been implemented by the core developers.
 
-For inspecting the errors received from `Provider` and their reasons, please revise this [document](https://github.com/oceanprotocol/provider/blob/main/ocean_provider/routes/README.md).
+For inspecting the errors received from `Provider` and their reasons, please revise this [document](https://github.com/oceanprotocol/provider/blob/main/ocean\_provider/routes/README.md).

developers/old-infrastructure/subgraph/README.md

@@ -12,27 +12,27 @@ The [Ocean Subgraph](https://github.com/oceanprotocol/ocean-subgraph) is built o
 
 Imagine this 💭: if you were to always fetch data from the on-chain, you'd start to feel a little...old :older\_woman: Like your queries are stuck in a time warp. But fear not! When you embrace the power of the subgraph, data becomes your elixir of youth.
 
-<figure><img src="../../.gitbook/assets/components/subgraph.png" alt=""><figcaption><p>Ocean Subgraph </p></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/components/subgraph.png" alt=""><figcaption><p>Ocean Subgraph</p></figcaption></figure>
 
 The subgraph reads data from the blockchain, extracting relevant information. Additionally, it indexes events emitted from the Ocean smart contracts. This collected data is then made accessible to any decentralized applications (dApps) that require it, through GraphQL queries. The subgraph organizes and presents the data in a JSON format, facilitating efficient and structured access for dApps.
 
 ### How to use the Subgraph?
 
-You can utilize the Subgraph instances provided by Ocean Protocol or deploy your instance. Deploying your own instance allows you to have more control and customization options for your specific use case. To learn how to host your own Ocean Subgraph instance, refer to the guide available on the [Deploying Ocean Subgraph](../../infrastructure/deploying-ocean-subgraph.md) page.
+You can utilize the Subgraph instances provided by Ocean Protocol or deploy your instance. Deploying your own instance allows you to have more control and customization options for your specific use case. To learn how to host your own Ocean Subgraph instance, refer to the guide available on the [Deploying Ocean Subgraph](../../../infrastructure/deploying-ocean-subgraph.md) page.
 
 If you're eager to use the Ocean Subgraph, here's some important information for you: We've deployed an Ocean Subgraph for each of the supported networks. Take a look at the table below, where you'll find handy links to both the subgraph instance and GraphiQL for each network. With the user-friendly GraphiQL interface, you can execute GraphQL queries directly, without any additional setup. It's a breeze! :ocean:
 
 {% hint style="info" %}
-When it comes to fetching valuable information about [Data NFTs](../contracts/data-nfts.md) and [datatokens](../contracts/datatokens.md), the subgraph queries play a crucial role. They retrieve numerous details and information, but, the Subgraph cannot decrypt the DDO. But worry not, we have a dedicated component for that—[Aquarius](../aquarius/)! 🐬 Aquarius communicates with the provider and decrypts the encrypted information, making it readily available for queries.
+When it comes to fetching valuable information about [Data NFTs](../../contracts/data-nfts.md) and [datatokens](../../contracts/datatokens.md), the subgraph queries play a crucial role. They retrieve numerous details and information, but, the Subgraph cannot decrypt the DDO. But worry not, we have a dedicated component for that—[Aquarius](../aquarius/)! 🐬 Aquarius communicates with the provider and decrypts the encrypted information, making it readily available for queries.
 {% endhint %}
 
 ### Ocean Subgraph deployments
 
 | Network              | Subgraph URL                                               | GraphiQL URL                                                                                                   |
-| ------------------- | ----------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| -------------------- | ---------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
 | Ethereum             | [Subgraph](https://v4.subgraph.mainnet.oceanprotocol.com)  | [GraphiQL](https://v4.subgraph.mainnet.oceanprotocol.com/subgraphs/name/oceanprotocol/ocean-subgraph/graphql)  |
 | Polygon              | [Subgraph](https://v4.subgraph.polygon.oceanprotocol.com/) | [GraphiQL](https://v4.subgraph.polygon.oceanprotocol.com/subgraphs/name/oceanprotocol/ocean-subgraph/graphql)  |
-| OP Mainnet(Optimism)| [Subgraph](https://v4.subgraph.optimism.oceanprotocol.com)  | [GraphiQL](https://v4.subgraph.optimism.oceanprotocol.com/subgraphs/name/oceanprotocol/ocean-subgraph/graphql)  |
+| OP Mainnet(Optimism) | [Subgraph](https://v4.subgraph.optimism.oceanprotocol.com) | [GraphiQL](https://v4.subgraph.optimism.oceanprotocol.com/subgraphs/name/oceanprotocol/ocean-subgraph/graphql) |
 | Sepolia              | [Subgraph](https://v4.subgraph.sepolia.oceanprotocol.com)  | [GraphiQL](https://v4.subgraph.sepolia.oceanprotocol.com/subgraphs/name/oceanprotocol/ocean-subgraph/graphql)  |
 
 {% hint style="warning" %}

developers/old-infrastructure/subgraph/get-veocean-stats.md

@@ -4,7 +4,7 @@ description: 'Discover the World of veOCEAN: Retrieving a Stats'
 
 # Get veOCEAN stats
 
-If you are already familiarized with veOCEAN, you're off to a great start. However, if you need a refresher, we recommend visiting the [veOCEAN](../../data-farming/passivedf.md) page for a quick overview :mag:
+If you are already familiarized with veOCEAN, you're off to a great start. However, if you need a refresher, we recommend visiting the [veOCEAN](../../../data-farming/passivedf.md) page for a quick overview :mag:
 
 On this page, you'll find a few examples to fetch the stats of veOCEANS from the Ocean Subgraph. These examples serve as a valuable starting point to help you retrieve essential information about veOCEAN. However, if you're eager to delve deeper into the topic, we invite you to visit the [GitHub](https://github.com/oceanprotocol/ocean-subgraph/blob/main/test/integration/VeOcean.test.ts) repository. There, you'll discover a wealth of additional examples, which provide comprehensive insights. Feel free to explore and expand your knowledge! :books:
 
@@ -722,4 +722,3 @@ query {
 {% endcode %}
 
 </details>
-

developers/old-infrastructure/subgraph/list-data-nfts.md

@@ -4,7 +4,7 @@ description: 'Discover the World of NFTs: Retrieving a List of Data NFTs'
 
 # Get data NFTs
 
-If you are already familiarized with the concept of NFTs, you're off to a great start. However, if you require a refresher, we recommend visiting the [data NFTs and datatokens page](../contracts/datanft-and-datatoken.md) for a quick overview.
+If you are already familiarized with the concept of NFTs, you're off to a great start. However, if you require a refresher, we recommend visiting the [data NFTs and datatokens page](../../contracts/datanft-and-datatoken.md) for a quick overview.
 
 Now, let us delve into the realm of utilizing the subgraph to extract a list of data NFTs that have been published using the Ocean contracts. By employing GraphQL queries, we can seamlessly retrieve the desired information from the subgraph. You'll see how simple it is :sunglasses:
 
@@ -16,7 +16,7 @@ There are several options available to see this query in action. Below, you will
 2. Execute the query in Python by following the code snippet.
 3. Execute the query in JavaScript by clicking on the "Run" button of the Javascript tab.
 
-_PS: In these examples, the query is executed on the Ocean subgraph deployed on the mainnet. If you want to change the network, please refer to_ [_this table_](README.md#ocean-subgraph-deployments)_._
+_PS: In these examples, the query is executed on the Ocean subgraph deployed on the mainnet. If you want to change the network, please refer to_ [_this table_](./#ocean-subgraph-deployments)_._
 
 {% tabs %}
 {% tab title="Javascript" %}

developers/old-infrastructure/subgraph/list-fixed-rate-exchanges.md

@@ -4,11 +4,9 @@ description: 'Discover the World of NFTs: Retrieving a List of Fixed-rate exchan
 
 # Get fixed-rate exchanges
 
-Having gained knowledge about fetching lists of data NFTs and datatokens and extracting specific information about each, let's now explore the process of retrieving the information of fixed-rate exchanges. A fixed-rate exchange refers to a mechanism where data assets can be traded at a predetermined rate or price. These exchanges offer stability and predictability in data transactions, enabling users to securely and reliably exchange data assets based on fixed rates. If you need a refresher on fixed-rate exchanges, visit the [asset pricing](../contracts/pricing-schemas.md#fixed-pricing) page.
+Having gained knowledge about fetching lists of data NFTs and datatokens and extracting specific information about each, let's now explore the process of retrieving the information of fixed-rate exchanges. A fixed-rate exchange refers to a mechanism where data assets can be traded at a predetermined rate or price. These exchanges offer stability and predictability in data transactions, enabling users to securely and reliably exchange data assets based on fixed rates. If you need a refresher on fixed-rate exchanges, visit the [asset pricing](../../contracts/pricing-schemas.md#fixed-pricing) page.
 
-
-
-_PS: In this example, the query is executed on the Ocean subgraph deployed on the mainnet. If you want to change the network, please refer to_ [_this table_](README.md#ocean-subgraph-deployments)_._
+_PS: In this example, the query is executed on the Ocean subgraph deployed on the mainnet. If you want to change the network, please refer to_ [_this table_](./#ocean-subgraph-deployments)_._
 
 {% tabs %}
 {% tab title="Javascript" %}

developers/storage.md

@@ -154,7 +154,7 @@ Example:
 }
 ```
 
-To get information about the files after encryption, the `/fileinfo` endpoint of the [_Provider_](provider/README.md) returns based on a passed DID an array of file metadata (based on the file type):
+To get information about the files after encryption, the `/fileinfo` endpoint of the [_Provider_](old-infrastructure/provider/) returns based on a passed DID an array of file metadata (based on the file type):
 
 ```json
 [

infrastructure/README.md

@@ -8,7 +8,7 @@ coverY: 0
 
 There are many ways in which the components can be deployed, from simple configurations used for development and testing to complex configurations, used for production systems.
 
-All the Ocean Protocol components ([Provider](../developers/provider/README.md), [Aquarius](../developers/aquarius/README.md), [Subgraph](../developers/subgraph/README.md)) are designed to run in Docker containers, on a Linux operating system. For simple configurations, we rely on Docker Engine and Docker Compose products to deploy and run the components, while for complex configurations we use Kubernetes. The guides included in this section will present both deployment options.
+All the Ocean Protocol components ([Provider](../developers/old-infrastructure/provider/), [Aquarius](../developers/old-infrastructure/aquarius/), [Subgraph](../developers/old-infrastructure/subgraph/)) are designed to run in Docker containers, on a Linux operating system. For simple configurations, we rely on Docker Engine and Docker Compose products to deploy and run the components, while for complex configurations we use Kubernetes. The guides included in this section will present both deployment options.
 
 Please note that deploying the Ocean components requires a good understanding of:
 

user-guides/asset-hosting/README.md

@@ -27,5 +27,5 @@ When you publish your asset as an NFT, then the URL/TX ID/CID required to access
 We recommend implementing a security policy that allows **only the Provider's IP address to access the file** and blocks requests from other unauthorized actors is recommended. Since not all hosting services provide this feature, **you must carefully consider the security features while choosing a hosting service.**
 
 {% hint style="warning" %}
-**Please use a proper hosting solution to keep your files.** Systems like `Google Drive` are not specifically designed for this use case. They include various virus checks and rate limiters that prevent the [`Provider`](../../developers/provider/README.md)downloading the asset once it was purchased.
+**Please use a proper hosting solution to keep your files.** Systems like `Google Drive` are not specifically designed for this use case. They include various virus checks and rate limiters that prevent the [`Provider`](../../developers/old-infrastructure/provider/)downloading the asset once it was purchased.
 {% endhint %}

user-guides/asset-hosting/azure-cloud.md

@@ -18,41 +18,41 @@ Create an account on [Azure](https://azure.microsoft.com/en-us/). Users might al
 
 Go to the Azure portal: https://portal.azure.com/#home and select `Storage accounts` as shown below.
 
-![Select storage accounts](../../.gitbook/assets/hosting/azure1.png)
+![Select storage accounts](<../../.gitbook/assets/hosting/azure1 (1).png>)
 
 **Create a new storage account**
 
-![Create a storage account](../../.gitbook/assets/hosting/azure2.png)
+![Create a storage account](<../../.gitbook/assets/hosting/azure2 (1).png>)
 
 **Fill in the details**
 
-![Add details](../../.gitbook/assets/hosting/azure3.png)
+![Add details](<../../.gitbook/assets/hosting/azure3 (1).png>)
 
 **Storage account created**
 
-![Storage account created](../../.gitbook/assets/hosting/azure4.png)
+![Storage account created](<../../.gitbook/assets/hosting/azure4 (1).png>)
 
 **Step 2 - Create a blob container**
 
-![Create a blob container](../../.gitbook/assets/hosting/azure5.png)
+![Create a blob container](<../../.gitbook/assets/hosting/azure5 (1).png>)
 
 **Step 3 - Upload a file**
 
-![Upload a file](../../.gitbook/assets/hosting/azure6.png)
+![Upload a file](<../../.gitbook/assets/hosting/azure6 (1).png>)
 
 **Step 4 - Share the file**
 
 **Select the file to be published and click Generate SAS**
 
-![Click generate SAS](../../.gitbook/assets/hosting/azure7.png)
+![Click generate SAS](<../../.gitbook/assets/hosting/azure7 (1).png>)
 
 **Configure the SAS details and click `Generate SAS token and URL`**
 
-![Generate link to file](../../.gitbook/assets/hosting/azure8.png)
+![Generate link to file](<../../.gitbook/assets/hosting/azure8 (1).png>)
 
 **Copy the generated link**
 
-![Copy the link](../../.gitbook/assets/hosting/azure9.png)
+![Copy the link](<../../.gitbook/assets/hosting/azure9 (1).png>)
 
 **Step 5 - Publish the asset using the generated link**
 

user-guides/wallets/metamask-setup.md

@@ -2,7 +2,7 @@
 description: How to set up a MetaMask wallet on Chrome
 ---
 
-# Set Up MetaMask Wallet
+# Set Up MetaMask
 
 Before you can publish or purchase assets, you will need a crypto wallet. As Metamask is one of the most popular crypto wallets around, we made a tutorial to show you how to get started with Metamask to use Ocean's tech.
 
@@ -12,27 +12,27 @@ Before you can publish or purchase assets, you will need a crypto wallet. As Met
 
 1. Go to the [Chrome Web Store for extensions](https://chrome.google.com/webstore/category/extensions) and search for MetaMask.
 
-![metamask-chrome-store](../../.gitbook/assets/wallet/metamask-chrome-extension.png)
+![metamask-chrome-store](<../../.gitbook/assets/wallet/metamask-chrome-extension (2).png>)
 
 * Install MetaMask. The wallet provides a friendly user interface that will help you through each step. MetaMask gives you two options: importing an existing wallet or creating a new one. Choose to `Create a Wallet`:
 
-![Create a wallet](../../.gitbook/assets/wallet/create-new-metamask-wallet.png)
+![Create a wallet](<../../.gitbook/assets/wallet/create-new-metamask-wallet (2).png>)
 
 * In the next step create a new password for your wallet. Read through and accept the terms and conditions. After that, MetaMask will generate Secret Backup Phrase for you. Write it down and store it in a safe place.
 
-![Secret Backup Phrase](../../.gitbook/assets/wallet/secret-backup-phrase.png)
+![Secret Backup Phrase](<../../.gitbook/assets/wallet/secret-backup-phrase (2).png>)
 
 * Continue forward. On the next page, MetaMask will ask you to confirm the backup phrase. Select the words in the correct sequence:
 
-![Confirm secret backup phrase](../../.gitbook/assets/wallet/confirm-backup-phrase.png)
+![Confirm secret backup phrase](<../../.gitbook/assets/wallet/confirm-backup-phrase (2).png>)
 
 * Voila! Your account is now created. You can access MetaMask via the browser extension in the top right corner of your browser.
 
-![MetaMask browser extension](../../.gitbook/assets/wallet/metamask-browser-extension.png)
+![MetaMask browser extension](<../../.gitbook/assets/wallet/metamask-browser-extension (2).png>)
 
 * You can now manage ETH and OCEAN with your wallet. You can copy your account address to the clipboard from the options. When you want someone to send ETH or OCEAN to you, you will have to give them that address. It's not a secret.
 
-![Manage tokens](../../.gitbook/assets/wallet/manage-tokens.png)
+![Manage tokens](<../../.gitbook/assets/wallet/manage-tokens (2).png>)
 
 You can also watch this [video tutorial](https://www.youtube.com/playlist?list=PL\_dn0wVs9kWolBCbtHaFxsi408cumOeth) if you want more help setting up MetaMask.
 
@@ -42,7 +42,7 @@ Sometimes it is required to use custom or external networks in MetaMask. We can
 
 Open the Settings menu and find the `Networks` option. When you open it, you'll be able to see all available networks your MetaMask wallet currently use. Click the `Add Network` button.
 
-![Add custom/external network](../../.gitbook/assets/wallet/metamask-add-network.png)
+![Add custom/external network](<../../.gitbook/assets/wallet/metamask-add-network (2).png>)
 
 There are a few empty inputs we need to fill in: