Skyocean MVP Development Guideline

This document provides a comprehensive, step-by-step guideline for building a functional MVP for the Skyocean platform. The MVP is designed to demonstrate key interoperability features—including ERP data conversion, DKG EDGE node integration, smart contract triggers on a testnet (using Sepolia), simulated customs clearance (for the USA and Ghana), and off-chain payment flows with banks—all integrated via a unified dashboard UI.

Note: While our full Web3 vision encompasses a unified ecosystem that integrates Data Verification & Traceability, Transaction Automation & Community Engagement, and Supply Chain Management, this MVP focuses on a minimal demonstration of these core features. Developers are encouraged to innovate and use alternative methods to achieve these outcomes, while the MVP remains a simplified proof-of-concept for initial validation and investor demonstrations.

1. Project Overview

Objective

  • Core Vision: Create an MVP that demonstrates a unified Web3 ecosystem built on three core pillars:

    • Data Verification & Traceability:
      Use OriginTrail DKG (v8) to verify and track supply chain data by converting documents (e.g., PDFs) into standardized JSON-LD Knowledge Assets (KAs) that adhere to recognized standards (e.g., GS1/EPCIS).

    • Transaction Automation & Community Engagement:
      Leverage blockchain (e.g., Polygon/Sepolia) for trade execution, token-based staking, financing, and other token utilities. Smart contracts will trigger actions (such as releasing funds) when conditions (e.g., document approvals) are met.

    • Supply Chain Management:
      Integrate an ERP or SCM module (e.g., ERPNext) to manage the entire trade lifecycle—from order initiation to document management, logistics tracking, and financial processing.

  • Simplified Explanation:
    Combine verified data, automated blockchain transactions, and robust supply chain management into one cohesive platform that delivers transparency, efficiency, and trust across global trade operations.

MVP Scope:
The MVP will focus on demonstrating the key interoperability aspects (data conversion, smart contract triggers, simulated customs clearance, and off-chain payment flows) rather than implementing every feature of the full Web3 vision. This minimal version will be sufficient to prove the concept, attract funding, and serve as the foundation for future expansion.

2. Architecture & Integration Overview

A. ERP Integration (ERPNext)

  • Setup:
    • Deploy a minimal ERPNext instance with an Aviation Trading module.
    • Populate the system with sample trade transactions that include key fields (e.g., transaction ID, part numbers, shipping documents, certification details).
  • Data Mapping & Conversion:
    • Mapping Document: Define how ERPNext fields convert into our canonical JSON-LD schema.
      • Example Mapping:
        • transaction_id → @id
        • part_number → productID
        • certification_status → certificationStatus
    • Conversion Scripts: Develop scripts (using Python, Node.js, etc.) that extract data from ERPNext, transform it into JSON-LD, and forward it to the DKG via the EDGE node API (Currently the EDGE now of DKGV8 can achieve this, see bellow).

B. DKG EDGE Node Integration (DKGv8)

  • EDGE Node Setup:
    • Install and configure the DKGv8 EDGE node per the official documentation.
    • Leverage its out-of-the-box customizable UI and built-in PDF-to-JSON-LD conversion feature.
  • API & RAG/Mining Integration:
    • Utilize the RAG and mining APIs to query and display live data from the DKG and own paranets.
    • Ensure the EDGE node accepts JSON-LD inputs from your ERP conversion scripts and returns validated KAs with unique identifiers.

C. Blockchain Integration (Sepolia Testnet)

  • Smart Contract Development:
    • Develop and deploy minimal smart contracts on the Sepolia testnet that include:
      • A function to lock tokens or funds upon trade initiation.
      • A trigger function to release tokens when conditions (e.g., document approvals) are met.
      • Event logging to capture and display when shipping documents are complete and the smart contract is executed.
    • Document the deployment process with sample scripts (using Remix or Truffle).
  • Trigger Mechanism:
    • Integrate an API endpoint that is called once final document approvals are confirmed. This endpoint will trigger the smart contract function.

