oceanprotocol/docs
1
0
Fork 0
mirror of https://github.com/oceanprotocol/docs.git synced 2024-11-26 19:49:26 +01:00
Code Releases Activity

Merge pull request #434 from oceanprotocol/v3

Browse Source 
V3
This commit is contained in:
Trent McConaghy 2020-10-27 10:30:38 +01:00 committed by GitHub
commit 7edff2b97c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
53 changed files with 395 additions and 1098 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
README.md
View File

@ -23,7 +23,6 @@
- [Linting & Formatting](#linting--formatting)
- [Editor Setup: VS Code](#editor-setup-vs-code)
- [Deployment](#deployment)
- [Authors](#authors)
- [License](#license)
## Content
@ -115,11 +114,6 @@ Requires authorization against AWS with [one of the various ways](https://docs.a
- `AWS_SECRET_ACCESS_KEY`
- `AWS_DEFAULT_REGION`
## Authors
- Troy McConaghy ([@ttmc](https://github.com/ttmc)) - [Ocean Protocol](https://oceanprotocol.com)
- Matthias Kretschmann ([@kremalicious](https://github.com/kremalicious)) - [Ocean Protocol](https://oceanprotocol.com)
## License
```text

33
config.js
View File

@ -1,8 +1,7 @@
module.exports = {
siteTitle: 'Ocean Protocol Documentation',
siteTitle: 'Ocean Developer Documentation',
siteShortTitle: 'Docs',
siteDescription:
'Learn about the components of the Ocean Protocol software stack, and how to run or use the components relevant to you.',
siteDescription: 'Tools to Build Data Markets, and Manage ERC20 Data Assets',
siteUrl: process.env.SITE_URL || 'https://docs.oceanprotocol.com',
siteIcon: 'node_modules/@oceanprotocol/art/logo/favicon-black.png',
siteCompany: 'Ocean Protocol Foundation Ltd.',
@ -25,10 +24,6 @@ module.exports = {
from: '/concepts/',
to: '/concepts/introduction/'
},
{
from: '/setup/',
to: '/setup/quickstart/'
},
{
from: '/tutorials/',
to: '/tutorials/introduction/'
@ -42,20 +37,28 @@ module.exports = {
to: '/concepts/wallets/'
},
{
from: '/concepts/production-network/',
to: '/concepts/pacific-network/'
from: '/references/ocean.js/',
to: 'https://github.com/oceanprotocol/ocean.js'
},
{
from: '/references/squid-py/',
to: 'https://squid-py.readthedocs.io/en/latest/'
from: '/references/react/',
to: 'https://github.com/oceanprotocol/react'
},
{
from: '/references/squid-java/',
to: 'https://www.javadoc.io/doc/com.oceanprotocol/squid/'
from: '/references/ocean.py/',
to: 'https://github.com/oceanprotocol/ocean.py'
},
{
from: '/tutorials/token-bridge/',
to: '/tutorials/'
from: '/references/ocean-contracts/',
to: 'https://github.com/oceanprotocol/ocean-contracts'
},
{
from: '/references/aquarius/',
to: 'https://github.com/oceanprotocol/aquarius'
},
{
from: '/references/provider-py/',
to: 'https://github.com/oceanprotocol/provider-py'
}
]
}

67
content/concepts/architecture.md Normal file
View File

@ -0,0 +1,67 @@
---
title: Architecture Overview
description: Simplicity and Interoperability via a Datatokens Core
---
## Overview
Here is the Ocean architecture.
![Ocean Protocol tools architecture](images/architecture.png)
Here’s an overview of the figure.
- The top layer is **applications** like Ocean Market. With these apps, users can onboard data services into crypto (publish and mint datatokens), hold datatokens as assets (data wallets), discover data assets and buy / sell datatokens for fixed or auto-determined price (data marketplaces), and consume data services (consume datatokens).
- Below that are **libraries** used by the applications: Ocean React hooks, JavaScript library, and Python library. This also includes middleware to assist discovery: Aquarius and (3rd party tool) TheGraph.
- The lowest level has the **smart contracts** used by the libraries. They’re deployed on Ethereum mainnet to start, and other networks later.
Left to right are groupings of functionality: tools for datatokens, tools for markets (including pools), tools to consume data services and for metadata, and external ERC20 tools.
The rest of this page elaborates.
## Datatokens & Access Control Tools
The publisher actor holds the dataset in Google Drive, Dropbox, AWS S3, on their phone, on their home server, etc. The dataset has a URL. The publisher can optionally use IPFS for a content-addressable URL. Or instead of a file, the publisher may run a compute-to-data service.
In the **publish** step, the publisher invokes **Ocean Datatoken Factory** to deploy a new datatoken to the chain. To save gas fees, it uses [ERC1167](https://eips.ethereum.org/EIPS/eip-1167) proxy approach on the **ERC20 datatoken template**. The publisher then mints datatokens.
The publisher runs **Ocean Provider**. In the **consume** step, Provider software needs to retrieve the data service URL given a datatoken address. One approach would be for the publisher to run a database; however this adds another dependency. To avoid this, it stores the URL on-chain. So that others don’t see that URL, it encrypts it.
To initiate the **consume** step, the data consumer sends 1.0 datatokens to the Provider wallet. Then they make a service request to the Provider. The Provider loads the encrypted URL, decrypts it, and provisions the requested service (send static data, or enable a compute-to-data job).
Instead of running a Provider themselves, the publisher can have a 3rd party like Ocean Market run it. While more convenient, it means that the 3rd party has custody of the private encryption/decryption key (more centralized). Ocean will support more service types and url custody options in the future.
**Ocean JavaScript and Python libraries** act as drivers for the lower-level contracts. Each library integrates with Ocean Provider to provision & consume data services, and Ocean Aquarius for metadata. **Ocean React hooks** use the JavaScript library, to help build webapps & React Native apps with Ocean.
## Market Tools
Once someone has generated datatokens, they can be used in any ERC20 exchange, centralized or decentralized. In addition, Ocean provides a convenient default marketplace that is tuned for data: **Ocean Market**. It’s a vendor-neutral reference data marketplace for use by the Ocean community.
The marketplaces are decentralized (no single owner or controller), and non-custodial (only the data owner holds the keys for the datatokens).
Ocean Market supports fixed pricing and automatic price discovery.
- For **fixed pricing**, there’s a simple contract for users to buy/sell datatokens for OCEAN, while avoiding custodianship during value transfer.
- For **automatic price discovery**, Ocean Market uses automated market makers (AMMs) powered by [Balancer](https://www.balancer.finance). Each pool is a datatoken-OCEAN pair. In the Ocean Market GUI, the user adds liquidity then invokes pool creation; the GUI’s React code calls the Ocean JavaScript library, which calls the **Pool Factory** to deploy a **Pool** contract. (The Python library also does this.) Deploying a datatoken pool can be viewed as an “Initial Data Offering” (IDO).
Complementary to Ocean Market, Ocean has reference code to ease building **third-party data marketplaces**, such as for logistics ([dexFreight data marketplace](https://blog.oceanprotocol.com/dexfreight-ocean-protocol-partner-to-enable-transportation-logistics-companies-to-monetize-data-7aa839195ac)) or mobility ([Daimler](https://blog.oceanprotocol.com/ocean-protocol-delivers-proof-of-concept-for-daimler-ag-in-collaboration-with-daimler-south-east-564aa7d959ca)).
[This post](https://blog.oceanprotocol.com/ocean-market-an-open-source-community-marketplace-for-data-4b99bedacdc3) elaborates on Ocean marketplace tools.
## Metadata Tools
Metadata (name of dataset, date created etc.) is used by marketplaces for data asset discovery. Each data asset can have a [decentralized identifier](https://w3c-ccg.github.io/did-spec/) (DID) that resolves to a DID document (DDO) for associated metadata. The DDO is essentially [JSON](https://www.json.org/) filling in metadata fields. [OEP7](https://github.com/oceanprotocol/OEPs/tree/master/7) formalizes Ocean DID usage.
[OEP8](https://github.com/oceanprotocol/OEPs/tree/master/8) specifies Ocean metadata schema, including fields that must be filled. It’s based on the public [DataSet schema from schema.org](https://schema.org/Dataset).
Ocean uses the Ethereum mainnet as an **on-chain metadata store**, i.e. to store both DID and DDO. This means that once the write fee is paid, there are no further expenses or dev-ops work needed to ensure metadata availability into the future, aiding in the discoverability of data assets. It also simplifies integration with the rest of the Ocean system, which is Ethereum-based. Storage cost on Ethereum mainnet is not negligible, but not prohibitive and the other benefits are currently worth the tradeoff compared to alternatives.
Due to the permissionless, decentralized nature of data on Ethereum mainnet, any last-mile tool can access metadata. **Ocean Aquarius** supports different metadata fields for each different Ocean-based marketplace. Developers could also use [TheGraph](https://www.thegraph.com) to see metadata fields that are common across all marketplaces.
## Third-Party ERC20 Apps & Tools
The ERC20 nature of datatokens eases composability with other Ethereum tools and apps, including **MetaMask** and **Trezor** as data wallets, DEXes as data exchanges, and more. [This post](https://blog.oceanprotocol.com/ocean-datatokens-from-money-legos-to-data-legos-4f867cec1837) has details.
## Actor Identities
Actors like data providers and consumers have Ethereum addresses, aka web3 accounts. These are managed by crypto wallets, as one would expect. For most use cases, this is all that’s needed. There are cases where the Ocean community could layer on protocols like [Verifiable Credentials](https://www.w3.org/TR/vc-data-model/) or tools like [3Box](https://3box.io/).

10
content/concepts/bounties.md
View File

@ -1,10 +0,0 @@
---
title: Bounties
description: Help with Ocean Protocol development and have Ocean Tokens rain on you.
---
Check out the:
- [Ocean Protocol Bounties on Gitcoin](https://gitcoin.co/explorer?network=mainnet&idx_status=open&keywords=oceanprotocol&order_by=-web3_created&org=oceanprotocol)
<repo name="ocean-bounties"></repo>

107
content/concepts/components.md
View File

@ -1,107 +0,0 @@
---
title: Software Components
description: Every Ocean network is brought to life by many interacting symbiotic software components.
---
Before reading this page, you should understand some [Ocean-specific terminology](/concepts/terminology/).
## Keeper
A computer running an EVM-compatible blockchain client
(such as [Parity Ethereum](https://www.parity.io/ethereum/))
where the associated blockchain network is running the Ocean Protocol
[keeper-contracts](https://github.com/oceanprotocol/keeper-contracts)
(smart contracts).
<repo name="keeper-contracts"></repo>
See also: [Run a Keeper](/setup/keeper/)
## Secret Store
A [Parity Secret Store](https://wiki.parity.io/Secret-Store): software for distributed key pair generation, distributed key storage, and threshold retrieval. It's used to store [asset](/concepts/terminology/#asset-or-data-asset) access-control keys.
<repo name="parity-ethereum"></repo>
There are several clients for integrating the Parity Secret Store into Ocean:
<repo name="secret-store-client-js"></repo>
<repo name="secret-store-client-py"></repo>
<repo name="secret-store-client-java"></repo>
## Aquarius
Marketplaces run Aquarius to store and manage metadata about the [assets](/concepts/terminology/#asset-or-data-asset) available in their marketplace. It provides an HTTP API for interacting with an off-chain database (sometimes called "OceanDB").
<repo name="aquarius"></repo>
### OceanDB Drivers
Aquarius supports several options for the off-chain database (OceanDB), including Elasticsearch and MongoDB. One can add support for another off-chain database by creating a new driver similar to the existing OceanDB drivers.
<repo name="oceandb-elasticsearch-driver"></repo>
<repo name="oceandb-mongodb-driver"></repo>
> There is also a [BigchainDB driver](https://github.com/oceanprotocol/oceandb-bigchaindb-driver) but it hasn't been maintained.
You can create your own OceanDB drivers by extending on the `oceandb-driver-interface`.
<repo name="oceandb-driver-interface"></repo>
## Brizo
Publishers run Brizo to manage interactions with marketplaces and consumers.
It interacts with the publisher's cloud and/or on-premise infrastructure.
The most basic scenario for a publisher is to provide access to the [assets](/concepts/terminology/#asset-or-data-asset) the publisher owns or manages, but [Brizo can do much more](/concepts/architecture/#brizo).
<repo name="brizo"></repo>
### Events Handler
Brizo communicates with the Events Handler to deal with Keeper Contracts events.
The Events Handler monitors Service Execution Agreement (SEA) events and acts as a provider agent to grant access and release rewards for the publisher/provider. This is a critical part in the process of consuming data sets in the Ocean Protocol network.
Every provider in the network must run some sort of an events handler to be able to fulfill the access condition of an `Access` service in a Service Execution Agreement.
<repo name="events-handler"></repo>
### Osmosis Drivers
Brizo supports several options for file storage, including Azure Storage, Amazon S3 and on-premise storage. One can add support for another file storage option by creating a new driver similar to one of the existing Osmosis drivers.
<repo name="osmosis-azure-driver"></repo>
<repo name="osmosis-aws-driver"></repo>
<repo name="osmosis-ipfs-driver"></repo>
<repo name="osmosis-on-premise-driver"></repo>
You can create your own Osmosis drivers by extending on the `osmosis-driver-interface`.
<repo name="osmosis-driver-interface"></repo>
## Squid Libraries
Client libraries used by applications (such as Pleuston or Jupyter notebooks) to interact with Ocean components, including Keepers, Aquarius nodes, Brizo nodes, etc.
![How Squid is Used](images/ocean-squid-ecosystem.png)
<repo name="squid-js"></repo>
<repo name="squid-py"></repo>
<repo name="squid-java"></repo>
## Commons Marketplace
An online example marketplace/publisher for consumers to explore, download, and publish open data sets in the [Pacific Network](/concepts/pacific-network/). Implemented using [React](https://reactjs.org/) and [squid-js](https://github.com/oceanprotocol/squid-js).
For more information, see [the blog post about Commons Marketplace](https://blog.oceanprotocol.com/the-commons-data-marketplace-c57a44288314).
<repo name="commons"></repo>
The Commons Marketplace is also the default frontend when running a full Ocean network locally with [Barge](/setup/quickstart/).
## Pleuston (deprecated)
An example marketplace/publisher front-end for developers to explore, download, and publish [assets](/concepts/terminology/#asset-or-data-asset) in an Ocean Protocol network. Implemented using [React](https://reactjs.org/) and [squid-js](https://github.com/oceanprotocol/squid-js).
<repo name="pleuston"></repo>

29
content/concepts/compute-to-data.md
View File

@ -1,22 +1,23 @@
---
title: Compute-to-Data
description: How Ocean Protocol enables Publishers to provide computing services and related services.
description: Providing access to data in a privacy-preserving fashion
slug: /concepts/compute-to-data/
section: concepts
---
## Motivation
The most basic scenario for a Publisher is to provide access to the datasets they own or manage.
In addition to that, a Publisher could offer a service to execute some computation on top of their data. This has some benefits:
The most basic scenario for a Publisher is to provide access to the datasets they own or manage. However, a Publisher may offer a service to execute some computation on top of their data. This has some benefits:
- The data **never** leaves the Publisher enclave.
- It's not necessary to move the data; the algorithm is sent to the data.
- Having only one copy of the data and not moving it makes it easier to be compliant with data protection regulations.
[This page](https://oceanprotocol.com/technology/compute-to-data) elaborates on the benefits.
## Architecture
### Enabling Publisher Services (Brizo)
### Enabling Publisher Services, using Ocean Provider
The direct interaction with the infrastructure where the data resides requires the execution of a component handled by Publishers.
@ -24,26 +25,16 @@ This component will be in charge of interacting with users and managing the basi
The business logic supporting these additional Publisher capabilities is the responsibility of this new technical component.
The main and new key component introduced to support these additional Publisher services is named **Brizo**.
The main and new key component introduced to support these additional Publisher services is named **Ocean Provider**.
> Brizo is an ancient Greek goddess who was known as the protector of mariners, sailors, and fishermen. She was worshipped primarily by the women of Delos, who set out food offerings in small boats. Brizo was also known as a prophet specializing in the interpretation of dreams.
In the Ocean ecosystem, Brizo is the technical component executed by the **Publishers**, which provides extended data services. Brizo, as part of the Publisher ecosystem, includes the credentials to interact with the infrastructure (initially in cloud providers, but it could be on-premise).
Because of these credentials, the execution of Brizo **SHOULD NOT** be delegated to a third-party.
<repo name="brizo"></repo>
![Brizo High-Level Architecture](images/brizo-hl-arch.png)
Ocean Provider is the technical component executed by the **Publishers**, which provides extended data services. Ocean Provider includes the credentials to interact with the infrastructure (initially in cloud providers, but it could be on-premise).
### Compute-to-Data Enviroment (Operator-Service)
The Operator Service is a micro-service implementing part of the Ocean Protocol
[Compute to the Data OEP-12](https://github.com/oceanprotocol/OEPs/tree/master/12),
The Operator Service is a micro-service that implements part of the Compute-to-Data spec [OEP-12](https://github.com/oceanprotocol/OEPs/tree/master/12),
in charge of managing the workflow executing requests.
Typically the Operator Service is integrated from the [Brizo proxy](https://github.com/oceanprotocol/brizo),
but can be called independently if it.
Typically the Operator Service is integrated from Ocean Provider, but can be called independently if it.
The Operator Service is in charge of stablishing the communication with the K8s cluster, allowing to:
@ -81,5 +72,5 @@ In the above diagram you can see the initial integration supported. It involves
Before the flow can begin, the following pre-conditions must be met:
- The Asset DDO has a compute service.
- The Asset DDO must specify the Brizo endpoint exposed by the Publisher.
- The Asset DDO must specify the Ocean Provider endpoint exposed by the Publisher.
- The Service Agreement template must already be predefined and whitelisted `on-chain`.

57
content/concepts/contributing.md
View File

@ -1,57 +1,34 @@
---
title: Ways to Contribute
description: There are many ways you could contribute to Ocean Protocol.
description: Help develop Ocean core software, more
---
All contributions to Ocean Protocol are governed by our [Contributor Code of Conduct](/concepts/code-of-conduct/).
Code development follows the [Ocean Engineering Principles](/concepts/principles/).
### Help develop Ocean core software
## Help Develop Core Ocean Software
We'd love to have you help contribute to the Ocean core software! Here are ways to get going:
- Read and understand the [legal requirements when contributing code](/concepts/legal-reqs/).
- Look through the [dev-ocean repository on GitHub](https://github.com/oceanprotocol/dev-ocean). It summarizes Ocean Protocol software development practices and policies.
- Ask technical questions in the [Ocean Protocol chatroom on Discord](https://discord.gg/TnXjkR5).
- Find repository-specific development notes in each repository (usually in the root `README.md` file).
- _Just do it:)_ Branch from the code, improve it, submit a Pull Request.
- Chat with other Ocean developers in [Discord](https://discord.gg/TnXjkR5).
- Because of the weird world of intellectual property, before it can go through, we need to follow the [legal requirements](/concepts/legal-reqs/). Please be aware of this.
- Finally, here's the [Contributor Code of Conduct](/concepts/code-of-conduct/).
## Report a Vulnerability
### Develop an app or integration, using Ocean as a tool
See the page about [reporting vulnerabilities](/concepts/vulnerabilities/).
Integrate Ocean at one of its interface points: React hooks, Javascript library, Python library, smart contracts, etc.
## Report a Bug or Make a Feature Request
Ocean documentation will help. And... you're here:)
To report a bug that isn't a vulnerability, or to make a feature request, go to the relevant GitHub repository, click on the Issues tab, click on the New issue button, and read the instructions.
### Report a bug
## Suggest a Change to the Protocol Itself
To report a vulnerability, [go here](/concepts/vulnerabilities/).
To suggest a change to the Ocean Protocol itself (which is actually a set of protocols), go to the [Ocean Protocol Enhancement Proposals (OEPs)](https://github.com/oceanprotocol/OEPs/) repository and write a proposal, either as an issue or as a pull request.
To report a bug that isn't a vulnerability, go to the relevant GitHub repository, click on the Issues tab, click on the New issue button, and read the instructions.
## Write!
You could write articles or blog posts related to Ocean Protocol. Possible topics include:
- a story about how you used Ocean Protocol or an Ocean network
- news from a recent event
- tutorials for beginners
- a deep dive into some specific aspect of Ocean Protocol
- a blog post about a particular component in the Ocean Protocol stack
For instructions on how to contribute to our main documentation site, check out the docs repo.
### Improve these docs
These docs can always be improved. Here's the repo.
<repo name="docs"></repo>
## Participate in a Bounty
### Other ways to get involved
See the page about [bounties](/concepts/bounties/).
## Become an Ocean Protocol Ambassador
- [Read the announcement of the Ocean Protocol Ambassador Program](https://blog.oceanprotocol.com/envoys-of-the-new-data-economy-ocean-protocol-ambassadors-3816a0e63611)
- [Read about some ambassadors](https://blog.oceanprotocol.com/an-ambassadors-tale-531401d4452f)
- [Apply to become an ambassador](https://oceanprotocol.com/#ambassadors)
## Develop a Service Integration Driver or Plugin
- Aquarius currently supports storing metadata in Elasticsearch or MongoDB. Each option is supported by its own "OceanDB driver." You could write a new OceanDB driver to support another database. See [the existing OceanDB repositories for examples](https://github.com/oceanprotocol?utf8=%E2%9C%93&q=oceandb&type=&language=).
- Brizo currently supports storing data sets in Azure Storage, Amazon S3 or on-premise. Each option is supported by its own "Osmosis driver." You could write a new Osmosis driver to support another storage provider. See [the existing Osmosis repositories for examples](https://github.com/oceanprotocol?utf8=%E2%9C%93&q=osmosis&type=&language=).
- [OEP-11 lists the supported encryption and decryption options](https://github.com/oceanprotocol/OEPs/tree/master/11#encryption-and-decryption) (for encrypting URLs before putting them in the metadata, not data sets themselves). You could add support for another option.
- Other kinds of services could also be integrated. If you need help or advice, then email <a href="mailto:info@oceanprotocol.com">info@oceanprotocol.com</a>.
Please go to the [Ocean Community Page](www.oceanprotocol.com/community) for more ideas on how to get involved.

22
content/concepts/development.md
View File

@ -1,22 +0,0 @@
---
title: Development & Governance
description: Learn about the engineering process behind Ocean Protocol and how you can influence its further development.
---
## Collective Code Construction Contract (C4)
Ocean Protocol uses [C4 Standard process](https://github.com/unprotocols/rfc/blob/master/1/README.md) to manage changes in the source code. Find more details in the respective [OEP-01](https://github.com/oceanprotocol/OEPs/tree/master/1).
<repo name="OEPs"></repo>
## Project management
We use GitHub as a means for maintaining and tracking issues, roadmap and source code development.
- [Ocean Protocol on GitHub](https://github.com/oceanprotocol)
- [Business Board (Ocean Roadmap)](https://github.com/oceanprotocol/ocean/projects/1)
- [Milestones](https://github.com/oceanprotocol/ocean/milestones?direction=asc&sort=due_date&state=open)
We use the _dev-ocean_ repository for internal documentation of most of our engineering processes.
<repo name="dev-ocean"></repo>

8
content/concepts/get-funding.md Normal file
View File

@ -0,0 +1,8 @@
---
title: Funding
description:
---
Funding can be for contributing to the core software, building apps, doing integrations, fixing bugs, community outreach, and more.
**[This page](https://www.oceanprotocol.com/fund)** has more information.

BIN
content/concepts/images/architecture.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 129 KiB

BIN
content/concepts/images/brizo-hl-arch.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 107 KiB

BIN
content/concepts/images/components.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 406 KiB

BIN
content/concepts/images/ocean-squid-ecosystem.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 306 KiB

22
content/concepts/introduction.md
View File

@ -1,24 +1,22 @@
---
title: Introduction
description: Get up to speed with Ocean Protocol.
description: Ocean Protocol - Tools for the Web3 Data Economy
---
## What is Ocean Protocol?
In Ocean Protocol, each data service gets its own ERC20 **datatoken**. This enables data wallets, data exchanges, and data co-ops by directly leveraging crypto wallets, exchanges, and more.
Ocean Protocol is an ecosystem for the data economy and associated services. It provides a tokenized service layer that exposes data, storage, compute and algorithms for consumption with a set of deterministic proofs on availability and integrity that serve as verifiable service agreements. There is staking on services to signal quality, reputation and ward against Sybil Attacks.
OCEAN token is used for staking, and more. [Here](https://oceanprotocol.com/token) are details.
Ocean helps to unlock data, particularly for AI. It is designed for scale and uses blockchain technology that allows data to be shared and sold in a safe, secure and transparent manner.
Ocean Protocol provides tools for developers to _build data markets_, and to _manage datatokens_ for use in DeFi.
While vast amounts of data are generated each year, data exchange and analysis have been hampered due largely to concerns over trust and security. Currently, many organizations have data but do not have the trusted and secure means to share it. Without data, AI cannot advance and be applied to solve problems and ultimately improve lives. More pressing is the fact that today, only a handful of companies have both AI and data capacities, and if data remains locked up, these companies could very well govern the development of AI and thereby our future.
**Build Data Markets.** Use Ocean Protocol software tools to build your own data marketplace, by either forking [Ocean Market](https://market.oceanprotocol.com/) code or building up with Ocean components.
Through blockchain technology and tokens, Ocean Protocol connects data providers and consumers, allowing data to be shared while guaranteeing traceability, transparency, and trust for all stakeholders involved. Ocean Protocol is designed to give data owners control over their data assets and prevent them from being locked in to any single marketplace.
**Manage Datatokens for use in DeFi.** Use Ocean [JavaScript](https://github.com/oceanprotocol/ocean-lib-js) or [Python](https://github.com/oceanprotocol/squid-py) drivers to manage datatokens:
By bringing together decentralized blockchain technology, a data sharing framework, and an ecosystem for data and related services, Ocean Protocol is committed to kick-starting a new Data Economy that touches every single person, company and device, giving power back to data owners, enabling people to reap value from data to better our world.
- _Publish and consume data services:_ downloadable files or compute-to-data. Use Ocean to deploy a new [ERC20](https://github.com/ethereum/EIPs/blob/7f4f0377730f5fc266824084188cc17cf246932e/EIPS/eip-20.md) datatoken contract for each data service, then mint datatokens.
## Mission Statement
- _Transfer datatokens_ to another owner (or approve & transferFrom).
Society is becoming increasingly reliant on data, especially with the advent of AI. However, a small handful of organizations with both massive data assets and AI capabilities attained worrying levels of control which is a danger to a free and open society.
- _Manage pools._ Deploy OCEAN-datatoken [Balancer](https://www.balancer.finance/) pools, buy & sell datatokens (swap), and add & remove liquidity.
Ocean Protocol aims to unlock data, for more equitable outcomes for users of data, using a thoughtful application of both technology and governance.
For more details, see the blog post "[Mission & Values for Ocean Protocol](https://blog.oceanprotocol.com/mission-values-for-ocean-protocol-aba998e95b8)".
- _And more._ Use ERC20 support in [web3.js](https://web3js.readthedocs.io/), [web3.py](https://web3py.readthedocs.io/en/stable/examples.html#working-with-an-erc20-token-contract) and Solidity to connect datatokens with crypto wallets and other DeFi services.

5
content/concepts/legal-reqs.md
View File

@ -9,9 +9,8 @@ All Ocean Protocol code (software) is licensed under an [Apache 2.0 license](htt
If you are:
- contributing code to complete a _currently-open_ [Ocean Protocol bounty](/concepts/bounties/) or
- a _current_ employee of BigchainDB GmbH or
- a _current_ employee of DEX Pte Ltd
- contributing code to complete a _currently-open_ [Ocean Protocol bounty](https://gitcoin.co/explorer?network=mainnet&idx_status=open&keywords=oceanprotocol&order_by=-web3_created&org=oceanprotocol) or
- a _current_ employee of BigchainDB GmbH
then there is nothing extra for you to do: licensing is already handled.

14
content/concepts/network-ethmainnet.md Normal file
View File

@ -0,0 +1,14 @@
---
title: Network - Ethereum Mainnet
description: Tools for development on Ethereum Mainnet
---
Ocean is deployed to Ethereum mainnet. This network is for your app's production deployment. Here are tools related to this deployment.
| What | URL |
| ----------------------- | ---------------------- |
| Etherscan explorer | https://etherscan.io/ |
| Ocean Market main | https://oceanmarket.io |
| Ocean Market - Provider | https://provider.mainnet.oceanprotocol.com |
| Ocean Market - Aquarius | https://aquarius.mainnet.oceanprotocol.com |

12
content/concepts/network-local.md Normal file
View File

@ -0,0 +1,12 @@
---
title: Network - Local / Barge
description: Tools for development on a local Ethereum network
---
You can deploy Ocean onto Ganache - a local Ethereum "network" that you run on your machine for fast iterations while developing your app.
Barge is a shell script to help with Ocean Ganache deployments. It launches Docker and Docker Compose, to run Ganache with Ocean smart contracts on top, along with Provider and Aquarius metadata cache. It's used extensively by the Ocean core devs.
The [Connect-to-Networks](/tutorials/connect-to-networks/) tutorial has more information about connecting your wallet or app to Ganache / Barge.
<repo name="barge"></repo>

13
content/concepts/network-rinkeby.md Normal file
View File

@ -0,0 +1,13 @@
---
title: Network - Rinkeby Testnet
description: Tools for development on Ethereum Rinkeby testnet
---
Ocean is deployed to Rinkeby network. This network is for testing your app's deployment before final production deployment. Here are tools related to this deployment.
| What | URL |
| ----------------------- | ----------------------------- |
| Etherscan explorer | https://rinkeby.etherscan.io/ |
| Ocean Market | Point wallet to Rinkeby network, at usual Ocean Market url https://market.oceanprotocol.com |
| Ocean Market - Provider | https://provider.rinkeby.oceanprotocol.com |
| Ocean Market - Aquarius | https://aquarius.rinkeby.oceanprotocol.com |

100
content/concepts/ocean-tokens.md
View File

@ -1,102 +1,6 @@
---
title: Ocean Tokens
description: The technical basics and most important infos about Ocean Tokens in different networks.
description: Information about OCEAN
---
## Basics
**Ocean Tokens** are the [cryptocurrency](https://en.wikipedia.org/wiki/Cryptocurrency) associated with Ocean Protocol. They are standards-compliant [ERC-20 tokens](https://en.wikipedia.org/wiki/ERC-20).
Ocean Tokens can, in principle, live in any EVM-compatible network. The Ocean Token contract is deployed in the Ethereum Mainnet, Pacific Mainnet, and the Nile Testnet.
Only OCEAN within the Ethereum Mainnet carry any value, reflected [on our token page](https://oceanprotocol.com/token).
| Property | Value |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Token Contract Addresses | _Ethereum Mainnet_<br /> [`0x967da4048cD07aB37855c090aAF366e4ce1b9F48`](https://etherscan.io/token/0x967da4048cD07aB37855c090aAF366e4ce1b9F48)<br /><br />_Pacific Mainnet_<br /> [`0x012578f9381e876A9E2a9111Dfd436FF91A451ae`](https://submarine.oceanprotocol.com/address/0x012578f9381e876a9e2a9111dfd436ff91a451ae/transactions)<br /><br />_Nile Testnet_<br />[`0x9861Da395d7da984D5E8C712c2EDE44b41F777Ad`](https://submarine.nile.dev-ocean.com/address/0x9861Da395d7da984D5E8C712c2EDE44b41F777Ad) |
| Token Symbol | OCEAN |
| Decimals of Precision | 18 |
## Ethereum Mainnet Ocean Tokens
There were several ways to acquire some of the Ethereum Mainnet Ocean Tokens in the initial circulating supply, including:
- participation in the seed round
- participation in the pre-sale
- participation in the token sale
- participation in the initial exchange offering (IEO)
- completion of a [bounty](/concepts/bounties/)
After [the initial exchange offering on Bittrex International](https://blog.oceanprotocol.com/initial-exchange-offering-of-ocean-protocol-on-bittrex-international-a454688f466a), Ethereum Mainnet Ocean Tokens became available in the Ethereum Mainnet (and not in any other network).
The initial circulating supply of Ethereum Mainnet Ocean Tokens became available on the Ethereum Mainnet in May 2019. If you acquired Ocean Tokens in the initial circulating supply, they should have been, or will be, sent to the address you provided, in the Ethereum Mainnet.
At the time of writing, you could use Ethereum Mainnet Ocean Tokens to do various things in the Ethereum Mainnet, including but not limited to:
- buy other cryptocurrencies
- provide liquidity in decentralized exchanges like Uniswap or Balancer
### Check Your Ethereum Mainnet Ocean Token Balance
There are many ways to check your Ethereum Mainnet Ocean Token balance. Starting with the easiest, here are some ways:
#### Ocean Token Tool
Enter your account address into the form on the [Ocean Token page on our website](https://oceanprotocol.com/token#balance).
[![Ocean Token Tool](images/token-tool.png)](https://oceanprotocol.com/token#balance)
#### Blowfish
Download and use [Blowfish](https://github.com/kremalicious/blowfish), a desktop app that tells you your Ocean Token balance (and other things).
[![Blowfish](images/blowfish.png)](https://github.com/kremalicious/blowfish)
#### MetaMask
Use MetaMask or other ERC-20-compatible wallet software. See the page about [using wallet software to manage Ocean Tokens](/tutorials/wallets-and-ocean-tokens/). You can also use wallet software to send Ocean Tokens to some other account.
#### Etherscan
Go to [Etherscan](https://etherscan.io/), enter your account address into the search field, click **Search**, click on **Erc20 Token Txns**, look for an _OceanToken_ transaction in the _Token_ colum, and click on **OceanToken** there.
### Buy or Sell Ethereum Mainnet Ocean Tokens
You can buy or sell Ethereum Mainnet Ocean Tokens (OCEAN) via any exchange that lists them. An always up-to-date _official list_ of exchanges can be found on the [Ocean Token page on our website](https://oceanprotocol.com/token#balance).
## Pacific Network Ocean Tokens
Ocean Tokens in Ocean's Mainnet, [Pacific](/concepts/pacific-network/), represent the same value as in the Ethereum Mainnet. The only way to get Ocean Tokens in Pacific is to transfer them from the Ethereum Mainnet.
## Testnet Ocean Tokens
There are Ocean Tokens in several testnets, including the Nile testnet. They are just testnet Ocean Tokens (i.e. for testing purposes only) and they aren't interchangeable with Ethereum Mainnet Ocean Tokens. For more details, see the the [page about Testnets](/concepts/testnets/) and the [tutorials](/tutorials/introduction/).
Once you have some Testnet Ocean Tokens, you can use them for all currently-implemented Ocean Protocol tasks _in that testnet_ (e.g. buying assets).
### Get Testnet Ocean Tokens
All Squid libraries have methods to request Ocean Tokens. They work by calling the _Dispenser_ keeper contract, a contract which is only deployed to testnets. Therefore they will only work in testnets.
They're documented in the following places:
- The squid-js docs for:
- [`OceanAccounts.requestTokens()`](/references/squid-js/#OceanAccounts-requestTokens)
- [`Account.requestTokens()`](/references/squid-js/#Account-requestTokens)
- The squid-py docs for:
- [the `squid_py.ocean.ocean_tokens` module](https://squid-py.readthedocs.io/en/develop/api/squid_py.ocean.ocean_tokens.html): see the `request()` method.
- [the `squid_py.ocean.ocean_accounts` module](https://squid-py.readthedocs.io/en/develop/api/squid_py.ocean.ocean_accounts.html): see the `request_tokens()` method.
- [The squid-java docs](https://www.javadoc.io/doc/com.oceanprotocol/squid/): click _All Classes_ then _AccountsManager_ then scroll to the bottom of the Class _AccountsManager_ page where you'll find the `requestTokens()` method.
The [Example Code page](/tutorials/example-code/) has links to example Squid code (in all of the languages), including examples of using the above methods.
## Further Reading about Ocean Tokens
- [Ocean Token page](https://oceanprotocol.com/token)
- [Tutorial: Use Your Wallet to Manage Ocean Tokens](/tutorials/wallets-and-ocean-tokens/)
- [Blog: Ocean Tokenomics](https://blog.oceanprotocol.com/ocean-tokenomics-d34f28c480a8)
- [Blog: Ocean Tokenomics II](https://blog.oceanprotocol.com/https-blog-oceanprotocol-com-ocean-tokenomics-ii-faf05854314b)
- [Ocean Protocol Technical Whitepaper](https://oceanprotocol.com/tech-whitepaper.pdf)
- [Blog: What Happened with the IEO?](https://blog.oceanprotocol.com/what-happened-with-the-ieo-54cc5c6c3db9)
- [Blog: Ocean Protocol — Token Sale](https://blog.oceanprotocol.com/ocean-protocol-token-sale-96d03f968e22)
- [Blog: Ocean Protocol Pre-Launch is Target Reached](https://blog.oceanprotocol.com/ocean-protocol-pre-launch-is-target-reached-d10e53272a2e)
Please go to https://oceanprotocol.com/token.

62
content/concepts/pacific-network.md
View File

@ -1,62 +0,0 @@
---
title: The Pacific Network
description: An introduction to Ocean Protocol's main network, named Pacific.
---
## Overview
The _Pacific Network_[^1] is an EVM-compatible [Proof of Authority (POA) network](https://github.com/poanetwork/wiki/wiki/What-is-POA) of nodes ("keepers") running [Parity Ethereum](https://www.parity.io/ethereum/) software. Various Ocean Protocol smart contracts ("keeper contracts") are deployed to it.
Initially, all the nodes in the Pacific Network were operated solely by BigchainDB GmbH (i.e. one company), but the goal was for the nodes to be operated by many independent operators in the future.
We expect vulnerabilities to be discovered and will conduct security audits over time, but the Ocean Protocol smart contracts will be in the wild for all intents and purposes.
Over time, the Pacific Network will be upgraded and improved.
There is no intent to shut it down.
Eventually, the goal is for it to be used in production by many projects.
[^1]: The Pacific Network is (or was) also known by other names, including _Pacific_, _Main Ocean Network_, _Ocean Mainnet_, _Ocean Live Network_.
## Ocean Tokens in Pacific
To be able to use [Ocean Tokens](/concepts/ocean-tokens/) in Pacific, they need to be transferred from the Ethereum Mainnet with a token bridge.
For more information, see [Pacific Network Ocean Tokens](/concepts/ocean-tokens/#pacific-network-ocean-tokens).
## Connect to the Pacific Network
To connect to Pacific in your browser with MetaMask, see [Tutorial: Connect to the Pacific Network](/tutorials/connect-to-networks/#connect-to-the-pacific-network).
## Pacific Blockchain Explorers
There is a Pacific blockchain explorer at [submarine.oceanprotocol.com](https://submarine.oceanprotocol.com/). You can use it to check the status of a transaction, the balance of an account, and more.
It uses the following symbols for Pacific Ether and Pacific Ocean Tokens:
| Cryptocurrency | Symbol used |
| -------------------- | ---------------- |
| Pacific Ether | POA |
| Pacific Ocean Tokens | OCEAN or SBT-OCN |
## Ocean Components Connected to Pacific
There are several Ocean Protocol software components that are live, connected to the Pacific Network, and operated by BigchainDB GmbH:
| Component | URL |
| ---------------------- | -------------------------------------------- |
| Node | `https://pacific.oceanprotocol.com` |
| Secret Store | `https://secret-store.oceanprotocol.com` |
| Aquarius Test instance | `https://aquarius.test.oceanprotocol.com` |
| Brizo Test instance | `https://brizo.test.oceanprotocol.com` |
| Aquarius for Commons | `https://aquarius.commons.oceanprotocol.com` |
| Brizo for Commons | `https://brizo.commons.oceanprotocol.com` |
| Commons Marketplace | `https://commons.oceanprotocol.com` |
| Faucet Server | `https://faucet.oceanprotocol.com` |
| Token Bridge Frontend | `https://bridge.oceanprotocol.com` |
> Internal note: The private "atlantic" repo documents the internal details of the Pacific Network in `networks/pacific/deployment.md`.
## Using Barge with Pacific
If you run [Barge](https://github.com/oceanprotocol/barge) with the `--local-pacific-node` option, then Barge will run a Pacific node on your local machine (along with everything else Barge runs).
There might be many blocks in the Pacific Network's blockchain, so it might take a long time for your local Pacific node to sync, i.e. to download a local copy of all the blocks. **In the meantime, the local Pacific node won't be able to do certain things.**

10
content/concepts/quickstart.md Normal file
View File

@ -0,0 +1,10 @@
---
title: Quickstart
description:
---
These drivers each have their own quickstart. Pick your favorite and have fun!
- [ocean.js](/references/ocean.js/)
- [ocean.py](/references/ocean.py/)
- [Ocean React](/references/react/)

88
content/concepts/resources.md
View File

@ -1,88 +1,10 @@
---
title: Resources
description: More places where you can learn about Ocean Protocol.
description:
---
## Papers
Here are a few places for more information.
All papers can be retrieved from the [Papers section](https://oceanprotocol.com/protocol/#papers) on our home page:
- **Technical Whitepaper** - This paper presents Ocean Protocol. Ocean is a decentralized protocol and network of artificial intelligence (AI) data/services. It incentivizes for a vast supply of relevant AI data/services.
- **Business Strategy** - This document presents a summary of the business model and ecosystem of Ocean Protocol. It is complementary to the technical whitepaper for Ocean Protocol.
- **Marketplace Framework** - This document presents a summary of the core marketplace attributes and components required to facilitate the successful deployment of the decentralized data exchange protocol and network called Ocean Protocol.
## Roadmap
[Ocean Protocol roadmap](https://oceanprotocol.com/protocol/#roadmap) outlining our plans and achievements in creating Ocean Protocol and building a community and ecosystem around it.
## Blog
Follow our [blog](https://blog.oceanprotocol.com/) to keep up-to-date with news about our community, tech progress, new use-cases, integrations and everything around Ocean.
In March 2019, we launched [an international version](https://medium.com/ocean-protocol-international)
of our blog for our non-english speaking communities. You can find blog posts in various languages such as Chinese, Russian, Korean, Spanish, Japanese and many more.
Below we have listed the most important blog posts that you should not miss.
### Diving into Ocean
The blog posts are easily-digestible introductions into Ocean Protocol. We address the “data problem” and explore real world uses cases involving our partners and collaborators.
- [4 Reasons to Dive into Ocean Protocol (and change the World)](https://blog.oceanprotocol.com/4-reasons-to-dive-into-ocean-protocol-and-change-the-world-b18cc8d53235)
- [4 Ways We’re Unlocking the Value of Data through Partnerships](https://blog.oceanprotocol.com/4-ways-were-unlocking-the-value-of-data-through-partnerships-9ee468e38265)
- [Building a better world with safe sharing of data](https://blog.oceanprotocol.com/building-a-better-world-with-safe-sharing-of-data-d448ec2472b0)
### Product
Already familiar with Ocean and want to jump into the tech? These blog posts explore product developments, updates and integrations.
#### Privacy
- [Blockchains for Artificial Intelligence](https://blog.oceanprotocol.com/blockchains-for-artificial-intelligence-ec63b0284984)
- [From AI to Blockchain to Data: Meet Ocean](https://blog.oceanprotocol.com/from-ai-to-blockchain-to-data-meet-ocean-f210ff460465)
- [Ocean’s Top-Level Goals](https://blog.oceanprotocol.com/oceans-top-level-goals-3dd75907187)
#### Control
- [Exploring the SEA: Service Execution Agreements](https://blog.oceanprotocol.com/exploring-the-sea-service-execution-agreements-65f7523d85e2)
- [Introducing the Ocean Protocol Service Agreements](https://blog.oceanprotocol.com/oep-11-service-agreements-63421ca76d9f)
#### Security
- [Secure On-Chain Access Control for Ocean Protocol](https://blog.oceanprotocol.com/secure-on-chain-access-control-for-ocean-protocol-38dca0af820c)
- [Ocean Integration: fitchain — Providing Secure On-Premise Compute](https://blog.oceanprotocol.com/ocean-integration-fitchain-secure-on-premises-compute-59f43a944266)
- [Smart Contracts Security Audit](https://blog.oceanprotocol.com/smart-contracts-security-audit-6672de695b5b)
#### Incentives
- [Curated Proofs Markets: A Walk-Through of Ocean’s Core Token Mechanics](https://blog.oceanprotocol.com/curated-proofs-markets-a-walk-through-of-oceans-core-token-mechanics-3d50851a8005)
- [The Layered TCR](https://blog.oceanprotocol.com/the-layered-tcr-56cc5b4cdc45)- [Introducing the equilibrium bonding market](https://blog.oceanprotocol.com/introducing-the-equilibrium-bonding-market-e7db528e0eff)
- [How Ocean can benefit data scientists](https://blog.oceanprotocol.com/how-ocean-can-benefit-data-scientists-7e502e5f1a5f)
#### Other worthwhile reading about product and deep tech
- [Project Manta Ray — Data Science powered by Ocean Protocol](https://blog.oceanprotocol.com/project-manta-ray-data-science-powered-by-ocean-protocol-535c54089b0f)
- [Ocean ♥ Docker](https://blog.oceanprotocol.com/ocean-docker-d43d992d8ecf)
- [How to Swim in the Ocean: Introducing Squid Libraries](https://blog.oceanprotocol.com/ocean-protocol-squid-library-java-c92a6035ce39)
- [The Commons Marketplace](https://blog.oceanprotocol.com/the-commons-data-marketplace-c57a44288314)
- [The Commons Marketplace in Pacific Network](https://blog.oceanprotocol.com/the-commons-marketplace-in-pacific-network-4bcf2f595721)
## Videos
Follow [our YouTube channel](https://www.youtube.com/oceanprotocol) not to miss any of our video content that includes meetup recordings, tech tutorials, use-case presentations and much more. Here is a selection of our most important playlists:
- [Ocean Partners and Collaborators](https://www.youtube.com/playlist?list=PL_dn0wVs9kWohtVtZZlj9AR5gcMj0s15h) - This series introduces our partners and collaborators and explores the possible way how Ocean Protocol can help their use-cases.
We have translated this series into several languages. Just add the subtitles of your choice while watching.
- [Manta Ray Tutorials](https://www.youtube.com/playlist?list=PL_dn0wVs9kWqSO2iCXvrWuxKFSgVr0Jrw) - Introducing Manta Ray - Ocean Protocol for Data Scientists, Data Engineers, and Python developers!
Manta Ray is designed to leverage the underlying Ocean API (oceanically named squid-py) which provides surface level methods for searching, publishing, and consuming assets in the deeper Ocean Protocol network.
- [Meet the Fleet](https://www.youtube.com/playlist?list=PL_dn0wVs9kWrgEGk0cd52qO6w3FiuY65G) - Ocean Protocol is being built by a diverse ecosystem of contributors who share a common vision of unlocking data for AI. Our core team has converged from many different countries, industries, and backgrounds to collaborate on kickstarting a New Data Economy. Check this mini series to find out who helps developing Ocean Protocol.
## Events
Our team members travel the world to present about Ocean Protocol and meet with local communities. Please, check [our website](https://oceanprotocol.com/#events) for events in your area.
We also often host and co-organize meetups all around the globe. Check the different meetup groups to find a group in your city and attend our meetup:
- [Data Economy](https://www.meetup.com/de-DE/pro/data-economy) - Estimates show that a \$2-5 Trillion Data Economy could be created if organizations and people would have the tools to guarantee control, privacy, security, compliance and pricing of data. Our target is bringing together curious minds with a background in Data Science, Blockchain, Artificial Intelligence, Robotics, Business Innovation and Blockchain. We started this initiative to build a community of enthusiasts around Data Economy including the following core topic areas: (1) Data Exchanges & Marketplaces, (2) Data Security, Privacy, Ethics, (3) Decentralised Systems & Blockchain, (4) Artificial Intelligence & Machine Learning, (5) Data Curation & Interoperability, and (6) New Business Models and Tangible Use Cases.
- [Token Engineering](https://www.meetup.com/pro/tokenengineering/) - Our mission is to see token ecosystem design become a new engineering discipline. This implies a body of theory, practice, tools and a sense of responsibility. We aim to do this collectively as a community in a decentralized, permissionless, open-source fashion that all can contribute to and all can use.
- [Ocean homepage](https://www.oceanprotocol.com)
- [Ocean blog](https://blog.oceanprotocol.com)
- [Ocean whitepaper](https://oceanprotocol.com/tech-whitepaper.pdf)

55
content/concepts/terminology.md
View File

@ -1,55 +0,0 @@
---
title: Terminology
description: Terminology specific to Ocean Protocol.
---
## Ocean Network
Any EVM-compatible network where all[^1] the Ocean Protocol smart contracts ([keeper contracts](https://github.com/oceanprotocol/keeper-contracts)) are deployed. There can be many Ocean networks and you can use the Ocean Protocol in several EVM-compatible networks, including:
- the Ethereum Mainnet (also called the Main Ethereum Network)
- the Ocean [Pacific Main Network](/concepts/pacific-network/)
- various Ocean [test networks](/concepts/testnets/)
## Asset or Data Asset
Anything that can be registered with and made available via an Ocean Network. Examples include data sets, trained model parameters, pipelines, and data-cleaning services.
## Data Owner or Data Service Provider
Someone who has assets that they want to sell (or give away freely). An example is an almond distributor with 30 years of data about almond sales.
> Initially, most data owners or data service providers will also be the publishers of their own assets.
## Publisher
A service which mediates access to assets on behalf of data owners or data service providers.
> Initially, most publishers will also be the owners of the assets they publish.
## Consumer
Someone who wants assets. An example is a data scientist working at an economic think tank.
## Marketplace
A service where publishers can list what assets they have, and consumers can see what's available then buy it (or get it for free). Every marketplace has a database where they store metadata about the assets they know about (but not the assets themselves). An Ocean network can support many marketplaces.
## Verifier
A person or a software service that checks some steps in transactions. For example, a verifier might check to see if a cryptographic signature is valid and then get rewarded for doing so.
## Service Execution Agreement (SEA) or Service Agreement
A contract-like agreement between a publisher, a consumer, and a verifier, specifying what assets are to be delivered (from publisher to consumer), the conditions that must be met, and the rewards for fulfilling the conditions.
We published a blog post that explains SEAs in more detail:
- [Blog: Exploring the SEA: Service Execution Agreements](https://blog.oceanprotocol.com/exploring-the-sea-service-execution-agreements-65f7523d85e2)
## More Terminology
- See the page about Ocean's [Software Components](/concepts/components/).
- See the page about [wallets (and other Ethereum terminology)](/concepts/wallets/).
[^1]: The _Dispenser_ smart contract should only be deployed to testnets.

68
content/concepts/testnets.md
View File

@ -1,68 +0,0 @@
---
title: Testnets
description: An overview of public test networks that you can test Ocean Protocol applications against.
---
This page is a brief overview of available testnets. The [tutorials](/tutorials/) cover more details (e.g. how to connect to specific ones).
## A Spree Testnet (for Local Development)
By default, [Barge](https://github.com/oceanprotocol/barge) will deploy a local _Spree Testnet_[^1] on your machine: a local testnet not connected to any external public testnet.
When running a Spree Testnet, you can connect to a node at RPC URL [http://localhost:8545](http://localhost:8545) (called "Localhost 8545" in MetaMask).
Spree Testnet details can be found in the [Barge README.md file](https://github.com/oceanprotocol/barge#spree-network). You can configure the Spree nodes by editing the files in the `barge/networks/spree/` directory.
> Spree testnets are named after the Spree River, the main river flowing through Berlin, Germany, where many Ocean Protocol developers are located.
## The Nile Testnet
In the _Nile Testnet_[^2] all nodes are operated by BigchainDB GmbH.
> For developers building on Ocean Protocol, we recommend starting with a [Spree Testnet](#a-spree-testnet-for-local-development).
### Connect to the Nile Testnet
See [Tutorial: Connect to the Nile Testnet](/tutorials/connect-to-networks/#connect-to-the-nile-testnet).
### Nile Blockchain Explorers
There is a Nile blockchain explorer at [https://submarine.nile.dev-ocean.com/](https://submarine.nile.dev-ocean.com/). You can use it to check the status of a transaction, the balance of an account, and more. It uses the following symbols for Nile Ether and Nile Ocean Tokens:
| Cryptocurrency | Symbol used |
| ----------------- | ---------------- |
| Nile Ether | POA |
| Nile Ocean Tokens | OCEAN or SBT-OCN |
### Ocean Components Connected to Nile
There are several Ocean Protocol software components that are live, connected to the Nile Testnet, and operated by BigchainDB GmbH:
| Component | URL |
| ---------------------- | -------------------------------------------- |
| Node | `https://nile.dev-ocean.com` |
| Secret Store | `https://secret-store.nile.dev-ocean.com` |
| Aquarius Test instance | `https://aquarius.nile.dev-ocean.com` |
| Brizo Test instance | `https://brizo.nile.dev-ocean.com` |
| Aquarius for Commons | `https://aquarius.marketplace.dev-ocean.com` |
| Brizo for Commons | `https://brizo.marketplace.dev-ocean.com` |
| Commons Marketplace | `https://commons.nile.dev-ocean.com` |
| Jupyter Hub | `https://mantaray.dev-ocean.com` |
| Faucet Server | `https://faucet.nile.dev-ocean.com` |
> Internal note: The private "atlantic" repo documents the internal details of the Nile Testnet in `networks/nile/README.md`.
### Using Barge with Nile
If you run [Barge](https://github.com/oceanprotocol/barge) with the `--local-nile-node` option, then Barge will run a Nile node on your local machine (along with everything else Barge runs).
There might be many blocks in the Nile Testnet's blockchain, so it might take a long time for your local Nile node to sync, i.e. to download a local copy of all the blocks. **In the meantime, the local Nile node won't be able to do certain things.**
## A Ganache-Based Testnet (for Local Development)
A local testnet similar to Spree but launched by using the `--local-ganache-node` option with Barge.
> You shouldn't use a Ganache-Based Testnet unless you know why you're doing so. For example, a Ganache-based testnet can be used to test some smart contracts, but it can't be used with a Secret Store.
[^1]: Formerly called Ocean Protocol Testnet v0.1, it was announced as part of the Plankton milestone.
[^2]: Also known as the Nile Beta Network. Formerly called the Ocean POA Testnet.

67
content/concepts/tools.md
View File

@ -1,67 +0,0 @@
---
title: Tools
description: Some tools that can be useful when working with Ocean Protocol.
---
## Barge
Barge is a shell script allowing you to run an Ocean network by orchestrating all [core components](/components) locally with Docker and Docker Compose. Extensively used by Ocean developers to develop and test Ocean core components locally, and the [quickest way](/setup/quickstart/) to get a full Ocean network up and running.
<repo name="barge"></repo>
## Tuna
Tuna is a showcase and provides cross environment examples & tests for the Squid client libraries.
<repo name="tuna"></repo>
## Plecos
Plecos is a Python tool to check metadata (a JSON file) to see if it conforms to the [OEP-8 schema](https://github.com/oceanprotocol/OEPs/tree/master/8). It wraps the [jsonschema](https://github.com/Julian/jsonschema) validator. Aquarius uses Plecos for checking metadata and other Ocean Protocol software will probably use it in the future.
<repo name="plecos"></repo>
## Faucet Server
The [Ocean Protocol Faucet Server](https://github.com/oceanprotocol/faucet) is a microservice that allows users to request Ether for a particular Ethereum network (e.g. the Nile Testnet). It is [deployed in multiple networks](/tutorials/get-ether-and-ocean-tokens/#get-ether), and started by default when using [Barge](#barge).
<repo name="faucet"></repo>
## Submarine Blockchain Explorer
Submarine is based on [BlockScout](https://github.com/poanetwork/blockscout) (by [POA](https://poa.network/)), an open source blockchain explorer for EVM-based blockchain networks. We use our own [fork of BlockScout](https://github.com/oceanprotocol/blockscout).
Instances are deployed for:
- **Pacific Network: [submarine.oceanprotocol.com](https://submarine.oceanprotocol.com/)**
- **Nile Testnet: [submarine.dev-ocean.com](https://submarine.dev-ocean.com/)**
<repo name="blockscout"></repo>
## Ocean Network Status
The Ocean status page checks all Ocean network connections from your browser.
- [**Ocean Network Status**](https://status.oceanprotocol.com)
<repo name="status"></repo>
## Command-Line Interfaces
There are a few Ocean Protocol command-line interfaces (CLIs). All of them were under development at the time of writing, so you may have issues with using them.
- [ocean-cli](https://github.com/bigchaindb-gmbh/ocean-cli) was built using squid-java
- [ocean-cli-py](https://github.com/bigchaindb-gmbh/ocean-cli-py) was built using squid-py
## IPFS
The IPFS protocol is integrated into the Ocean Protocol stack in various places. For this, we run and maintain our own IPFS node and gateway with a custom frontpage for simple adding of files to that IPFS node.
- [**Ocean Protocol 💖 IPFS**](https://ipfs.oceanprotocol.com)
<repo name="ipfs"></repo>
To learn more about how IPFS is used, have a look at OEP-15 and the respective blog post:
- [OEP-15: Distributed Asset File Storage with IPFS](https://github.com/oceanprotocol/OEPs/tree/master/15)
- [Ocean Protocol and IPFS, Sitting In The Merkle Tree](https://blog.oceanprotocol.com/ocean-ipfs-integration-store-asset-files-43c623c356d7)

17
content/references/introduction.md
View File

@ -1,18 +1,19 @@
---
title: API References
description: All the API reference docs for Ocean Protocol components and libraries.
description:
---
This section has API reference docs (or links to external ones) for the following Ocean Protocol components and libraries:
<repo name="ocean.js"></repo>
<repo name="react"></repo>
<repo name="ocean.py"></repo>
<repo name="ocean-contracts"></repo>
<repo name="aquarius"></repo>
<repo name="brizo"></repo>
<repo name="squid-js"></repo>
<repo name="squid-py"></repo>
<repo name="squid-java"></repo>
<repo name="provider-py"></repo>
The API references for Aquarius and Brizo are auto-generated from the Swagger specs (JSON files) of the live Aquarius and Brizo instances attached to the Nile Testnet. On this site you can't execute the documented API calls yet. If you need that, you can run a component's local Swagger UI as outlined in the repository instructions on GitHub.
Additionally, if you need API docs for a past version of Aquarius or Brizo, check out their specs on SwaggerHub:
The API references for Aquarius and Provider-py are auto-generated from the Swagger specs (JSON files) of the live instances. On this site you can't execute the documented API calls yet. If you need that, you can run a component's local Swagger UI as outlined in the repository instructions on GitHub.
Additionally, if you need API docs for a past version of Aquarius or Provider-py, check out their specs on SwaggerHub:
- [SwaggerHub: Aquarius](https://app.swaggerhub.com/apis/Ocean-Protocol/aquarius)
- [SwaggerHub: Brizo](https://app.swaggerhub.com/apis/Ocean-Protocol/brizo)
- [SwaggerHub: Provider-py](https://app.swaggerhub.com/apis/Ocean-Protocol/provider-py)

71
content/setup/marketplace.md
View File

@ -1,71 +0,0 @@
---
title: Set Up a Marketplace
description: Set up and run a data marketplace in an Ocean network.
---
In Ocean Protocol, marketplaces and publishers play different roles (outlined in the [Terminology page](/concepts/terminology/)), but both roles can be played by the same person or organization. Initially, we anticipate that will be the most common setup. As a result, this guide explains how to set up and run a combined marketplace/publisher (for now).
## An Outline of the Steps
1. Have [assets](/concepts/terminology/#asset-or-data-asset) to offer in your marketplace.
1. Prepare those assets to work with Ocean Protocol.
1. Develop a marketplace/publisher app.
1. Run everything you need to run in production.
## Prepare Assets
At the time of writing, the following kinds of [assets](/concepts/terminology/#asset-or-data-asset) were supported:
- data sets stored in Azure Storage (i.e. with "core.windows.net" in their URL). See [the tutorial about setting up Azure Storage to work with Ocean Protocol](/tutorials/azure-for-brizo/).
- data sets stored in Amazon S3 storage (i.e. with "s3://" in their URL). See [the tutorial about setting up Amazon S3 storage to work with Ocean Protocol](/tutorials/amazon-s3-for-brizo/).
- data sets stored in on-premise storage. See [the tutorial about setting up on-premise storage to work with Ocean Protocol](/tutorials/on-premise-for-brizo/).
> You can use _all_ of the above. You aren't restricted to using only one storage provider.
Support for other kinds of assets (e.g. computing in Azure) is coming.
## Develop a Marketplace/Publisher App
At the time of writing, we recommend the following steps to develop a marketplace/publisher app:
1. Do the [React App Tutorial](/tutorials/react-setup/).
2. Grow your app from there.
For more examples and inspiration, check out the [source code for the Commons Marketplace](https://github.com/oceanprotocol/commons) and the [source code for Pleuston](https://github.com/oceanprotocol/pleuston). Both have an Apache v2 open source license. Both use React and squid-js. Both are "serverless" apps: they run entirely in the browser and have no server-side component.
<repo name="commons"></repo>
<repo name="pleuston"></repo>
### Other Options
A marketplace/publisher app could have both a back-end component and a front-end component. The main consideration is that you should probably use a programming language with an existing Squid library:
<repo name="squid-js"></repo>
<repo name="squid-py"></repo>
<repo name="squid-java"></repo>
> There are examples of how to use squid-py in the [Tutorials](/tutorials/introduction/). squid-py is to Ocean like boto3 is to AWS.
Of course, you could always write your own Squid library in the language of your choice.
## Run Everything You Need to Run in Production
When developing your marketplace/publisher app, you will probably use Barge to run all the Ocean Protocol components on your local machine. When it comes time to go to production, you will have to run some of those components in production:
- Your marketplace/publisher app
- [Aquarius](/concepts/components/#aquarius)
- A database to go with Aquarius, e.g. Elasticsearch or MongoDB
- [Brizo](/concepts/components/#brizo)
- Recommended: a [keeper](/concepts/components/#keeper) node with the keeper contracts deployed to it, connected to an Ocean network
- Optional: your own [Secret Store](/concepts/components/#secret-store) nodes (for a more advanced setup)
Before running all of that in production, you will want to test it with an [Ocean Protocol testnet](/concepts/testnets/).
Of course, there are many other things that must be handled in production:
- Security of the infrastructure where the software is running
- Monitoring
- Log aggregation, storage and search
- Handling crashes or other faults
Each of those is a big topic beyond the scope of these docs.

6
content/setup/publisher.md
View File

@ -1,6 +0,0 @@
---
title: Set Up a Publisher
description: Set up and run a publisher in an Ocean network.
---
Initially, there won't be many Ocean marketplaces or publishers, so most marketplaces will also act as publishers, and most publishers will also act as marketplaces. Therefore, for now, see [the docs for marketplaces](/setup/marketplace/).

32
content/setup/quickstart.md
View File

@ -1,32 +0,0 @@
---
title: Quickstart
description: Do a quick test drive of Ocean Protocol components or interact with the network by using Jupyter notebooks.
---
## 🐳 Developers: Barge
Developers can run and try every [Ocean software component](/concepts/components/) on their local machine, all at once, using Docker Compose. Ocean Protocol software developers do this often, to test their code against all the other Ocean components.
```bash
git clone https://github.com/oceanprotocol/barge.git
cd barge/
./start_ocean.sh
```
Seeing the dolphin means it's working:
![Output of start_ocean.sh](images/dolphin.png)
Once everything is up and running, you can interact with the components. E.g. once [Commons](/concepts/components/#commons) is running, you can interact with it at:
- [http://localhost:3000/](http://localhost:3000/)
For the details of what components are running, see the [`barge` repository](https://github.com/oceanprotocol/barge).
<repo name="barge"></repo>
## 👩‍🔬 Data Science: Jupyter notebooks
You can try some free, online Jupyter notebooks that connect to a live Ocean test network.
- [Tutorial: Jupyter Notebooks](/tutorials/jupyter-notebooks/)

2
content/tutorials/amazon-s3-for-brizo.md
View File

@ -3,6 +3,8 @@ title: Set Up Amazon S3 Storage
description: Tutorial about how to set up Amazon S3 storage for use with Ocean Protocol.
---
*Note: This needs updating for Ocean V3. As a workaround: Brizo has been renamed to provider-py; it should work similarly.*
To enable Brizo to use files stored in Amazon S3 (i.e. files with an URL containing `s3://`), you must:
1. have an Amazon AWS user account (IAM account) with permission to read those files from S3, and

0
content/setup/compute-to-data.md → content/tutorials/compute-to-data.md
View File

38
content/tutorials/connect-to-networks.md
View File

@ -1,38 +1,30 @@
---
title: Connect to Ocean-Related Networks
description: Learn how to connect to the Pacific network, Nile testnet and other Ocean-related networks in your browser with MetaMask.
description: On connecting to Ethereum, Rinkeby and Your Local Network.
---
## Connect to the Pacific Network
## Connect to Ethereum mainnet
Here are the parameters you might need to connect to the [Pacific Network](/concepts/pacific-network/):
Metamask and other ERC20 wallets default to Ethereum mainnet. Therefore your wallet is almost certainly pointing to Ethereum by default.
| Parameter | Value |
| ------------------ | ---------------------------------------------------------- |
| RPC URL (required) | `https://pacific.oceanprotocol.com` |
| ChainID | `846353` (decimal for MetaMask) or `0xcea11` (hexadecimal) |
| Symbol | Whatever you like, e.g. `PACIFIC ETH` |
| Nickname | Whatever you like, e.g. `Pacific` |
Some apps may need `network_id` and `chain_id`. The values are both `1` for Ethereum mainnet. `Symbol` and `nickname` can be whatever value you like.
In MetaMask, click on the network name then click on `Custom RPC` in the drop-down list. Scroll down to the `New Network` section. Enter the above RPC URL. You don't need to add a port number to the end of the RPC URL. Enter the ChainID, Symbol and Nickname if you like. See the [MetaMask docs about how it uses the ChainID](https://metamask.github.io/metamask-docs/Main_Concepts/Sending_Transactions).
## Connect to Rinkeby testnet
If you're using [Barge](https://github.com/oceanprotocol/barge) to run a local Pacific node, you can connect to that local Pacific node at RPC URL [http://localhost:8545](http://localhost:8545) (called "Localhost 8545" in MetaMask). You can configure that local Pacific node by editing the files in the `barge/networks/pacific/config/` directory.
In MetaMask, click on the network name dropdown, then select `Rinkeby`.
## Connect to the Nile Testnet
Its `network_id` is 3 and `chain_id` is 3.
Here are the parameters you might need to connect to the [Nile Testnet](/concepts/testnets/#the-nile-testnet):
## Connect to local Ganache network
| Parameter | Value |
| ------------------ | ------------------------------------------------------- |
| RPC URL (required) | `https://nile.dev-ocean.com` |
| ChainID | `8995` (decimal for MetaMask) or `0x2323` (hexadecimal) |
| Symbol | Whatever you like, e.g. `NILE ETH` |
| Nickname | Whatever you like, e.g. `Nile Testnet` |
**Metamask.** In MetaMask, click on the network name then click on `Custom RPC` in the drop-down list. Scroll down to the `New Network` section. Enter the above RPC URL. You don't need to add a port number to the end of the RPC URL. Enter the ChainID, Symbol and Nickname if you like. See the [MetaMask docs about how it uses the ChainID](https://metamask.github.io/metamask-docs/Main_Concepts/Sending_Transactions).
In MetaMask, click on the network name then click on `Custom RPC` in the drop-down list. Scroll down to the `New Network` section. Enter the above RPC URL. You don't need to add a port number to the end of the RPC URL. Enter the ChainID, Symbol and Nickname if you like. See the [MetaMask docs about how it uses the ChainID](https://metamask.github.io/metamask-docs/Main_Concepts/Sending_Transactions).
**Barge.** If you're using Ocean [Barge](https://github.com/oceanprotocol/barge) to help run a local network, you can connect to that local node at RPC URL [http://localhost:8545](http://localhost:8545) (called "Localhost 8545" in MetaMask). You can configure that local node by editing the files in the `barge/networks/pacific/config/` directory.
If you're using [Barge](https://github.com/oceanprotocol/barge) to run a local Nile node, you can connect to that local Nile node at RPC URL [http://localhost:8545](http://localhost:8545) (called "Localhost 8545" in MetaMask). You can configure that local Nile node by editing the files in the `barge/networks/nile/config/` directory.
## More info
- [List of Ethereum's Major Networks and Chain ids](https://medium.com/@piyopiyo/list-of-ethereums-major-network-and-chain-ids-2bc58e928508).
- [Ganache documentation](https://www.trufflesuite.com/ganache)
## Connect to a Local Spree Testnet or Ganache-Based Testnet
When using [Barge](https://github.com/oceanprotocol/barge) to run a purely-local testnet (Spree or Ganache-based), you can connect to a local node at RPC URL [http://localhost:8545](http://localhost:8545) (called _Localhost 8545_ in MetaMask).

81
content/tutorials/get-ether-and-ocean-tokens.md
View File

@ -1,82 +1,33 @@
---
title: Get Ether and Ocean Tokens
description: A tutorial about how to get Ether and Ocean Tokens.
title: Get ETH and OCEAN Tokens
description: How to get tokens for each network deployment
---
If you want to interact with an Ethereum-based network that supports Ocean Protocol, then you'll eventually need Ether or [Ocean Tokens](/concepts/ocean-tokens/) _for that network_. Every Ethereum-based network has its own Ether and its own Ocean Tokens, and you can't use those in other networks.
### Overview
There are some public testnets you can use to test an Ocean Protocol application. For more information about those, see the page about [testnets](/concepts/testnets/).
In each network, you'll need ETH to pay for gas. Certain Ocean actions will need OCEAN tokens.
## Get a Compatible Wallet
The ETH and OCEAN in Rinkeby and local networks are not "real" ETH or OCEAN tokens of any value. They're simply stand-ins to be able to test.
You will need a [wallet](/concepts/wallets/) that can hold Ether (for any Ethereum network) and Ocean Tokens (for any Ethereum network). For the purpose of this tutorial, you can use MetaMask. See our tutorial about [how to set up MetaMask](/tutorials/metamask-setup/).
### Ethereum mainnet
In MetaMask, be sure to switch from the _Main Ethereum Network_ to whatever Ocean network you're using.
- **ETH.** [Here are exchanges](https://www.coingecko.com/en/coins/ethereum#markets) to purchase ETH.
## Get Ether
- **OCEAN.** [Here are exchanges](https://www.coingecko.com/en/coins/ocean-protocol#markets) to purchase OCEAN.
### Get Ether for the Pacific Network
If you're connecting to the Pacific network, you can use the [Ocean Faucet server](/concepts/tools/#faucet-server). A simple user interface for it is deployed as part of the Commons marketplace under:
### Rinkeby testnet
- client: [commons.oceanprotocol.com/faucet](https://commons.oceanprotocol.com/faucet)
Testnets like Rinkeby have faucets to dole out ETH and OCEAN.
This interface is set up to communicate with the deployed Ocean Faucet Server under:
- **ETH.** [Here's an ETH faucet](https://faucet.rinkeby.be/) for Rinkeby. You may find others by [searching](https://www.google.com/search?q=rinkeby+ether+faucet&oq=rinkeby+ether+faucet).
- server: [faucet.oceanprotocol.com](https://faucet.oceanprotocol.com)
- **OCEAN.** [Here's an OCEAN faucet](https://faucet-5wrpg.ondigitalocean.app/) for Rinkeby.
You can also communicate with that server directly and get some Pacific Ether into `<YOUR ADDRESS>` using the following command:
### Local network
```bash
curl --data '{"address": "<YOUR ADDRESS>", "agent": "curl"}' -H "Content-Type: application/json" -X POST https://faucet.oceanprotocol.com/faucet
```
Ganache is the local network. Ocean Barge is a tool to help use it.
Check out the [Ocean Faucet server repository](https://github.com/oceanprotocol/faucet) to learn more about what the server provides.
- **ETH.** By default, Ganache creates several Ethereum accounts at launch, gives each some ETH, and makes their private keys available in the logs. You can also instruct Ganache to give ETH to specific Ethereum addresses.
The Pacific faucet has a limit of one request every 24 hours for the same Ethereum address. But don't worry, the Ether given is more than enough for interacting with the network.
### Get Ether for the Nile Testnet
If you're connecting to the Nile testnet, you can use the Ocean Faucet. A simple UI for it is deployed as part of the Commons marketplace under:
- client: [commons.nile.dev-ocean.com/faucet](https://commons.nile.dev-ocean.com/faucet)
This interface is set up to communicate with the deployed Ocean Faucet Server under:
- server: [faucet.nile.dev-ocean.com](https://faucet.nile.dev-ocean.com)
You can also communicate with that server directly and get some Nile Ether into `<YOUR ADDRESS>` using the following command:
```bash
curl --data '{"address": "<YOUR ADDRESS>", "agent": "curl"}' -H "Content-Type: application/json" -X POST https://faucet.nile.dev-ocean.com/faucet
```
Check out the [Ocean Faucet Server repository](https://github.com/oceanprotocol/faucet) to learn more about what the server provides.
The Nile faucet has a limit of one request every 24 hours for the same Ethereum address. But don't worry, the Ether given is more than enough for interacting with the network.
### Get Ether for a Local Spree Testnet
You can use the [Ocean Faucet server](/concepts/tools/#faucet-server) which is stafrted by default when you run [Barge](/concepts/tools/#barge).
To ask the faucet to send some Spree Ether to `<YOUR ADDRESS>`, use the command:
```bash
curl --data '{"address":"<YOUR ADDRESS>"}' -H "Content-Type: application/json" -X POST localhost:3001/faucet
```
Alternatively, you can import the seed phrase used to generate the accounts in Spree into MetaMask (e.g. by logging out and then clicking "Import using account seed phrase"). By default, the Spree testnet is configured to bootstrap ten accounts with a decent amount of Spree Ether in each one.
`taxi music thumb unique chat sand crew more leg another off lamp`
Details about the bootstrapped accounts can be found in [the README.md file in the Barge repository](https://github.com/oceanprotocol/barge/#spree-network). They're the ones of type "mnemonic."
> **WARNING!** Never use any of those accounts in any mainnet. They are for testing purposes only.
### Get Ether for a Local Ganache-Based Testnet
If you're running a local Ganache-based testnet, then it creates several accounts at network launch time, and gives each of them some Ether. The addresses and private keys of those accounts should be shared (to logs or the console) during the launch process. You can use those accounts and their Ether.
## Get Ocean Tokens
See the page about [Ocean Tokens](/concepts/ocean-tokens/).
- **OCEAN.** You can deploy an ERC20 token with label OCEAN. You'll see examples in the quickstarts for the Ocean JavaScript and Python drivers.

13
content/tutorials/introduction.md
View File

@ -1,10 +1,13 @@
---
title: Overview of the Tutorials
description: What you can expect to find in these Ocean Protocol tutorials.
title: Overview of Tutorials
description:
---
These tutorials cover:
- The basics of using wallets with Ocean Protocol.
- How to set up storage (e.g. in Azure or AWS) to be used with Ocean Protocol.
- Examples of using squid-js (JavaScript), squid-py (Python) and squid-java to publish a data set, to get & use a data set, and to do other things.
- Using Web3 wallets with Ocean
- Getting ETH and OCEAN on Ethereum mainnet, and Rinkeby testnet
- Storage setup - Azure, AWS or local
- Building a React app with Ocean. This is a great way to understand Ocean end-to-end.

45
content/tutorials/marketplace.md Normal file
View File

@ -0,0 +1,45 @@
---
title: Set Up a Marketplace
description:
---
In Ocean, marketplaces and publishers are different roles. A common setup is for one organization to do both. We focus on that here.
## The Steps
1. Develop the first cut of the app.
1. Prepare some initial data assets.
1. Deploy to production.
## Develop a First Cut of the App
Here are some approaches:
-Fork [Ocean Market](/references/market/) code
-Do the [React App Tutorial](/tutorials/react-setup/) then grow your app from there. It uses [Ocean React hooks](/references/react/).
-Build up from [ocean.js](/references/ocean.js/) or [ocean.py](/references/ocean.py/) drivers
## Prepare Some Initial Data Assets
When you deploy, you'll want some initial data assets for your market to offer.
Ocean supports several types, such as Azure and S3 storage. The [tutorials](/tutorials/) section provides more info.
## Deploy to Production
When developing your app, you'll likely use Barge to run all the Ocean Protocol components on your local machine.
When it comes time to go to production, you will have to run these components:
- Your marketplace/publisher app
- Aquarius (with Elasticsearch)
- Provider-py
Of course, there are many other things that must be handled in production:
- Security of the infrastructure where the software is running
- Monitoring
- Log aggregation, storage and search
- Handling crashes or other faults
Each of those is beyond the scope of these docs.

2
content/tutorials/metamask-setup.md
View File

@ -1,5 +1,5 @@
---
title: Set Up MetaMask
title: Set Up MetaMask Wallet
description: Tutorial about how to set up MetaMask for Chrome.
---

2
content/tutorials/on-premise-for-brizo.md
View File

@ -3,6 +3,8 @@ title: Set Up On-Premise Storage
description: Tutorial about how to set up on-premise storage for use with Ocean.
---
*Note: This needs updating for Ocean V3. As a workaround: Brizo has been renamed to provider-py; it should work similarly.*
To enable Brizo to use files stored in on-premise storage (i.e. files with an URL not containing `core.windows.net` or `s3://`), there is _nothing to do, other than make sure Brizo can resolve the URLs_. In particular, you don't have to set any Brizo-specific configuration settings, e.g. in the `[osmosis]` section of the Brizo config file or in some special Brizo environment variables.
Local and private network URLs are fine so long as they can be resolved by Brizo. Potential examples include `http://localhost/helicopter_data.xls`, `http://192.168.12.34/almond_sales_2012.csv` and `http://10.12.34.56/duck_photos.zip`.

2
content/tutorials/react-publish-algorithm.md
View File

@ -13,7 +13,7 @@ Open `src/Compute.js` from your `marketplace/` folder.
## Define Asset
First, let's add the [asset](/concepts/terminology/#asset-or-data-asset) that we want to publish.
First, let's add the data asset that we want to publish.
To do that, we need to define the Algorithm asset based on the [OEP-08](https://github.com/oceanprotocol/OEPs/tree/master/8) metadata structure. An algorithm asset can have multiple `files` attached to it and each file's `url` value will be encrypted during the publish process.

2
content/tutorials/react-publish-data-set.md
View File

@ -13,7 +13,7 @@ Open `src/index.js` from your `marketplace/` folder.
## Define Asset
First, let's add the [asset](/concepts/terminology/#asset-or-data-asset) that we want to publish.
First, let's add the asset that we want to publish.
To do that, we need to define the asset based on the [OEP-08](https://github.com/oceanprotocol/OEPs/tree/master/8) metadata structure. An asset can have multiple `files` attached to it and each file's `url` value will be encrypted during the publish process. To download that file later on, this value will be decrypted during the consume process.

28
content/tutorials/react-setup.md
View File

@ -1,6 +1,6 @@
---
title: React App Setup
description: This tutorial shows how you can build a basic [React](https://reactjs.org/) app with [Create React App](https://github.com/facebook/create-react-app) that uses the squid-js JavaScript package to publish a data set, get a data set, and more.
description: This tutorial shows how you can build a basic [React](https://reactjs.org/) app with [Create React App](https://github.com/facebook/create-react-app) that uses the Ocean [JavaScript driver](https://github.com/oceanprotocol/ocean.js) to publish a data set, get a data set, and more. *WARNING this has not been updated yet for Ocean V3.*
---
## Git repository and CodeSandbox
@ -43,7 +43,7 @@ First, create a new project folder for your new app, e.g. `marketplace`. Within
GITHUB-EMBED https://github.com/oceanprotocol/react-tutorial/blob/master/package.json json GITHUB-EMBED
Notice the `@oceanprotocol/squid` dependency, which is the [Ocean Protocol JavaScript library](https://github.com/oceanprotocol/squid-js). Save that file, and in your terminal install the dependencies we have just defined in `package.json`:
Notice the `@oceanprotocol/ocean.js` dependency, which is the [Ocean Protocol JavaScript library](https://github.com/oceanprotocol/ocean.js). Save that file, and in your terminal install the dependencies we have just defined in `package.json`:
```bash
npm install
@ -55,7 +55,7 @@ GITHUB-EMBED https://github.com/oceanprotocol/react-tutorial/blob/master/public/
## Add Basic Markup
Create a new folder `src/` and within that a `index.js` file with the following content as our base, where we already import squid-js and web3.js:
Create a new folder `src/` and within that a `index.js` file with the following content as our base, where we already import ocean.js and web3.js:
GITHUB-EMBED https://github.com/oceanprotocol/react-tutorial/blob/e639e9ed4432e8b72ca453d50ed7bdaa36f1efb4/src/index.js jsx 1-4,6,14,100-110,122-127 GITHUB-EMBED
@ -101,7 +101,7 @@ GITHUB-EMBED https://github.com/oceanprotocol/react-tutorial/blob/e639e9ed4432e8
This will initiate a connection to all Ocean components in Nile, load the contracts, and finally store the Ocean object in the local component state for reuse.
We also set the `verbose` option of squid-js so we better see what's going on.
We also set the `verbose` option of ocean.js so we better see what's going on.
## Final Result
@ -115,13 +115,9 @@ GITHUB-EMBED https://github.com/oceanprotocol/react-tutorial/blob/2765a7e6ae9a94
**Move on to [Publish a Data Set](/tutorials/react-publish-data-set/).**
## Bonus: Connect against local Spree network
## Bonus: Connect against local network
[_Spree_](https://docs.oceanprotocol.com/concepts/testnets/#a-spree-testnet-for-local-development), a local Ocean test network, can be used instead of remotely connecting to Nile. For this you first have to get up the Spree network by using [oceanprotocol/barge](https://github.com/oceanprotocol/barge).
### Run Spree with Barge
Clone the barge repository and use its startup script:
Instead of remotely connecting to Rinkeby, you can connect to your own [local network](concepts/network-local). It uses Ethereum Ganache plus Ocean Barge.
```bash
git clone https://github.com/oceanprotocol/barge.git
@ -130,19 +126,21 @@ cd barge/
./start_ocean.sh --no-commons
```
Note that compiling and deploying the contracts in your local Docker network takes some time so it can take a few minutes until the network is ready to be interacted with. That usually is the case once `keeper-contracts_1` container doesn't show any messages anymore.
Compiling and deploying the contracts in your local network may take a few minutes.
### Copy Contract Artifacts
At the end of the contract compiling and deploying you need to copy the resulting _Spree_ contract artifacts from the Docker container to your local `@oceanprotocol/keeper-contracts` dependency folder. The _keeper-contracts_ Docker container will output all artifacts in a hidden folder in your home folder so you can copy from there:
At the end of the contract compiling and deploying you need to copy the resulting contract artifacts from the Docker container to your local `@oceanprotocol/keeper-contracts` dependency folder. The _keeper-contracts_ Docker container will output all artifacts in a hidden folder in your home folder so you can copy from there:
```bash
cp ~/.ocean/keeper-contracts/artifacts/* ./node_modules/@oceanprotocol/keeper-contracts/artifacts/
```
### Get Spree Ether
### Get ETH for the local network
You will also need some [_Spree_ Ether](/tutorials/get-ether-and-ocean-tokens/#get-ether-for-a-local-spree-testnet) in your MetaMask account. You can execute this, replacing `<YOUR ADDRESS>` with your MetaMask account address:
You will also need some ETH for your local network. [This tutorial](/tutorials/get-ETH-and-OCEAN-tokens) describes how to get it into your MetaMask account.
You can execute this, replacing `<YOUR ADDRESS>` with your MetaMask account address:
```bash
curl --data '{"address": "<YOUR ADDRESS>", "agent": "curl"}' -H "Content-Type: application/json" -X POST http://localhost:3001/faucet
@ -150,7 +148,7 @@ curl --data '{"address": "<YOUR ADDRESS>", "agent": "curl"}' -H "Content-Type: a
### Adjust App Config
Finally, move back to your marketplace React app and modify the Ocean instance config in `src/index.js` to use the Spree endpoints:
Finally, move back to your marketplace React app and modify the Ocean instance config in `src/index.js` to use the local network's endpoints:
```jsx
const ocean = await new Ocean.getInstance({

2
content/tutorials/wallets-and-ocean-tokens.md
View File

@ -1,5 +1,5 @@
---
title: Use Your Wallet to Manage Ocean Tokens
title: Use Your Wallet to Manage OCEAN Tokens
description: How to use crypto wallet software to check your Ocean Token balance and to send Ocean Tokens to others.
---

93
data/repositories.yml
View File

@ -1,59 +1,25 @@
- group: Core Components
- group: Drivers
items:
- name: keeper-contracts
links:
- name: Documentation
url: https://github.com/oceanprotocol/keeper-contracts/tree/develop/doc
- name: ocean.js
- name: ocean.py
- name: react
- group: Smart Contracts
items:
- name: contracts
- group: Ocean Market
items:
- name: market
- group: Services
items:
- name: barge
- name: aquarius
links:
- name: API reference
url: /references/aquarius/
- name: brizo
links:
- name: API reference
url: /references/brizo/
- name: events-handler
- name: commons
- group: Libraries
items:
- name: squid-js
links:
- name: API reference
url: /references/squid-js/
- name: squid-py
links:
- name: API reference
url: https://squid-py.readthedocs.io/en/latest/
- name: squid-java
links:
- name: API reference
url: https://www.javadoc.io/doc/com.oceanprotocol/squid/
- group: Tools
items:
- name: barge
- name: tuna
- name: plecos
- name: faucet
- name: status
- name: blockscout
- name: ipfs
- group: OceanDB Drivers
items:
- name: oceandb-elasticsearch-driver
- name: oceandb-mongodb-driver
- name: oceandb-driver-interface
- group: Osmosis Drivers
items:
- name: osmosis-azure-driver
- name: osmosis-aws-driver
- name: osmosis-ipfs-driver
- name: osmosis-on-premise-driver
- name: provider
- group: Compute-to-Data
items:
@ -61,30 +27,3 @@
- name: operator-engine
- name: pod-configuration
- name: pod-publishing
- group: Parity Secret Store
items:
- name: parity-ethereum
- name: secret-store-client-js
links:
- name: Architecture
url: /concepts/secret-store/
- name: secret-store-client-py
links:
- name: Architecture
url: /concepts/secret-store/
- name: secret-store-client-java
links:
- name: Architecture
url: /concepts/secret-store/
- group: Project Management
items:
- name: OEPs
- name: ocean
links:
- name: Business Board
url: https://github.com/oceanprotocol/ocean/projects/1
- name: Research Board
url: https://github.com/oceanprotocol/ocean/projects/3
- name: dev-ocean

18
data/sections.yml
View File

@ -1,19 +1,19 @@
- title: Quickstart
description: Try out ocean.js, ocean.py or React drivers.
link: /concepts/quickstart/
color: blue
- title: Core Concepts
description: Understand the fundamentals of Ocean Protocol.
description: On Ocean architecture, network deployments, and more.
link: /concepts/introduction/
color: purple
- title: Setup Guides
description: Setting up the Ocean Protocol components.
link: /setup/quickstart/
color: blue
- title: Tutorials
description: Browse tutorials for most common setup and development use-cases.
description: Build an Ocean-powered React app, and more.
link: /tutorials/introduction/
color: orange
- title: API References
description: Get the references for REST APIs and library methods for all relevant components.
description: Interfaces for libraries and services.
link: /references/introduction/
color: green
color: blue

45
data/sidebars/concepts.yml
View File

@ -1,28 +1,23 @@
- group: Basics
items:
- title: Quickstart
link: /concepts/quickstart/
- title: Introduction
link: /concepts/introduction/
- title: Terminology
link: /concepts/terminology/
- title: Software Components
link: /concepts/components/
- title: Tools
link: /concepts/tools/
- title: Pacific Network
link: /concepts/pacific-network/
- title: Testnets
link: /concepts/testnets/
- title: Ocean Tokens
link: /concepts/ocean-tokens/
- title: Wallet Basics
link: /concepts/wallets/
- group: Architecture
items:
- title: Overview
- title: Architecture Overview
link: /concepts/architecture/
- title: Secret Store
link: /concepts/secret-store/
- group: Networks
items:
- title: Network - Local / Barge
link: /concepts/network-local/
- title: Network - Rinkeby Testnet
link: /concepts/network-rinkeby/
- title: Network - Ethereum Mainnet
link: /concepts/network-ethmainnet/
- group: Preserving Privacy
items:
- title: Compute-to-Data
link: /concepts/compute-to-data/
@ -30,18 +25,18 @@
items:
- title: Ways to Contribute
link: /concepts/contributing/
- title: Bounties
link: /concepts/bounties/
- title: Get Funding
link: /concepts/get-funding/
- title: Reporting Vulnerabilities
link: /concepts/vulnerabilities/
- title: Legal Requirements when Contributing Code
link: /concepts/legal-reqs/
- title: Engineering Principles
link: /concepts/principles/
- title: Code of Conduct
link: /concepts/code-of-conduct/
- group: Further Information
- group: Extras
items:
- title: Wallet Basics
link: /concepts/wallets/
- title: Resources
link: /concepts/resources/

39
data/sidebars/references.yml
View File

@ -3,27 +3,32 @@
- title: API References
link: /references/introduction/
- group: ocean.js
items:
- title: API Reference
link: https://github.com/oceanprotocol/ocean.js
- group: react
items:
- title: API Reference
link: https://github.com/oceanprotocol/react
- group: ocean.py
items:
- title: API Reference
link: https://github.com/oceanprotocol/ocean.py
- group: Smart Contracts
items:
- title: API Reference
link: https://github.com/oceanprotocol/ocean-contracts
- group: aquarius
items:
- title: API Reference
link: /references/aquarius/
- group: brizo
- group: provider-py
items:
- title: API Reference
link: /references/brizo/
- group: squid-js
items:
- title: API Reference
link: /references/squid-js/
- group: squid-py
items:
- title: API Reference
link: https://squid-py.readthedocs.io/en/latest/
- group: squid-java
items:
- title: API Reference
link: https://www.javadoc.io/doc/com.oceanprotocol/squid/
link: /references/provider-py/

14
data/sidebars/setup.yml
View File

@ -1,22 +1,8 @@
- group: Quickstart
items:
- title: Run & Try Everything
link: /setup/quickstart/
- group: Marketplaces
items:
- title: Set Up a Marketplace
link: /setup/marketplace/
- group: Publishers
items:
- title: Set Up a Publisher
link: /setup/publisher/
- group: Keepers
items:
- title: Run a Keeper
link: /setup/keeper/
- group: Compute-to-Data
items:
- title: Run a Compute-to-Data Environment

34
data/sidebars/tutorials.yml
View File

@ -5,25 +5,21 @@
- group: Wallets & Ocean Protocol
items:
- title: Set Up MetaMask
- title: Set Up MetaMask Wallet
link: /tutorials/metamask-setup/
- title: Use Your Wallet to Manage Ocean Tokens
- title: Use Your Wallet to Manage OCEAN Tokens
link: /tutorials/wallets-and-ocean-tokens/
- title: Get Ether and Ocean Tokens
- title: Get ETH and OCEAN Tokens
link: /tutorials/get-ether-and-ocean-tokens/
- title: Connect to Ocean-Related Networks
link: /tutorials/connect-to-networks/
- group: Storage Setup
- group: Marketplaces
items:
- title: Set Up Azure Storage
link: /tutorials/azure-for-brizo/
- title: Set Up Amazon S3 Storage
link: /tutorials/amazon-s3-for-brizo/
- title: Set Up On-Premise Storage
link: /tutorials/on-premise-for-brizo/
- title: Set Up a Marketplace
link: /tutorials/marketplace/
- group: React App Tutorial (squid-js)
- group: React App Tutorial
items:
- title: Setup
link: /tutorials/react-setup/
@ -42,12 +38,16 @@
- title: Get Status of a Compute Job
link: /tutorials/react-compute-status/
- group: squid-py Tutorials
- group: Compute-to-Data
items:
- title: Jupyter Notebooks
link: /tutorials/jupyter-notebooks/
- title: Run a Compute-to-Data Environment
link: /tutorials/compute-to-data/
- group: More Examples
- group: Storage Setup
items:
- title: Example Code Using Squid
link: /tutorials/example-code/
- title: Set Up Azure Storage
link: /tutorials/azure-for-brizo/
- title: Set Up Amazon S3 Storage
link: /tutorials/amazon-s3-for-brizo/
- title: Set Up On-Premise Storage
link: /tutorials/on-premise-for-brizo/

2
docs/content.md
View File

@ -99,7 +99,7 @@ Note: The `description` value will be rendered on-page below the title, and it w
1. Don't include the page title or description in the Markdown section. That is, don't begin the Markdown content with `# This is the Title in Title Case`. Just write as if that were already there.
2. start your heading levels with `h2`, so `## My heading`
3. Internal links to other docs pages should be:
- to a absolute URL without the host, that looks like `/concepts/terminology/` with slashes on the beginning and end, and with no `.md` or `.html` at the end (before the last slash).
- to a absolute URL without the host, that looks like `/concepts/introduction/` with slashes on the beginning and end, and with no `.md` or `.html` at the end (before the last slash).
- when linking from external repos, to the _full absolute URL_, such as `https://docs.oceanprotocol.com/hello/you-are-awesome/`
4. no TOC please, this will be generated automatically from all headings
5. for images and media, you can keep them in the original repo. Images will be automatically grabbed by the docs site on querying. When doing that, docs site will generate all sorts of image sizes to handle proper responsive images, so no need to keep an eye on image dimensions or file sizes

8
docs/repositories.md
View File

@ -23,7 +23,7 @@ Additional information about a repo will then be [fetched automatically from Git
This repository component can also be used within any Markdown content like so:
```html
<repo name="pleuston"></repo>
<repo name="ocean.js"></repo>
```
You can also add a private repo to prepare for a release, it will show up as soon as it is made public on GitHub.
@ -33,12 +33,10 @@ You can also add a private repo to prepare for a release, it will show up as soo
You can attach multiple links to a repo by attaching them to the respective repo in the [`/data/repositories.yml`](../data/repositories.yml) file:
```yaml
- name: keeper-contracts
- name: ocean-contracts
links:
- name: Documentation
url: https://github.com/oceanprotocol/keeper-contracts/tree/develop/doc
- name: TCR Owner's Manual
url: https://github.com/oceanprotocol/keeper-contracts/blob/develop/doc/owners_manual.md
url: https://github.com/oceanprotocol/ocean-contracts/tree/develop/doc
```
The GitHub link is automatically added for every repository and will always be displayed.

9
gatsby-node.js
View File

@ -208,27 +208,18 @@ const createTypeDocPage = async (createPage, name, downloadUrl) => {
// it generic for all TypeDoc specs
classes: [
'ocean/Ocean',
'ocean/OceanAccounts',
'ocean/OceanAssets',
'ocean/OceanAgreements',
'ocean/OceanAgreementsConditions',
'ocean/OceanCompute',
'ocean/OceanSecretStore',
'ocean/OceanVersions',
'ocean/Account',
'ocean/DID',
'ddo/DDO',
'ddo/Service',
'aquarius/Aquarius',
'brizo/Brizo',
'keeper/Keeper',
'keeper/ContractHandler',
'keeper/EventHandler',
'keeper/Web3Provider',
'models/Config',
'models/Balance',
'ocean/utils/OceanUtils',
'ocean/utils/ServiceAgreement',
'ocean/utils/WebServiceConnector',
'utils/Logger'
]

19
src/components/QuickRun.jsx
View File

@ -1,6 +1,5 @@
import React from 'react'
import { Link, StaticQuery, graphql } from 'gatsby'
import Repository from './Repository'
import styles from './QuickRun.module.scss'
const QuickRun = () => (
@ -19,23 +18,13 @@ const QuickRun = () => (
render={(data) => (
<aside className={styles.quickrun}>
<header className={styles.header}>
<h1 className={styles.tldr}>TL;DR</h1>
<h1 className={styles.tldr}>Quickstart</h1>
<strong>
Wanna quickly get an Ocean network with all{' '}
<Link to="/concepts/components/">core components</Link> running on
your machine?
The <Link to=".">ocean.js</Link>, <Link to=".">ocean.py</Link>, and{' '}
<Link to=".">Ocean React</Link> repos have quickstarts. Pick your
favorite and have fun!
</strong>
</header>
<div className={styles.docker}>
<div
dangerouslySetInnerHTML={{
__html: data.allMarkdownRemark.edges[0].node.html
}}
/>
<Repository name="barge" />
</div>
</aside>
)}
/>

11
src/components/Repositories/index.jsx
View File

@ -1,5 +1,5 @@
import React from 'react'
import { Link, StaticQuery, graphql } from 'gatsby'
import { StaticQuery, graphql } from 'gatsby'
import RepositoryList from './RepositoryList'
import styles from './index.module.scss'
@ -33,15 +33,6 @@ const Repositories = () => (
<div className={styles.repositories}>
<header>
<h1 className={styles.repositoriesTitle}>Repositories</h1>
<p className={styles.repositoriesText}>
<strong>
Most of our repositories are open source and we listed the key
repositories here. Start with the{' '}
<Link to="/concepts/components/">software components</Link>{' '}
document for an introduction to the components found in a
typical Ocean network.
</strong>
</p>
</header>
<RepositoryList repositories={repositories} />

3
src/pages/index.jsx
View File

@ -7,7 +7,6 @@ import Layout from '../components/Layout'
import Content from '../components/Content'
import HeaderHome from '../components/HeaderHome'
import Repositories from '../components/Repositories'
import QuickRun from '../components/QuickRun'
import { ReactComponent as Arrow } from '../images/arrow.svg'
import styles from './index.module.scss'
@ -70,8 +69,6 @@ const IndexPage = ({ data, location }) => (
))}
</ul>
<QuickRun />
<Repositories />
</Content>
</Layout>