From d21f119aba3df7cf60dd84ea5236e242f0180680 Mon Sep 17 00:00:00 2001 From: Albert Peci Date: Mon, 23 Sep 2024 10:15:42 +0200 Subject: [PATCH 1/3] docs: add ecosystem tutorial (WIP) --- .gitignore | 1 + pages/docs/tutorial/collaboration.mdx | 112 +++++++++++++++ pages/docs/tutorial/compliance.mdx | 122 +++++++++++++++++ pages/docs/tutorial/introduction.mdx | 46 +++++++ pages/docs/tutorial/monetization.mdx | 73 ++++++++++ pages/docs/tutorial/nautilus.mdx | 188 ++++++++++++++++++++++++++ sidebar.ts | 26 ++++ 7 files changed, 568 insertions(+) create mode 100644 pages/docs/tutorial/collaboration.mdx create mode 100644 pages/docs/tutorial/compliance.mdx create mode 100644 pages/docs/tutorial/introduction.mdx create mode 100644 pages/docs/tutorial/monetization.mdx create mode 100644 pages/docs/tutorial/nautilus.mdx diff --git a/.gitignore b/.gitignore index 03251d5..a14f2f1 100644 --- a/.gitignore +++ b/.gitignore @@ -8,3 +8,4 @@ dist tsconfig*.tsbuildinfo .vercel +.zed/ diff --git a/pages/docs/tutorial/collaboration.mdx b/pages/docs/tutorial/collaboration.mdx new file mode 100644 index 0000000..793e8aa --- /dev/null +++ b/pages/docs/tutorial/collaboration.mdx @@ -0,0 +1,112 @@ +# Lesson 4: Collaboration Across Industries + +In this lesson, we will explore the power of collaboration within the Pontus-X ecosystem, where industries can securely share and utilize data across various sectors. Collaboration is the backbone of the decentralized data economy, enabling industries such as manufacturing, AI, healthcare, and mobility to create innovative solutions and unlock new business opportunities. + +By the end of this lesson, you will understand how to: +- Facilitate cross-industry collaboration using Nautilus. +- Leverage decentralized data spaces to share and consume data across sectors. +- Use Pontus-X to develop joint AI and data-driven solutions that benefit multiple industries. + + +## Why Cross-Industry Collaboration Matters + +In today’s digital economy, industries are increasingly interconnected. Data from one sector, such as healthcare, can have a profound impact when applied to another, like AI or manufacturing. However, traditional data sharing is often limited by concerns about privacy, intellectual property, and the security of sensitive information. + +The Pontus-X ecosystem, with its decentralized and federated structure, offers a solution by providing a secure, transparent, and privacy-compliant platform for cross-sector collaboration. Through Pontus-X, industries can share data assets and AI models, enabling them to: +- Accelerate innovation by pooling resources and expertise from different fields. +- Reduce costs by leveraging shared data and infrastructure. +- Unlock new market opportunities by developing joint solutions tailored to multiple industries. + +## Facilitating Cross-Industry Collaboration Using Nautilus + +Nautilus makes it easy to collaborate across industries by enabling secure data sharing and seamless interaction between different data spaces. Let’s go through how you can set up collaborative projects in Pontus-X. + +### **Step 1: Publishing Shared Assets** + +When publishing data assets in **Pontus-X**, you can configure them for shared access across different industries. For example, you might publish a dataset that is useful for both healthcare and AI sectors, such as a medical imaging dataset that can be used for AI training. + +### **Step 2: Setting Up Collaborative Access Permissions** + +**Nautilus** allows you to set up specific access permissions to enable collaboration between industries. For example, you may choose to provide free access to universities while offering paid access to private companies. + +```typescript +const service = serviceBuilder.setPricing({ type: "free" }) +``` + +This flexibility enables institutions, businesses, and researchers to collaborate on the same dataset with tailored access depending on their role in the ecosystem. + + +## Leveraging Decentralized Data Spaces for Collaboration + +**Pontus-X** operates across **decentralized data spaces**, meaning different organizations can maintain their own data spaces while still sharing and consuming data within the larger ecosystem. This makes cross-sector collaboration more efficient, as each industry can maintain control over its data while accessing shared resources from other sectors. + +### Step 1: Accessing Data from Other Sectors + +Let’s assume you are a company in the manufacturing industry, but you want to access data from the mobility sector to optimize your production process with real-time traffic data. + +Using a Pontus-XPortal, you can search for and consume data from other industries, such as mobility or AI: [Pontus-X Portal](https://portal.pontus-x.eu/search?sort=nft.created&sortOrder=desc) + +Once you find a relevant dataset, you can request access just like with any other data asset. + +```typescript +const assetDid = 'did:op:mobility_data_did'; +const mobilityData = await nautilus.access({ assetDid }); +console.log('Accessed mobility data:', mobilityData); +``` + +Now you can combine this data with your own manufacturing data to develop a solution that optimizes production based on traffic patterns. + +### Step 2: Cross-Sector Compute-to-Data Jobs + +Compute-to-Data enables secure collaboration by allowing industries to perform computations on shared data without accessing the raw data itself. This is particularly useful for industries like healthcare and AI, where sensitive data needs to be processed while maintaining strict privacy controls. + +For instance, if a healthcare company wants to collaborate with an AI provider to develop a diagnostic model, they can share their medical data without exposing it. + +```typescript +const computeJob = await nautilus.compute({ + did: 'did:op:healthcare_data_did', + did: 'did:op:ai_model_did', +}); + +const { jobId } = computeJob + +const computeJobStatus = await nautilus.getComputeStatus({ + jobId, // using our extracted jobId + providerUri: 'https://v4.provider.oceanprotocol.com/' +}) + +console.log('Compute job status:', computeJobStatus); +``` +The AI company can run computations on the healthcare data to develop an AI model, but the healthcare company retains full control over its sensitive information. + +## Developing Joint Solutions Across Industries + +Collaboration within Pontus-X allows industries to develop joint solutions that benefit from the expertise and data of multiple sectors. Let’s explore a real-world example of how this works: + +Example: Healthcare and Mobility Collaboration +In this scenario, a mobility company wants to integrate healthcare data into its services to develop a smart ambulance routing system. This system uses real-time traffic data from the mobility company and patient data from healthcare providers to optimize ambulance routes during emergencies. + +### Step 1: Access Mobility Data + The healthcare provider can consume traffic data from the mobility company through **Nautilus**: + ```typescript + const trafficData = await nautilus.access({ assetDid: 'did:op:traffic_data_did' }); + ``` + +### Step 2: Compute Healthcare Data + The mobility company can securely process the healthcare data without accessing it directly: + ```typescript + const computeJob = await nautilus.compute({ + did: 'did:op:healthcare_data_did', + did: 'did:op:ai_model_did', + }); + ``` + +### Step 3: Joint Solution Deployment +The result is a smart ambulance routing solution that combines the best of both industries—real-time traffic data and patient healthcare information—to save lives in emergencies. + + +## Conclusion + +Collaboration across industries is one of the most powerful features of the Pontus-X ecosystem. By using Nautilus, you can securely share and consume data from various sectors, develop joint solutions, and unlock new business opportunities that would not be possible in traditional siloed data environments. + +In the next lesson, we will explore advanced privacy and compliance features within the Pontus-X ecosystem, focusing on how to ensure data sovereignty and meet regulatory requirements when sharing sensitive data. diff --git a/pages/docs/tutorial/compliance.mdx b/pages/docs/tutorial/compliance.mdx new file mode 100644 index 0000000..7e8a678 --- /dev/null +++ b/pages/docs/tutorial/compliance.mdx @@ -0,0 +1,122 @@ +# Lesson 5: Ensuring Privacy and Compliance + +Welcome to the final lesson of the Pontus-X Educational Campaign! In this session, we will focus on one of the most critical aspects of decentralized data sharing and monetization: privacy, security, and compliance. By understanding and leveraging the built-in protections of the Pontus-X ecosystem, you can confidently share and monetize data while adhering to regulations like GDPR and ensuring the sovereignty of your assets. + +By the end of this lesson, you will be able to: + +- Understand the Gaia-X Trust Framework and its importance for compliance. +- Use Compute-to-Data to ensure privacy during data processing. +- Apply best practices for data security in the Pontus-X ecosystem. +- Set up privacy-preserving access controls using Nautilus. + +## The Gaia-X Trust Framework + +The Gaia-X Trust Framework forms the backbone of the Pontus-X ecosystem, ensuring that all data transactions, services, and interactions adhere to stringent European standards for data sovereignty, privacy, and transparency. This framework provides the legal and technical guidelines necessary for organizations to securely share and consume data without losing control over their assets or violating compliance regulations like GDPR. + +**Key Principles of the Gaia-X Trust Framework**: + +- **Data Sovereignty**: Each organization retains full control over how their data is used, shared, and monetized. +- **Transparency**: All transactions and data exchanges are fully transparent, building trust among ecosystem participants. +- **Security**: Robust encryption, secure data storage, and privacy-preserving technologies protect sensitive information. +- **Compliance**: The framework ensures that data sharing within Pontus-X adheres to GDPR and other regulatory requirements. + +The Pontus-X ecosystem fully integrates the Gaia-X Trust Framework, making it a trusted platform for businesses to share and monetize data while complying with regulatory obligations. + +## Ensuring Privacy Through Compute-to-Data + +One of the most innovative privacy features within the Pontus-X ecosystem is Compute-to-Data. This technology allows you to provide access to data for computational purposes without sharing the raw data itself. It ensures that your sensitive data never leaves your control, yet it can still be used to power valuable AI models and analyses . + +**How Compute-to-Data Protects Privacy**: + +- **Data remains in its original location** and is processed locally, avoiding the risk of exposure during transmission. +- **Users can only access the results** of computations performed on the data, not the data itself. +- **Granular access control** allows you to decide who can run compute jobs and what algorithms they can use. + +**Example: Running a Compute Job on Sensitive Healthcare Data** + +Here’s an example of how you can allow an AI company to train a model on sensitive healthcare data without exposing the raw data: + +```typescript +const computeJob = await nautilus.compute({ + {did: 'did:op:sensitive_healthcare_data_did'}, // dataset, + {did: 'did:op:ai_training_algorithm_did' } //algorithm +}) + +console.log('Compute job result:', computeJob); +``` + +The AI company receives the trained model but never gains access to the underlying healthcare data, ensuring complete privacy while still enabling collaboration. + +## Best Practices for Data Security in Pontus-X + +The Pontus-X ecosystem provides several layers of data security to protect your assets, whether you are publishing, sharing, or consuming data. By following best practices, you can ensure that your data remains secure at every stage of the data lifecycle. + +### Encryption + +All data assets published and shared in Pontus-X are encrypted, both in transit and at rest. Nautilus automatically handles encryption, but you should also ensure that any sensitive data is encrypted before it is uploaded. + +### Access Controls + +Setting granular access controls ensures that only authorized users can access or compute on your data. This is critical for maintaining security, particularly when dealing with sensitive or proprietary information. + +You can configure access permissions with Nautilus to restrict data to specific users or organizations. + +```typescript +const assetBuilder =new AssetBuilder() + +assetBuilder.addCredentialAddresses(CredentialListTypes.ALLOW, [ + '0x0000000000000000000000000000000000000000' // add your address here to allow it +]) +const asset = assetBuilder.build() + +await nautilus.publish(asset) +``` + +await nautilus.setAccessPermissions(publishedAsset.id, restrictedAccess); + +This ensures that only trusted parties can interact with your data in ways you’ve explicitly allowed. + +### Identity Management + +The Pontus-X ecosystem uses decentralized identity mechanisms to ensure that all participants are verified and that their actions can be traced transparently. Each participant has a Decentralized Identifier (DID), which provides a secure way to verify identities without relying on central authorities. + +## Meeting Compliance Requirements with Pontus-X + +Compliance with regulations like GDPR is essential for organizations handling sensitive data, especially in sectors like healthcare, finance, and AI. Pontus-X ensures that all data exchanges are compliant with European standards for data protection. + +### GDPR Compliance in Pontus-X + +- Data Minimization: Only the necessary data is shared or processed, reducing the risk of overexposure. +- Purpose Limitation: Data can only be used for the specific purposes agreed upon by the data provider and consumer. +- Data Subject Rights: Participants in Pontus-X retain full control over their personal data and can exercise rights like access, rectification, and erasure. + +### Example: Handling Data Subject Requests + +In Pontus-X, you can track how your data is being used and respond to requests for data deletion or updates, ensuring GDPR compliance. + +This process ensures that personal data is handled in accordance with privacy laws and can be modified or deleted as needed. + +## Privacy-Preserving Access Controls with Nautilus + +One of the key features of Nautilus is the ability to implement privacy-preserving access controls, ensuring that only the right users can access your data and that they only use it in ways you’ve approved. + +**Set Up Role-Based Access** + +You can restrict access based on the role of the user (e.g., researcher, company, or public user). Here’s how you can implement role-based access with Nautilus: + +```typescript +const assetBuilder =new AssetBuilder() + +assetBuilder.addCredentialAddresses(CredentialListTypes.ALLOW, [ + '0x0000000000000000000000000000000000000000' // add your address here to allow it +]) +const asset = assetBuilder.build() + +await nautilus.publish(asset) +``` + + +## Conclusion +Privacy, security, and compliance are crucial components of the Pontus-X ecosystem. By following the best practices outlined in this lesson, you can confidently share and monetize your data while ensuring it remains protected and compliant with regulations like GDPR. Whether through Compute-to-Data, robust encryption, or granular access controls, Nautilus offers the tools you need to safeguard your data in the decentralized economy. + +This concludes the Pontus-X Educational Campaign! You’ve learned how to publish, consume, monetize, collaborate, and protect your data within the Pontus-X ecosystem using Nautilus. Now, you’re ready to fully engage in the data economy of the future. diff --git a/pages/docs/tutorial/introduction.mdx b/pages/docs/tutorial/introduction.mdx new file mode 100644 index 0000000..c8a5470 --- /dev/null +++ b/pages/docs/tutorial/introduction.mdx @@ -0,0 +1,46 @@ +# Lesson 1: Introduction to Pontus-X Ecosystem + +Welcome to the first lesson of the **Pontus-X Educational Campaign**. In this lesson, we will explore the core components, vision, and significance of the **Pontus-X ecosystem**, a groundbreaking platform for decentralized data management and monetization, built on **Gaia-X** principles and designed to meet the needs of today’s data-driven industries. + +## What is Pontus-X? + +**Pontus-X** is a decentralized digital ecosystem that enables organizations to **consume, offer, and monetize data, AI products, and digital services** in a trusted, secure, and transparent environment. It is built on the principles of data sovereignty and privacy, ensuring that companies maintain control over their data, even when sharing or monetizing it. + +The system is designed to: + +- **Foster collaboration** between industries, institutions, and individuals by enabling data sharing across different sectors. +- **Empower businesses** to monetize their data without losing control over their intellectual property. +- Ensure **GDPR compliance** and **privacy protection** through advanced technologies like **Compute-to-Data**, which allows data processing without moving sensitive information. + +By leveraging the **Pontus-X ecosystem**, companies can unlock new revenue streams from their digital assets while adhering to the highest standards of data protection and transparency. + +## Key Components of Pontus-X Ecosystem + +1. **Data Sovereignty**: Data sovereignty is a core principle of Pontus-X. It ensures that data providers retain full control over how their data is used, shared, and processed. **Data is managed locally**, within the jurisdiction of the data provider, using technologies like Compute-to-Data, which allows for secure, local processing of data while maintaining privacy. + +2. **Decentralized and Federated Network**: Pontus-X operates in a decentralized manner, meaning there is no central authority controlling the network. Instead, it uses a **federated model**, where different members of the network (federators) contribute to its infrastructure and validate transactions. This creates a more transparent and trusted environment for data exchange across industries. + +3. **Gaia-X Trust Framework**: Pontus-X is aligned with the **Gaia-X Trust Framework**, which provides the guidelines for **data sovereignty, privacy, and compliance** within the European Union. Gaia-X is key to ensuring that the data shared and processed on the Pontus-X network meets the highest standards for data protection. + +4. **Open Ecosystem and Collaboration**: Pontus-X is designed to be **domain-agnostic**, meaning it can be used by any industry, from aerospace and AI to healthcare and mobility. This allows companies from different sectors to collaborate, share data, and access services in an **open, decentralized marketplace**. + +## Why Pontus-X Matters + +The European data economy is set to grow rapidly, with the projected market size reaching **€829 billion by 2025**. As data becomes an increasingly valuable asset, businesses need a way to share and monetize data securely and transparently. **Pontus-X** addresses the critical challenges of data sovereignty, intellectual property protection, and GDPR compliance, allowing companies to unlock the full potential of their data. + +## Pontus-X in Action: Key Use Cases + +1. **AI and Data-Driven Solutions**: Companies can leverage Pontus-X to create and deploy AI models and data-driven applications without compromising data security. By using tools like Compute-to-Data, AI solutions can be developed with secure access to sensitive data, ensuring compliance with privacy laws. +2. **Cross-Sector Collaboration**: Pontus-X enables seamless data sharing across different industries and data spaces. For example, manufacturers can collaborate with AI providers or mobility companies to create innovative data-driven services, unlocking new revenue streams. +3. **Monetizing Data and AI Products**: One of the most significant advantages of Pontus-X is its ability to allow companies to monetize their data assets. Organizations can offer data, AI models, and software as services on the Pontus-X marketplace, opening up new opportunities for growth. + +## How You Can Benefit from Pontus-X + +- **For Data Professionals**: Learn how to manage and monetize data in a decentralized ecosystem, ensuring compliance and control. +- **For Business Leaders**: Discover how Pontus-X can unlock new business models and revenue streams, while keeping data secure. +- **For Developers**: Explore the tools available within the Pontus-X ecosystem, like Nautilus, to build and manage decentralized data pipelines and services. +- **For Researchers**: Understand how Pontus-X can facilitate cross-border research collaborations without compromising sensitive data. + +## Next Steps + +In the next lesson, we will dive deeper into the **Nautilus toolkit**, an essential tool within the **Pontus-X** ecosystem that simplifies data management and enables businesses to connect with decentralized data spaces effortlessly. diff --git a/pages/docs/tutorial/monetization.mdx b/pages/docs/tutorial/monetization.mdx new file mode 100644 index 0000000..ff700d3 --- /dev/null +++ b/pages/docs/tutorial/monetization.mdx @@ -0,0 +1,73 @@ +# Lesson 3: Monetizing Your Data and AI Products + +In this lesson, we will focus on the exciting possibilities of **monetizing data and AI products** in the Pontus-X ecosystem. By the end of this session, you will understand how to use Nautilus to create flexible monetization models, secure your intellectual property, and maximize the value of your assets through decentralized networks. + +## Why Monetize Data and AI in Pontus-X? + +The **Pontus-X** ecosystem provides businesses, developers, and data professionals with a powerful platform to monetize their data assets and AI services. Monetization opportunities are made more attractive because of the network’s decentralized nature, where **data sovereignty** and **privacy** are maintained, and assets can be securely shared and accessed across industries. + +Monetization within **Pontus-X** can take several forms, including: +- **Selling data access** with flexible pricing models (e.g., one-time access, subscription-based models). +- **Offering compute services** through Compute-to-Data, allowing customers to run computations on your data without ever downloading or accessing it directly. +- **Providing AI models** as a service, where other organizations can utilize pre-trained models for their business needs. + + +## Flexible Monetization Models + +Nautilus enables you to create multiple ways to monetize your data and AI assets, giving you the flexibility to match your business model to market demands. + +### Model 1: One-Time Purchase +This model is ideal if you want to offer **single-use access** to your data assets, allowing customers to pay once and retrieve the data. + +In this setup, users will be able to access and download your dataset after completing a one-time payment. More details in the [Nautilus docs](https://nautilus.delta-dao.com/docs/api/nautilus/setServicePrice). + +### Model 2: Subscription-Based Access (WIP) +Subscription models allow for ongoing access to your data over a specific period, making it perfect for regularly updated datasets or continuous services like APIs or AI models. + +This ensures that customers pay periodically, making it easier to create a recurring revenue stream for your data services. + +### Model 3: Pay-Per-Compute +This model uses **Compute-to-Data**, which allows users to run computations on your data without ever moving the data itself. This is particularly useful for sensitive datasets where data privacy is critical. + +Customers pay to use your data for computations (e.g., training a machine learning model), but they never gain direct access to the raw data, ensuring security and compliance with privacy regulations. + + +## Protecting Intellectual Property + +A major concern when monetizing data and AI is the risk of losing control over your assets. Pontus-X addresses this through advanced privacy features, including **Compute-to-Data** and **granular access controls**. + +### Compute-to-Data: Securing Sensitive Data +With **Compute-to-Data**, you can offer data for analysis without sharing the raw data itself. This ensures that your intellectual property is protected while allowing others to benefit from your data in a secure, privacy-compliant manner. + +Example: +```typescript +const dataset = { + did: 'did:op:123abc...' +} +const algorithm = { + did: 'did:op:123abc...' +} + +const computeJob = await nautilus.compute({ + dataset, + algorithm +}) + +console.log('Compute job:', computeJob); +``` + +With this feature, customers can run their computations, such as training AI models, but they only receive the results, not the original data. + + +## Maximizing the Value of Your Data and AI + +To maximize the value of your assets within Pontus-X, it’s important to take a strategic approach to monetization: +- **Diversify access models**: Offer one-time purchases, subscription access, and pay-per-compute options to cater to different customer needs. +- **Leverage cross-industry collaborations**: Work with partners from other industries to expand your reach and unlock new opportunities for data-driven solutions. +- **Bundle data and AI services**: Create packages where customers can access both datasets and AI models, offering a comprehensive solution for their needs. + +## Conclusion + +Monetizing data and AI products in the Pontus-X ecosystem offers immense potential for businesses, developers, and data professionals. By using Nautilus to set up flexible access models, protect your intellectual property, and maximize the value of your assets, you can unlock new revenue streams while maintaining full control over your data. + +In the next lesson, we will explore advanced techniques for collaboration across industries, focusing on how different sectors can leverage the Pontus-X ecosystem to build innovative, data-driven solutions. diff --git a/pages/docs/tutorial/nautilus.mdx b/pages/docs/tutorial/nautilus.mdx new file mode 100644 index 0000000..31143b4 --- /dev/null +++ b/pages/docs/tutorial/nautilus.mdx @@ -0,0 +1,188 @@ +# Lesson 2: Learn Nautilus – Publishing, Consuming, and Downloading Data Assets + +In this session, we’ll dive into **Nautilus**, the essential toolkit for managing decentralized data pipelines. This course will focus on **publishing, consuming, and downloading data assets** within the **Pontus-X** ecosystem, providing you with a comprehensive guide to using Nautilus in real-world applications. + +By the end of this lesson, you'll be able to: +- Publish datasets to the Pontus-X networks. +- Consume and retrieve data assets. +- Download and use data from decentralized sources. + +## What is Nautilus? +**Nautilus** is a TypeScript toolkit specifically designed for the **data economy**. It serves as an **abstraction layer** over decentralized data infrastructure, allowing users to create, manage, and interact with data pipelines in a more intuitive and accessible way. It is a powerful tool for those looking to **publish, access, and monetize data services** in the **Pontus-X** ecosystem. + +Whether you are publishing a dataset, executing a compute job, or managing access to data, Nautilus streamlines these processes by providing easy-to-use APIs and features that are flexible enough to adapt to different use cases. + +## Key Features of Nautilus + +**Publishing and Managing Data Assets** +- Nautilus makes it simple to publish datasets, APIs, and algorithms on the Pontus-X marketplace. Once published, you can manage your data assets by editing, updating, or removing them as needed. +- Users can offer different access types (e.g., subscription, one-time purchase) for their data assets, creating flexible monetization models. +- Hands-on Example: Walkthrough of publishing a dataset and setting access parameters. + +**Triggering and Managing Compute Jobs** +- One of the standout features of Nautilus is its support for Compute-to-Data. This feature allows you to execute compute jobs on data without moving the data itself, ensuring privacy and security. +- Nautilus also supports monitoring compute job status and retrieving the results, providing end-to-end control over data processing tasks. +- Hands-on Example: Demonstrate how to trigger a compute job and retrieve the results using Nautilus. + +**Accessing Data from Decentralized Spaces** +- Nautilus allows you to consume data services offered by others within the Pontus-X ecosystem. Whether you are accessing datasets, APIs, or compute services, the toolkit makes it easy to discover and use the resources you need. +- With typed APIs and full TypeScript support, Nautilus ensures that you have reliable, clear interfaces for interacting with the data economy. +- Hands-on Example: Demonstrate accessing a dataset or API offered by another participant in the Pontus-X ecosystem. + +**Custom Network Configurations** +- One of the key strengths of Nautilus is its flexibility. You can customize your connections to different networks and components within Pontus-X to meet your specific needs. +- This allows businesses and developers to seamlessly integrate Nautilus into their existing infrastructures and workflows. +- Hands-on Example: Guide through setting up a custom network configuration for a specific business use case. + +**Cross-Network Collaboration** +- Nautilus supports interactions across different data spaces, allowing for collaboration between industries, institutions, and partners. By offering seamless cross-network functionality, it opens up opportunities for multi-sector collaboration. + +## Why Use Nautilus? + +1. **Ease of Use**: Nautilus abstracts the complexity of decentralized data management, making it accessible even to users with limited experience in blockchain or decentralized technologies. +2. **Data Sovereignty**: It allows you to maintain control over your data assets while still participating in a decentralized marketplace. +3. **Flexible Monetization**: By using Nautilus, businesses can explore various ways to monetize their data, from one-time sales to subscription-based models. + +## Setting Up Your Environment + +Before diving into the practical steps, let’s ensure your environment is set up correctly: + +1. **Install Nautilus:** + Make sure you have **Node.js** installed. Then, run the following command to install Nautilus: + ```bash + npm install @deltadao/nautilus + ``` + +2. **Set Up Dependencies:** + Import the required modules: + ```typescript + import { Nautilus } from '@deltadao/nautilus'; + import { Wallet, providers } from 'ethers'; + ``` + +3. **Configure Your Client:** + Create a connection to the **Pontus-X** network by setting up the client with a JSON RPC provider: + ```typescript + const provider = new providers.JsonRpcProvider('https://rpc.dev.pontus-x.eu'); + const signer = new Wallet('0xYourPrivateKey', provider); + const nautilus = await Nautilus.create(signer); + ``` + +## Publishing Data Assets + +Publishing a data asset on Pontus-X allows you to share and potentially monetize your datasets or services. Let’s go step-by-step through the publishing process. + +### Step 1: Define Your Asset +First, prepare your data or API that you want to publish. This can be a dataset, an API, or an algorithm. + +### Step 2: Publish the Asset Using Nautilus +With **Nautilus**, publishing an asset is straightforward. Use the following code snippet to publish your dataset: + +```typescript +const serviceBuilder = new ServiceBuilder({ + serviceType: ServiceTypes.ACCESS, + fileType: FileTypes.URL, +}); + +const urlFile: UrlFile = { + type: "url", + url: "https://raw.githubusercontent.com/Pontus-X/.github/main/profile/README.md", + method: "GET", +}; + +const service = serviceBuilder + .setServiceEndpoint(devnet.providerUri) + .setTimeout(60) + .addFile(urlFile) + .setPricing({ type: "free" }) + .setDatatokenNameAndSymbol("Test Presentation", "TST") + .build(); + +const assetbuilder = new AssetBuilder(); +const asset = assetbuilder + .setType("dataset") + .setName("13:24 Nautilus Example") + .setDescription("Nautilus Example") + .setAuthor("deltaDAO AG") + .setLicense("MIT") + .addService(service) + .setOwner("0xFB7Cb9F2E15F3935B22FB9846d69b46bD31edf07") // YOUR ADDRESS + .build(); + +const result = await nautilus.publish(asset); +console.log(result); +console.log('Published asset:', publishedAsset); +``` + +### Step 3: Set Access Permissions +You can configure how other users can access your data. **Nautilus** allows you to set various types of permissions, such as free access, paid access, or restricted access. For example, to allow free access, use: + +```typescript +const service = serviceBuilder.setPricing({ type: "free" }) +``` + +## Consuming Data Assets + +Once a dataset or service is published on the Pontus-X network, other users can access it. Here’s how you can consume a data asset using Nautilus. + +### Step 1: Search for Available Assets +You can search for available datasets using the [Pontus-X marketplace](https://portal.pontus-x.eu/search?sort=nft.created&sortOrder=desc) + +### Step 2: Consume a Dataset +Once you find a dataset you want to consume, you can request access to it. You’ll need the **DID** (Decentralized Identifier) of the asset: + +```typescript +const did = 'did:op:3cccb2963b99120426249b11f7b911526533237509cfad8e9671813a7adb2cec'; +const consumedDataUrl = await nautilus.access({ assetDid: did }); +console.log('Consumed data:', consumedDataUrl); +``` + +Once the transaction is complete, you’ll be able to access and use the data. + + +## Downloading Data Assets + +After accessing a dataset, you may want to download it for local analysis or other purposes. + +### Step 1: Request Download +Once you have access to a dataset, **Nautilus** allows you to download the files associated with the asset: + +```typescript +const fetch = require('node-fetch'); +const fs = require('fs'); + +async function downloadData(url, destination) { + const response = await fetch(url); + const fileStream = fs.createWriteStream(destination); + return new Promise((resolve, reject) => { + response.body.pipe(fileStream); + response.body.on('error', reject); + fileStream.on('finish', resolve); + }); +} +``` + +### Step 2: Save the Data Locally +You can save the downloaded data to your local machine for further use: + +```typescript +const url = 'https://example.com/data.json'; // Replace with the actual URL from the previous step +const destination = 'data.json'; // Specify the path where the file should be saved and make sure file extension is correct + +downloadData(url, destination) + .then(() => console.log('Download completed!')) + .catch((err) => console.error('Error downloading file: ', err)); +``` + +Now you have the data locally, and you can use it for analysis, machine learning, or any other project. + +## Conclusion + +You’ve now learned how to: +- Publish datasets on the Pontus-X network. +- Consume and access decentralized data assets. +- Download and manage data from the network for local use. + +By mastering these skills, you can fully participate in the Pontus-X data economy, offering and consuming valuable datasets and services while maintaining control over your assets. + +In the next lesson, we will explore how to monetize your data and AI products within the Pontus-X marketplace, and take a deeper dive into cross-industry collaboration and data sharing. diff --git a/sidebar.ts b/sidebar.ts index 3598639..7173ccb 100644 --- a/sidebar.ts +++ b/sidebar.ts @@ -43,6 +43,32 @@ export const sidebar = { }, ], }, + { + text: "Ecosystem Tutorial", + collapsed: true, + items: [ + { + text: "Lesson 1: Introduction to Pontus-X Ecosystem", + link: "/docs/tutorial/introduction", + }, + { + text: "Lesson 2: Learn Nautilus", + link: "/docs/tutorial/nautilus", + }, + { + text: "Lesson 3: Monetizing Your Data and AI Products ", + link: "/docs/tutorial/monetization", + }, + { + text: "Lesson 4: Collaboration Across Industries", + link: "/docs/tutorial/collaboration", + }, + { + text: "Lesson 5: Ensuring Privacy and Compliance", + link: "/docs/tutorial/compliance", + }, + ], + }, { text: "Participants & Federators", collapsed: true, From 6a93a69082dc7f25f397b26e0ebd46b32a8eeeb3 Mon Sep 17 00:00:00 2001 From: Albert Peci Date: Mon, 23 Sep 2024 10:20:47 +0200 Subject: [PATCH 2/3] chore(sidebar): remove whitespace --- sidebar.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sidebar.ts b/sidebar.ts index 7173ccb..ce53428 100644 --- a/sidebar.ts +++ b/sidebar.ts @@ -56,7 +56,7 @@ export const sidebar = { link: "/docs/tutorial/nautilus", }, { - text: "Lesson 3: Monetizing Your Data and AI Products ", + text: "Lesson 3: Monetizing Your Data and AI Products", link: "/docs/tutorial/monetization", }, { From 4df9eaa6590817d064809a836fe2adef90068aa2 Mon Sep 17 00:00:00 2001 From: Albert Peci Date: Thu, 26 Sep 2024 09:32:01 +0200 Subject: [PATCH 3/3] refactor(tutorial): update content --- pages/docs/tutorial/introduction.mdx | 8 ++++---- pages/docs/tutorial/nautilus.mdx | 22 ++++------------------ 2 files changed, 8 insertions(+), 22 deletions(-) diff --git a/pages/docs/tutorial/introduction.mdx b/pages/docs/tutorial/introduction.mdx index c8a5470..7c28b80 100644 --- a/pages/docs/tutorial/introduction.mdx +++ b/pages/docs/tutorial/introduction.mdx @@ -1,18 +1,18 @@ # Lesson 1: Introduction to Pontus-X Ecosystem -Welcome to the first lesson of the **Pontus-X Educational Campaign**. In this lesson, we will explore the core components, vision, and significance of the **Pontus-X ecosystem**, a groundbreaking platform for decentralized data management and monetization, built on **Gaia-X** principles and designed to meet the needs of today’s data-driven industries. +Welcome to the first lesson of the **Pontus-X Educational Campaign**. In this lesson, we will explore the core components, vision, and significance of the **Pontus-X ecosystem**, a groundbreaking paradigm for decentralized data management and monetization, built on **Gaia-X** principles and designed to meet the needs of today’s data-driven industries. ## What is Pontus-X? -**Pontus-X** is a decentralized digital ecosystem that enables organizations to **consume, offer, and monetize data, AI products, and digital services** in a trusted, secure, and transparent environment. It is built on the principles of data sovereignty and privacy, ensuring that companies maintain control over their data, even when sharing or monetizing it. +**Pontus-X** is a decentralized digital ecosystem that enables organizations to **consume, offer, and monetize data, AI products, and digital services** in a trusted, secure, and transparent environment. It is built on the principles of data sovereignty and privacy, ensuring that data owners maintain control over their data, even when sharing or monetizing it. The system is designed to: -- **Foster collaboration** between industries, institutions, and individuals by enabling data sharing across different sectors. +- **Foster collaboration** between industries, institutions, and individual companies by enabling data sharing across different sectors. - **Empower businesses** to monetize their data without losing control over their intellectual property. - Ensure **GDPR compliance** and **privacy protection** through advanced technologies like **Compute-to-Data**, which allows data processing without moving sensitive information. -By leveraging the **Pontus-X ecosystem**, companies can unlock new revenue streams from their digital assets while adhering to the highest standards of data protection and transparency. +By leveraging the **Pontus-X ecosystem**, data owners can unlock new revenue streams from their digital assets while adhering to the highest standards of data protection and transparency. ## Key Components of Pontus-X Ecosystem diff --git a/pages/docs/tutorial/nautilus.mdx b/pages/docs/tutorial/nautilus.mdx index 31143b4..5d10d5c 100644 --- a/pages/docs/tutorial/nautilus.mdx +++ b/pages/docs/tutorial/nautilus.mdx @@ -1,11 +1,6 @@ # Lesson 2: Learn Nautilus – Publishing, Consuming, and Downloading Data Assets -In this session, we’ll dive into **Nautilus**, the essential toolkit for managing decentralized data pipelines. This course will focus on **publishing, consuming, and downloading data assets** within the **Pontus-X** ecosystem, providing you with a comprehensive guide to using Nautilus in real-world applications. - -By the end of this lesson, you'll be able to: -- Publish datasets to the Pontus-X networks. -- Consume and retrieve data assets. -- Download and use data from decentralized sources. +Let us dive into **Nautilus**, the essential toolkit for managing decentralized data pipelines. This course will focus on **publishing, consuming, and downloading data assets** within the **Pontus-X** ecosystem. By the end of this lesson, you'll be able to publish datasets to the Pontus-X networks, consume and download data from decentralized sources. ## What is Nautilus? **Nautilus** is a TypeScript toolkit specifically designed for the **data economy**. It serves as an **abstraction layer** over decentralized data infrastructure, allowing users to create, manage, and interact with data pipelines in a more intuitive and accessible way. It is a powerful tool for those looking to **publish, access, and monetize data services** in the **Pontus-X** ecosystem. @@ -15,24 +10,20 @@ Whether you are publishing a dataset, executing a compute job, or managing acces ## Key Features of Nautilus **Publishing and Managing Data Assets** -- Nautilus makes it simple to publish datasets, APIs, and algorithms on the Pontus-X marketplace. Once published, you can manage your data assets by editing, updating, or removing them as needed. -- Users can offer different access types (e.g., subscription, one-time purchase) for their data assets, creating flexible monetization models. -- Hands-on Example: Walkthrough of publishing a dataset and setting access parameters. +- Nautilus makes it simple to publish datasets, access to digital services, and algorithms on the Pontus-X marketplace. Once published, you can manage your data assets by editing, updating, or removing them as needed. +- Users can offer different access types (e.g., subscription, one-time purchase) for their service offers, creating flexible monetization models. **Triggering and Managing Compute Jobs** - One of the standout features of Nautilus is its support for Compute-to-Data. This feature allows you to execute compute jobs on data without moving the data itself, ensuring privacy and security. - Nautilus also supports monitoring compute job status and retrieving the results, providing end-to-end control over data processing tasks. -- Hands-on Example: Demonstrate how to trigger a compute job and retrieve the results using Nautilus. **Accessing Data from Decentralized Spaces** - Nautilus allows you to consume data services offered by others within the Pontus-X ecosystem. Whether you are accessing datasets, APIs, or compute services, the toolkit makes it easy to discover and use the resources you need. - With typed APIs and full TypeScript support, Nautilus ensures that you have reliable, clear interfaces for interacting with the data economy. -- Hands-on Example: Demonstrate accessing a dataset or API offered by another participant in the Pontus-X ecosystem. **Custom Network Configurations** - One of the key strengths of Nautilus is its flexibility. You can customize your connections to different networks and components within Pontus-X to meet your specific needs. - This allows businesses and developers to seamlessly integrate Nautilus into their existing infrastructures and workflows. -- Hands-on Example: Guide through setting up a custom network configuration for a specific business use case. **Cross-Network Collaboration** - Nautilus supports interactions across different data spaces, allowing for collaboration between industries, institutions, and partners. By offering seamless cross-network functionality, it opens up opportunities for multi-sector collaboration. @@ -178,11 +169,6 @@ Now you have the data locally, and you can use it for analysis, machine learning ## Conclusion -You’ve now learned how to: -- Publish datasets on the Pontus-X network. -- Consume and access decentralized data assets. -- Download and manage data from the network for local use. - -By mastering these skills, you can fully participate in the Pontus-X data economy, offering and consuming valuable datasets and services while maintaining control over your assets. +You’ve now learned how to publish datasets on the Pontus-X network, consume and access decentralized data assets and download and manage data from the network for local use. This is the first step to participate in the Pontus-X data economy, offering and consuming valuable datasets and services while maintaining control over your assets. In the next lesson, we will explore how to monetize your data and AI products within the Pontus-X marketplace, and take a deeper dive into cross-industry collaboration and data sharing.