D. Customs Clearance & Off-Chain Payment Simulation

  • Customs API Simulation:
    • Develop lightweight REST API endpoints that simulate customs clearance workflows.
    • Example (USA):
      • Endpoint: /api/customs/usa/clearance
      • Accepts a JSON payload representing a trade transaction and returns a simulated clearance status.
  • Bank Payment API Simulation:
    • Build a dummy off-chain payment API to mimic bank payment confirmations once smart contract conditions are met.
    • Example Endpoint:
      • URL: /api/payments/offchain
      • Returns a confirmation status for the simulated payment.

3. User Interface (UI) & Experience

A. Dashboard Design

  • Framework:
    Build a responsive single-page application (SPA) using React.js that integrates with ERP, DKG, blockchain, customs, and payment APIs.

  • Key UI Components:

    1. Trade Overview Panel:
      Lists trade transactions with basic details.

    2. Document Status Panel:
      Displays the status of shipping documents (uploaded, in conversion, approved) and provides links to the corresponding KAs in the DKG.

    3. Smart Contract Event Log:
      Shows real-time events from the smart contract (e.g., token locking, document approval triggers, payment releases).

    4. Customs Clearance Module:
      Displays simulated clearance status from the USA and Ghana endpoints.

    5. Off-Chain Payment Module:
      Displays payment status updates after simulated bank API confirmations.

    6. Integration Alerts:
      Notifies users when key events occur (e.g., “All documents approved – smart contract triggered!”).

  • UI Suggestions:

    • Leverage customizable UI components provided by DKGv8.
    • Use clear call-to-action buttons for manual document uploads and test triggers.
    • Integrate charts or progress bars to visualize the trade lifecycle.

4. MVP Test Scenarios & Workflow

A. End-to-End Test Scenario

  1. Trade Initiation:
    • Create a sample transaction in ERPNext.
    • Extract and convert ERP data into JSON-LD using your mapping script.
  2. Document Upload & Conversion:
    • Manually upload shipping documents (e.g., commercial invoice, bill of lading, certificate of origin) via the DKG EDGE node UI.
    • The EDGE node converts PDFs into JSON-LD and creates Knowledge Assets.
    • knowledge assets of a purchase order are posted in the UI and simulate token holders blocking tokens in the Smart contract
  3. Document Verification & Approval:
    • Approve the Smart contrac via the UI the KA is updated with the smart contract number
    • Upon DLKs full approval of documenation, automatically trigger the smart contract function.
  4. Smart Contract Trigger & Token Release:
    • The smart contract on Sepolia is triggered to lock/release tokens and or notification for off chain payment.
    • Log the event and display it in the UI.
  5. Customs Clearance Simulation:
    • Send a simulated clearance request to the USA or Ghana customs API.
    • Display the returned clearance status on the dashboard.
  6. Off-Chain Payment Simulation:
    • Trigger a simulated off-chain payment request to the bank API upon smart contract execution.
    • Display the payment confirmation on the dashboard.

B. Minimal Test Scenario (If Full Integration Is Too Extensive)

  • Core Demonstration:
    • Create a sample trade record.
    • Manually upload shipping documents via the EDGE node UI.
    • Demonstrate the document-to-KA conversion and display the resulting KA.
    • Manually trigger a smart contract and display the event log.
    • Show simulated customs clearance and off-chain payment statuses with preconfigured responses.

5. Deployment & Budget Considerations

  • Hosting & Infrastructure:
    • Use open-source ERPNext and DKGv8 components to minimize costs.
    • Deploy on a small cloud instance or VPS for demonstration purposes.
    • Utilize testnets (e.g., Sepolia) to avoid high transaction fees.
  • Development Tools:
    • Leverage existing development frameworks.
  • Documentation & Version Control:
    • Maintain all integration scripts, UI code, and API endpoints in a version-controlled repository (e.g., GitHub).
    • Ensure comprehensive documentation is provided for each module.

6. Final Steps & Recommendations

6.1 Final Vision

The ultimate goal of the Skyocean platform is to create a unified Web3 ecosystem that seamlessly integrates:

  • Data Verification & Traceability:
    Leveraging OriginTrail DKG (v8) to standardize and verify supply chain documents as JSON-LD Knowledge Assets.
  • Transaction Automation & Community Engagement:
    Utilizing blockchain technology (via smart contracts on testnets like Sepolia) to automate trade execution, token-based staking, financing, and governance.
  • Supply Chain Management:
    Integrating an ERP/SCM module (e.g., ERPNext) to manage the entire trade process—from order initiation to document management, logistics, and financial processing.

In simple terms, we aim to combine verified data, automated blockchain transactions, and robust supply chain management into one cohesive platform that offers transparency, efficiency, and trust across global trade.

6.2 MVP Goals

For the MVP, focus on demonstrating the following core capabilities:

  • ERP to DKG Integration:
    • Extract sample trading data from ERPNext.
    • Convert ERP data into JSON-LD Knowledge Assets via the DKG EDGE node.
  • Smart Contract Automation on a Testnet:
    • Deploy minimal smart contracts on Sepolia to simulate token locking/release based on document approvals.
  • Simulated Interoperability:
    • Develop REST API endpoints to simulate customs clearance (USA and Ghana) and dummy off-chain payment confirmations.
  • Unified Dashboard UI:
    • Create a React.js dashboard that integrates and displays data from ERP, DKG, smart contracts, and simulated customs/payment APIs.

6.3 Flexibility in Implementation

  • Innovation Over Constraints:
    • The provided guideline serves as a baseline. Developers are encouraged to explore alternative methods that achieve the same outcomes.
  • Freedom to Choose Technologies:
    • While the core objectives remain fixed, developers have the freedom to choose frameworks, libraries, and integration patterns that best suit the implementation.
  • Focus on Key Outcomes:
    • Ensure that the final MVP effectively demonstrates data verification, automated blockchain processes, and integrated supply chain management—even if implemented via different methods.

6.4 Iterative Testing and Documentation

  • Iterative Development:
    • Begin with minimal test scenarios and validate each integration step. Iterate based on test results and feedback.
    • Example: Test ERP-to-DKG conversion independently, then integrate smart contract triggers, and finally add customs/payment simulations.
  • Robust Documentation:
    • Maintain version-controlled documentation covering mapping logic, ontology definitions, integration scripts, and API endpoints.
    • Update documentation as new methods or optimizations are introduced.
  • Comprehensive Logging:
    • Implement detailed logging at every integration step to aid in troubleshooting and performance tuning.

6.5 Stakeholder Communication

  • Demonstration and Feedback:
    • Organize regular walkthroughs of the MVP with internal stakeholders and potential investors (VCs).
    • Use the unified dashboard to showcase real document flows, KA creation, smart contract triggers, and simulated customs/payment integrations.
  • Clear Value Proposition:
    • Emphasize that the MVP demonstrates the integration of verified data, automated blockchain operations, and supply chain management.
    • Clearly link each component to the final vision, even if the MVP is a minimal representation.

Conclusion

This guideline provides a clear roadmap for developing a functional MVP for the Skyocean platform. The MVP should:

  • Demonstrate end-to-end document verification and conversion via the DKG EDGE node.
  • Trigger smart contracts on a testnet based on document approval conditions.
  • Simulate interoperability with customs systems and bank payment APIs.
  • Present a unified UI that showcases these processes in real time.

Developers are encouraged to use this document as a starting point, adapt the implementation as needed, and focus on delivering a compelling demonstration of the platform’s core capabilities. This approach will pave the way for future expansion and full-scale production once the MVP is validated and funded.