Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProgramsOrganizations

Explore Organizations

Discover open-source organizations actively accepting contributors across GSoC, ESoC, LFX Mentorship, Outreachy, and more.

Codeuino Mentorship logoCodeuino MentorshipCompressed instructions for SERV logoCompressed instructions for SERVConfidential Computing Fellowship logoConfidential Computing FellowshipContributing to first stable release of mldsa-native logoContributing to first stable release of mldsa-nativeCopacetic logoCopaceticCoreDNS logoCoreDNSCortex logoCortexCreate a Workload Analysis Flow Using RISC-V Olympia Performance Model logoCreate a Workload Analysis Flow Using RISC-V Olympia Performance ModelCrossplane logoCrossplaneDeveloping RISC-V with Next Generation Arithmetic (NGA) capabilities logoDeveloping RISC-V with Next Generation Arithmetic (NGA) capabilitiesDevfile logoDevfileElectron FDC3 logoElectron FDC3Codeuino Mentorship logoCodeuino MentorshipCompressed instructions for SERV logoCompressed instructions for SERVConfidential Computing Fellowship logoConfidential Computing FellowshipContributing to first stable release of mldsa-native logoContributing to first stable release of mldsa-nativeCopacetic logoCopaceticCoreDNS logoCoreDNSCortex logoCortexCreate a Workload Analysis Flow Using RISC-V Olympia Performance Model logoCreate a Workload Analysis Flow Using RISC-V Olympia Performance ModelCrossplane logoCrossplaneDeveloping RISC-V with Next Generation Arithmetic (NGA) capabilities logoDeveloping RISC-V with Next Generation Arithmetic (NGA) capabilitiesDevfile logoDevfileElectron FDC3 logoElectron FDC3Codeuino Mentorship logoCodeuino MentorshipCompressed instructions for SERV logoCompressed instructions for SERVConfidential Computing Fellowship logoConfidential Computing FellowshipContributing to first stable release of mldsa-native logoContributing to first stable release of mldsa-nativeCopacetic logoCopaceticCoreDNS logoCoreDNSCortex logoCortexCreate a Workload Analysis Flow Using RISC-V Olympia Performance Model logoCreate a Workload Analysis Flow Using RISC-V Olympia Performance ModelCrossplane logoCrossplaneDeveloping RISC-V with Next Generation Arithmetic (NGA) capabilities logoDeveloping RISC-V with Next Generation Arithmetic (NGA) capabilitiesDevfile logoDevfileElectron FDC3 logoElectron FDC3

Showing 841–960 of 1,257 organizations

Browse projects
Codeuino Mentorship logo

Codeuino Mentorship

Linux Foundation

Codeuino is a volunteer-driven, open-source, social networking software development organization that desires the potential to change the way other communities and individuals use and create open-source social-environment tools to better align with end-user expectations, giving prospectus to various other organizations, users and activists to use the social environments built within Codeuino in a custom way. Donut is an open-source, feature-rich, highly flexible and privacy-friendly, social networking platform built for community-oriented collaboration in a customized way. It has been built on the Node.js framework allowing an essential impetus to provide custom and friendly rich widgets and an expansive library of modules to make communication and collaboration easy and successful. With a powerful module system, you can customize this platform by using third party tools, writing your own, or integrating other software.

javascriptjqueryjson+5
1 active years
Explore
Compressed instructions for SERV logo

Compressed instructions for SERV

Linux Foundation

The award-winning SERV (https://github.com/olofk/serv) is the world's smallest RISC-V CPU and is suitable for deeply embedded applications where chip area is at a premium. In a real system however, not only the CPU sets the system size and the smaller the CPU, the more important to also minimize the memory size. Adding support for the C ISA extension (compressed instructions) to SERV would enable RISC-V to reach even more use-cases on the deeply embedded side. SERV is an open source bit-serial RISC-V implementation written in Verilog with an emphasis on resource efficiency. The addition of the C ISA extension is expected to consist of changes to the instructions fetcher, an extra optional decoder stage for converting the compressed instructions into their non-compressed equivalents as well as other changes related to the PC not necessarily being word-aligned. On the infrastructure side, the relevant test suites (riscv-formal and riscv-compliance) are expected to pass and it should run the Zephyr operation OS with compressed instructions enabled. The SERV FuseSoC core description file should also be updated to allow users to conditionally select the C ISA extension at compile-time for simulation and FPGA/ASIC targets.

verilogscriptingrisc-v+1
1 active years
Explore
Confidential Computing Fellowship logo

Confidential Computing Fellowship

Linux Foundation

As organizations from different sectors move their computing workloads across multiple environments, from on-premises to public Cloud to Edge, they require greater assurances that their sensitive code and data are protected. Confidential Computing protects data in use by performing computation in a hardware-based Trusted Execution Environment (TEE). To learn more about the Confidential Computing Fellowship, please check the guide below: https://enarx.dev/docs/Fellowship/Introduction Also, please join the #mentorship chat channel at: https://chat.enarx.dev/channel/mentorship

rustgitlinux+2
2 active years
Explore
Contributing to first stable release of mldsa-native logo

Contributing to first stable release of mldsa-native

Linux Foundation

This project focuses on contributing to mldsa-native, a work-in-progress implementation of the ML-DSA post-quantum signature standard. The mentee will help advance mldsa-native towards its first stable release by working on various aspects of building a secure, fast, and portable implementation. Tasks may include implementing constant-time analysis tooling, expanding test coverage, improving build systems, enhancing documentation, developing benchmarking infrastructure, or contributing to CI/CD pipelines. The project offers flexibility to focus on areas matching the mentee's interests while contributing meaningfully to this post-quantum cryptography implementation and helping achieve production readiness.

c programming • python programming • make and build systems • interest in cryptographic implementations and post-quantum cryptography • security-focused development practices and constant-time analysis • testing frameworks, ci/cd, or build system experiencequantumsecurity+1
1 active years
Explore
Copacetic logo

Copacetic

Cloud Native Computing Foundation (CNCF)

Copacetic currently doesn't support vulnerability scan reports by Wiz scanning. This mentorship project will extend Copa's support to cover this new scanning schema using a pre-existing template. Expected Outcome: The mentee will produce the following i. Design doc for Wiz Scanning ii. Wiz Plugin Integration iii. End to End integration tests

golinuxcontainer images+6
2 active years
Explore
CoreDNS logo

CoreDNS

Cloud Native Computing Foundation (CNCF)

CoreDNS (https://github.com/coredns/coredns) is a cloud-native DNS server with a focus on service discovery. While best known as the default DNS server for Kubernetes, CoreDNS is capable of handle many other scenarios within or outside of Kubernetes clusters to make easy infrastructure management. One such case is certificate management. This project is to provide ACME protocol support so that it is possible to have automatic certificate management through CoreDNS. More details and discussions are available in https://github.com/coredns/coredns/issues/3460.

gocloud nativedns+2
3 active years
Explore
Cortex logo

Cortex

Cloud Native Computing Foundation (CNCF)

Description: Cortex Ruler queries ingester directly for rule evaluation. This is okay but if Cortex Ruler could query Query Frontend instead for rule evaluation, it can benefit from more features in the Query Frontend like vertical sharding. This also simplifies the Cortex ruler to not embed a querier and uses less resources. For this project, we would like to switch Cortex Ruler to query Query Frontend. You are expected to work with a microservice architecture and write unit tests and end to end tests to make sure the feature works correctly. Expected Outcome: Cortex Ruler talks to Query Frontend for rules evaluation.

gokubernetescloud native+4
3 active years
Explore
Create a Workload Analysis Flow Using RISC-V Olympia Performance Model logo

Create a Workload Analysis Flow Using RISC-V Olympia Performance Model

RISC-V

Performance research/design of RISC-V CPU designs require workloads for analysis. Workloads can be custom user applications or industry benchmarks such as SPEC, GeekBench, Dhrystone, etc. Using tools like the RVI Olympia Perf CPU Model users can pinpoint bottlenecks in CPU design, the workload, or the compilers/libraries. When the workload is small, running the workload on Olympia is not complex: trace the workload using a functional model and run that trace through Olympia; count cycles. However, if the workload is large, tracing the entire workload is not practical. Workload reduction tools, such as SimPoint, help narrow down the points of interest (POI) as well as reduce the instruction length to calculate estimated performance. The flow using SimPoint: Workload -> SimPoint analysis (using tools like QEMU) -> workload fragments -> trace generation. Each trace can be run in parallel on Olympia to gather the point performance. Post-processing tools will collate the fragments and generate an overall estimate of performance. This internship will: * Establish workloads (research) * Establish a SimPoint flow to reduce the workloads (QEMU or other instruction set simulators) * Generate STF traces using SimPoint data (QEMU or other instruction set simulators) * Create a repository of traces and their metadata, such as compiler info * Tools to run traces on Olympia and generate perf data (python, C++)

computer architectureable to collaborate with others
1 active years
Explore
Crossplane logo

Crossplane

Cloud Native Computing Foundation (CNCF)

Crossplane supports pulling packages from private registries through a variety of mechanisms, including IRSA, Workload Identity, and packagePullSecrets. There are a wide variety of environments in which a user is pulling a private package, which can lead to confusion about which to use, the precedence with which each is invoked, etc. This can lead to issues such as crossplane/crossplane#2876, where I suspect that we are resolving to Application Default Credentials, when we actually want to be using the provided packagePullSecret.

gokubernetes
3 active years
Explore
Developing RISC-V with Next Generation Arithmetic (NGA) capabilities logo

Developing RISC-V with Next Generation Arithmetic (NGA) capabilities

RISC-V

We want to discuss, map out, and plan a Next Generation Arithmetic (to include complex numbers) extension or equivalent to the RISC-V spec. This was discussed on the tech list a couple of years ago. We think there is a strong demand for this facility right now. The results of this work, likely including a feasibility study and code snippets, will inform the community on how to integrate NGA formats, including posits, into a RISC-V implementation. This internship will include our Journal Club approach where all interns will get opportunities to incorporate their additions and review the appropriate papers. To further these goals, and to give a reference to the substantial performance, accuracy and reproducibility advantages of NGA-enhanced RISC-V, a large number of CPU-based codes will be refactored to take advantages of the best parts of the appropriate arithmetic approaches while keeping floating-point options open.

open sourcefossifpga+2
1 active years
Explore
Devfile logo

Devfile

Cloud Native Computing Foundation (CNCF)

Devfiles are YAML files that define remote development environments. The main part of a Devfile is the `components` section and that's where the containers required to code, build and test an application are specified. The Devfile can either include those containers defintions or reference external files such as Dockerfiles or Kubernetes manifests. [The Compose file](https://github.com/compose-spec/compose-spec/blob/master/spec.md) is a popular format in open source development projects to define runtime environments for testing the application but those cannot be referenced by a Devfile yet. The goal is to continue the work that has been started a couple of months ago to allow referencing a Compose file from a Devfile. The expected outcome is to create a PoC written in go that parses a Compose file such as [this one](https://github.com/microservices-demo/microservices-demo/blob/master/deploy/docker-compose/docker-compose.yml) using [kompose](https://github.com/kubernetes/kompose) (as a library, not as an executable) and that creates the objects corresponding to the Compose file services in a Kubernetes cluster.

gokubernetescompose
1 active years
Explore
Electron FDC3 logo

Electron FDC3

Linux Foundation

Update FDC3-electron to support FDC3 2.0 Certify FDC3-electron on FDC3 1.2 and 2.0 Release fdc3-electron into mainstream repositories (NPM) Include 3+ samples in fdc3-electron as default Point fdc3-electron to FINOS global directory if existing Work with FDC3 maintainers to “approve” fdc3-electron as reference implementation and link into fdc3.finos.org

fdc3electron
1 active years
Explore
Enable BGP on Alpine virtual switch logo

Enable BGP on Alpine virtual switch

Linux Foundation

*OPEN TO US BASED STUDENTS ONLY* - Accepting applications until May 23, 2025 Alpine was primarily designed by Google to enable testing of an SDN-controlled fabric without an embedded control plane. However, Alpine can be extended to support traditional routing protocols that are supported by hardware SONiC switches. This project will help make Alpine more broadly useful as a virtual SONiC switch. Expected Outcomes: 1: Enable the routing container (FRR) in Alpine virtual switch image 2: Extend the Alpine configuration to include BGP configuration 3: Test the configuration in a mirror testbed 4: Identify any data plane gaps (and if found, update Lucius) 5: Run the SONiC test suites 6: Document running and configuring BGP in Alpine Recommended Skills: Kubernetes, Linux, Networking, Go Relationship to SONiC and Impact on Community: One of the main goals of Alpine is to provide a virtual switch with a dataplane to accelerate software delivery with fast test iterations. Integrating support for the widely-used BGP protocol in Alpine significantly broadens its applicability and increases its relevance to the SONiC community. Additional Information: https://youtu.be/55X1_2utiVg

kubernetesgolinux+1
1 active years
Explore
Enable ONAP to deploy Kubernetes workloads logo

Enable ONAP to deploy Kubernetes workloads

Linux Foundation

Increasingly, edge locations are becoming Kubernetes (K8s) based as K8s can support multiple deployment types (Virtual Network Functions, Containerized Network Functions, Virtual Machines and containers). ONAP4K8s is the project that enables ONAP to deploy workloads in K8s based sites. ONAP4K8s enables operators to use a K8s based sites to deploy workloads. In ONAP they can use this to deploy workloads on both Openstack based sites as well K8s based. It also enables usage of common compute resources for both network functions and applications, thereby utilizing compute infrastructure efficiently. ONAP4K8s is being extended to support deploying and connecting apps/services that span across multiple clusters. Major work items where intern can help are – 1. API enhancements 2. Improve code coverage 3. Adding support for application upgrades 4. Adding test cases for new use cases 5. Improving monitoring, tracing, logging of microservices

programming skillsscriptingsource control/git+7
1 active years
Explore
Enhancement to Olympia logo

Enhancement to Olympia

RISC-V

RISC-V Performance Modeling SIG is driving the development of Performance Modeling and Simulation Tools for use across RISCV membership to foster collaboration across the community. To that end, the SIG has developed a trace-driven performance model of an example RISC-V superscalar processor using C++ based on the Sparta simulation framework. The performance model, named Olympia, has been adopted by multiple organizations in both industry and academia. We have identified set of features for further development of Olympia: * Add support for execution-driven modeling - https://github.com/riscv-software-src/riscv-perf-model/issues/14 * Model state of art branch predictors along with decoupled frontend using branch-prediction API, with an example being the BOOM processor frontend documented at https://docs.boom-core.org/en/latest/sections/branch-prediction/index.html - https://github.com/riscv-software-src/riscv-perf-model/issues/143 - https://github.com/riscv-software-src/riscv-perf-model/issues/1 * Develop an API for Interconnect model and implement an example Interconnect microarchitecture. - https://github.com/riscv-software-src/riscv-perf-model/issues/60 * Use the API for data/instruction prefetcher and implement an example prefetcher microarchitecture - https://github.com/riscv-software-src/riscv-perf-model/issues/142 * Enhance the existing vector extension implementation Etc.

computer architectureperformance modelingcollaboration+2
1 active years
Explore
Enhancing Constant-Time Analysis Tooling in liboqs logo

Enhancing Constant-Time Analysis Tooling in liboqs

Linux Foundation

This project aims to improve the detection of timing side-channel vulnerabilities in the liboqs library by extending and integrating constant-time analysis tools into the CI pipeline. Past vulnerabilities such as Kyberslash, clangover highlight the need for improved automated detection. The mentee will explore existing tooling, enhance it for broader coverage, integrate it into liboqs workflows, triage and investigate any findings. The project may also include reporting issues upstream, contributing fixes, and documenting the results.

c programming - basic scripting (e.g., python) for ci integration - interest in cryptographic implementations - interest in side-channel analysis and secure coding practicesquantumsecurity+1
1 active years
Explore
Enhancing Redis Access Efficiency and Robustness in SONiC logo

Enhancing Redis Access Efficiency and Robustness in SONiC

Linux Foundation

*OPEN TO US BASED STUDENTS ONLY* - Accepting applications until May 23, 2025 To profile, analyze, and optimize Redis access patterns in SONiC's critical services and daemons, with the goal of reducing unnecessary Redis traffic and ensuring responsiveness even under load. Implement robust exception handling for Redis to prevent daemon crashes. Probable Implementation: Review GET/SET operations to ensure appropriate exception handling is in place. Use tools like redis-cli MONITOR, strace, perf, syslogs to identify: High-frequency Redis accesses Redundant or repeated GET/SET patterns Long response-time operations Focus on critical daemons like chassisd, pcied, lldp, syncd, orchagent. Apply the following optimizing methods for best performance: Use "HGETALL" instead of multiple "HGET" operations. Check for value-change before writing. Batching and use pipelining where it is missing. Benchmarking: Setup baseline Redis load tests and focus on couple of high CPU/mem consuming HWSkus Compare before/after metrics Redis command frequency Memory and CPU usage Expected Outcome: - High-level document outlining of existing Redis baseline, improvements required, etc. - Optimized Redis access operations - Improved exception handling for Redis reads/writes

luapythonlinux+1
1 active years
Explore
Environmentally Sensitive Growth Module and Online Courses for Forest Greenhouse Gas Estimates logo

Environmentally Sensitive Growth Module and Online Courses for Forest Greenhouse Gas Estimates

Linux Foundation

Climate change is the biggest challenge of our time. We need all the help we can get to reduce emissions in every sector. The land sector is particularly important because there are not only emissions but also to potential for removals of greenhouse gases from the atmosphere. The Full Lands INtegration Tool (FLINT) is a platform for estimating greenhouse gas emissions and removals from land. This project: Develops new modules that represent the impacts of environmental changes on growth and mortality rates. Data from South Korea is used as a pilot. Scientifically, the key challenge is to translate information about tree-level responses to environmental changes to stand-level responses. Develops online training in response to COVID-19 to replace classroom training. A coherent approach to online instruction needs to be designed and the existing materials need to be turned into online ready versions.

c++rknowledge of forest growth dynamics+4
1 active years
Explore
Envoy logo

Envoy

Linux Foundation

Envoy is an open source edge and service proxy, designed for cloud-native applications.

c++cloud native
1 active years
Explore
Envoy Gateway logo

Envoy Gateway

Cloud Native Computing Foundation (CNCF)

Envoy Gateway translates Kubernetes-native Gateway API resources into xDS configuration consumed by Envoy Proxy. It also manages the lifecycle of the Envoy Proxy fleet by generating Kubernetes resources such as Deployments and Services. Currently, upgrades to Envoy Gateway (the control plane) result in immediate, in-place updates to the associated Envoy Proxy fleet (the data plane). While this operation is designed to be zero-downtime, some users prefer a staged upgrade process where the control plane is updated first, followed by a progressive rollout of the data plane. This project aims to design and implement support for progressive data plane upgrades, allowing users to decouple the control and data plane upgrade processes. This would provide enhanced control and safer rollout strategies (e.g., canary or blue-green deployments). Expected Outcome: 1. Design a two-step upgrade workflow that separates control plane and data plane updates. 2. Implement configuration or CRD support to control rollout strategy of the Envoy Proxy fleet. 3. Add documentation and example manifests for users to adopt the new workflow.

goscriptingenvoy proxy+16
2 active years
Explore
Expose and manage PCI device reset logo

Expose and manage PCI device reset

Linux Foundation

PCI and PCIe devices may support a number of possible reset mechanisms, for example Function Level Reset (FLR) provided via Advanced Feature or PCIe capabilities, Power Management reset, bus reset, or device specific reset. Currently the PCI subsystem creates a policy prioritizing these reset methods which provides neither visibility nor control to userspace. This project would work to expose the reset methods available per device to userspace, likely via sysfs, and allow a administrative user or device owner to have some ability to manage per device reset method priorities or exclusions. This feature aims to allow greater control of a device for use cases as device assignment, where specific device or platform issues may interact poorly with a given reset method, and for which device specific quirks have not been developed.

cgnu makeshell+2
1 active years
Explore
FINOS Accessibility Theme Builder Mentorship logo

FINOS Accessibility Theme Builder Mentorship

FINOS

Theme Builder is a React-based web application that allows users to create design systems that are accessible out of the box. Currently, users are not able to modify their design system's color palette or default color theme once it has been defined, because such changes may invalidate other design system updates that the user may have already made. This project is to modify the application to allow the user to make palette and theme changes in an existing design system and to add code to help users identify and correct issues that may arise due to the changes.

web appnode.jsreact+1
1 active years
Explore
FINOS Marketing logo

FINOS Marketing

FINOS

FINOS (FinTech Open Source Foundation - part of the Linux Foundation) is looking for a summer marketing intern to assist with: - Marketing research (members, projects, BD) - Social media (research, operations) - Content for website (research, operations) - Podcast production (research, operations)

marketingmarketing researchsocial media+4
1 active years
Explore
Feature optimizations for RISCV-CTG (Compatibility Test Generator) and RISCV-ISAC (RISCV ISA Coverag logo

Feature optimizations for RISCV-CTG (Compatibility Test Generator) and RISCV-ISAC (RISCV ISA Coverag

Linux Foundation

Introduction RISCV-ISAC: RISC-V ISAC is an ISA coverage extraction tool. Given a set of cover points and an execution trace of a test/application run on a model, ISAC can provide a report indicating in detail which of those cover points were covered by the test/application. ISAC also holds the capability to provide a detailed quality analysis on data propagation occurring within the test/application.RISCV-CTG is the RISC-V based Compatibility Test Generator. This tool is used to generate tests used in the official RISC-V Architectural Test Suite and the RISC-V architectural test framework RISCOF. All tests generated by the CTG are compliant with the official Test Format Spec. The CTG is similar to a constrained test generator capable of generating tests targeting a specific set of constraints. These constraints are supplied to the CTG using the Coverage Group Format (CGF) File. The CGF file contains various cover-points for different instructions. The CTG treats each cover-point as a constraint and employs a solver to identify potential solutions. CTG uses the constraint satisfaction problem (CSPs) solvers offered by the python-constraint package.

risc-vpythonassembly programming (risc-v preferred)+4
1 active years
Explore
Feature optimizations for RISCV-CTG and RISCV-ISAC logo

Feature optimizations for RISCV-CTG and RISCV-ISAC

Linux Foundation

ISAC & CTG are essential components of the RISC-V Architectural Testing(AT) ecosystem. CTG generates tests for AT using the coverpoints as stimulus to ensure that complete coverage can be achieved with minimal testing. ISAC measures the coverage of the tests and reports on the quality of the test suite. This mentorship involves adding multiple features to both these tools to improve the quality of the architectural test suite. For further information on the tasks to be done during your internship refer here - https://gist.github.com/pawks/e2dec6d67224a9f68bf96fc909398c45 As part of the selection process, all candidates are required to successfully complete the coding challenge described here before August 3rd : https://gist.github.com/pawks/98863e5eca71c8b80b18e060cb4d9558

python programmingassembly programming (risc-v preferred)computer architecture (bonus)+7
1 active years
Explore
Fluentd logo

Fluentd

Linux Foundation

Fluentd is an open source data collector for building the unified logging layer. Once installed on a server, it runs in the background to collect, parse, transform, analyze and store various types of data.

clinuxcloud native
1 active years
Explore
Flux logo

Flux

Cloud Native Computing Foundation (CNCF)

Flux has several integration points with hyper-scaler platforms e.g., AWS. In general it is tricky to test these satisfactorily, because it requires running in the platform and thereby incurring usage costs. GCP donate credits that are used to test there; and now the Flux project has been generously granted credits to use for testing in AWS, and we can create conformance tests for AWS specifically too. Expected outcome: A suite of conformance tests for AWS integrations in Flux.

awsgolanggithub actions
1 active years
Explore
GVCR logo

GVCR

Hyperledger

As conceptualized and standardized by the W3C, the Verifiable Credentials protocol is one of the three pillars of Self-Sovereign Identity, together with the Decentralized Identifiers protocol (DIDs) and Distributed Ledger Technology (or Blockchain). The project aims to design and build a verifiable credential registry (VCR) on GitHub repository, namely GitHub-based Verifiable Credential Registry (GVCR), by leveraging existing GitHub APIs, and other open-source tools provided by other Hyperledger projects, such as Aries, Indy, and Ursa. The basic architecture is already built. For more details about the conceptional design and workflows, please refer to the GitHub repository GitHub-VCR.

shelldecentralized identitygit+2
1 active years
Explore
GenevaERS Demo System logo

GenevaERS Demo System

Linux Foundation

Assist in development of the initial GenevaERS demo system, including building views, test processes, procedures to allow initial users to download and use GenevaERS successfully.

java
1 active years
Explore
Google Season of Documentation logo

Google Season of Documentation

Linux Foundation

Help us fight climate change through nature-based solutions! The Full Lands INtegration Tool (FLINT) is a platform for estimating greenhouse gas emissions at local, national and global scales. This project aims to improve moja global's documentation by building a community website and adopting consistent standards across our projects.

documentationsphinxreadthedocs+3
2 active years
Explore
GraphQL Mentorship logo

GraphQL Mentorship

Linux Foundation

GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. GraphQL provides a complete and understandable description of the data in your API, gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools.

graphql
1 active years
Explore
Harbor logo

Harbor

Cloud Native Computing Foundation (CNCF)

Description: Design, plan and implement an and UI and backend to be able to visualize per project and/or for the registry vulnerability overview which will allow better security audits and vulenrability mitigation Expected Outcome: Addition to the Web UI which can be used to represent in full for the whole Harbor instance or per project the vulnerability status of the images, which will allow Harbor admin or project admin to get an overview of the existing vulnerabilities on in the images, also to provide capability to export the data via the CVE exporter so it can be consumed in 3rd party tools(not necessary to be complete functionality) Upstream Issues: https://github.com/goharbor/harbor/issues/16680 https://github.com/goharbor/harbor/issues/10496 https://dso.docker.com/explore?search=pkgs

golangoss contributionsdistributed systems+42
4 active years
Explore
Hardware Abstraction Layer Transitional Library for Software to Hardware Posits For RISC-V logo

Hardware Abstraction Layer Transitional Library for Software to Hardware Posits For RISC-V

RISC-V

This project aims to ease the transition and implementation of Posits, an alternative numerical representation, for RISC-V systems. By creating a robust hardware abstraction layer (HAL), developers need not know if the target RISC-V platform has a hardware Posits implementation or requires a software implementation. This new POSIX-compliant C++ library (with ports planned eventually) will help make available the option to transition between IEEE Float / Doubles to Posits and should make the machine-specific selection and configuration seamless. The lack of such a HAL is a roadblock in Posit adoption and Posits represent a serious opportunity for free and open source silicon (FOSSi) systems. Initial focus will be directed toward HPC support, where numerical computation efficiency may be best observed. Additionally, we will be conducting benchmarking studies to evaluate the performance of the HAL, identifying bottlenecks, and iterating on the design based on empirical data. The testing framework will also be part of the mentee's deliverables.

software engineeringalternative numerical systemsdevelopment for accelerators and high powered computing+10
1 active years
Explore
Hardware Abstraction Layer Transitional Library for Software to Hardware Posits For RISC-V - Part II logo

Hardware Abstraction Layer Transitional Library for Software to Hardware Posits For RISC-V - Part II

RISC-V

This project aims to ease the transition and implementation of Posits, an alternative numerical representation, for RISC-V systems. By creating a robust hardware abstraction layer (HAL), developers need not know if the target RISC-V platform has a hardware Posits implementation or requires a software implementation. This new POSIX-compliant C++ library (with ports planned eventually) will help make available the option to transition between IEEE Float / Doubles to Posits and should make the machine-specific selection and configuration seamless. The lack of such a HAL is a roadblock in Posit adoption and Posits represent a serious opportunity for free and open source silicon (FOSSi) systems. We will also update the existing posit implementations to the current standard and add consistent unit testing. Initial focus will be directed toward HPC support, where numerical computation efficiency may be best observed. Additionally, we will be conducting benchmarking studies to evaluate the performance of the HAL, identifying bottlenecks, and iterating on the design based on empirical data. The testing framework will also be part of the mentee's deliverables.

c++linuxsuccessfully completed a software engineering course+5
1 active years
Explore
Healthcare-Centric Edge-AI Development on RVMCU Architecture logo

Healthcare-Centric Edge-AI Development on RVMCU Architecture

Linux Foundation

The healthcare system in Pakistan, particularly in rural areas, faces significant challenges due to limited access to medical facilities and high costs of conventional diagnostic equipment. These constraints leave a large portion of the population underserved, with limited access to timely and reliable healthcare. This project aims to address these gaps by providing a low-cost, portable healthcare solution powered by energy-efficient Edge-AI. By leveraging advancements in RISC-V technology, the proposed solution can revolutionize healthcare delivery in underprivileged areas, ensuring affordable and accessible diagnostics for all. The project, Healthcare-Centric Edge-AI Development on RVMCU Architecture, builds upon the RVMCU, a RISC-V microcontroller designed during the Linux Foundation's Spring 2024 LFX Mentorship Program. The RVMCU, which is compliant with the RV32IMC_Zba_Zbb_Zicsr_Zifencei specifications, was developed as an ultra-low-power, versatile SoC. This proposal seeks to extend that foundational work to enable healthcare-centric applications, specifically targeting wearable and portable devices. The enhanced RVMCU architecture will support diverse healthcare sensors (e.g., cough monitors, heartbeat detectors, ECG sensors) and provide real-time AI-powered analytics. The emphasis will be on achieving energy efficiency, modularity in hardware and firmware design, and seamless integration with AI frameworks optimized for edge computing.

risc-v architecture: a solid understanding of risc-v isa, extensions, and microcontroller conceptsembedded systems: experience in programming microcontrollers and working with low-level hardwarefpga development: familiarity with fpga design tools and workflows, including verilog/vhdl coding, simulation, and synthesis+14
1 active years
Explore
Hypereldger - Support Clique for Besu on HL Labs BAF logo

Hypereldger - Support Clique for Besu on HL Labs BAF

Linux Foundation

Hyperledger Labs Blockchain Automation Framework(BAF) is a tool to deploy different DLT platforms automatically on a given Kubernetes cluster. BAF supports multi-cloud and multi-DLT deployments, and already supports HL Fabric, HL Besu, Quorum, R3 Corda. For HL Besu, currently only IBFT2 Consensus is supported by BAF. With this internship program we want to support the Clique consensus for Besu, so that BAF can be used to deploy and operate a HL Besu network with Clique consensus. This will also include upgrading BAF to support the latest stable Besu version. The mentee will be able to learn: 1) Production grade architecture. 2) evOps in Blockchain Development. 3) Architecture of Besu and BAF. 4) work in true spirit of open-source, communicating with both Besu and BAF community, joining calls and using other community tools. 5) writing documentation, so anyone in the community could use the results of their work. 6) following rules and standards of open-source projects created by Hyperledger. Expected Outcome 1) Documented, ready-to-use Besu Clique consensus on BAF. 2) Documented upgrade of Besu to latest stable on BAF.

ansiblemoleculehelmcharts+3
1 active years
Explore
Hyperledger logo

Hyperledger

Hyperledger

Hyperledger Fabric is a prominent blockchain framework known for its enterprise-grade features and modular architecture. Within Hyperledger Fabric, chaincode (smart contracts) plays a crucial role in defining transaction logic and business rules. Ensuring the correctness and security of chaincode implementations is essential for the reliability and trustworthiness of Hyperledger Fabric networks. This research proposal aims to explore formal verification techniques specifically tailored for verifying the correctness and security properties of Hyperledger Fabric chaincode.

hyperledger fabricsubstrateblockchain+28
1 active years
Explore
Hyperledger - An object-key-value mapper for Hyperledger Fabric logo

Hyperledger - An object-key-value mapper for Hyperledger Fabric

Hyperledger

In Hyperledger Fabric, there can be a significant mismatch between the simple key-value ledger storage abstraction and the data representation style used for developing chaincode – i.e., Java has classes and objects, not keys and values. Currently, there aren’t really good tools for facilitating the “object-key-value mapping” (at least anything approaching classic Object-Relational Mapping – ORM). This not only complicates chaincode development, but a less than systematic approach with the mapping can lead to performance problems (through logically unnecessary MVCC conflict transaction invalidations). Additionally, an explicit object-oriented ledger data model would enable imposing data-centric constraints on the ledger content, either for runtime checking or development time verification and validation. The goal of the mentorship is to design and implement an object-key-value mapper with the following functionality: - Generating key-value storage models from UML ledger data models - Application of storage strategies during the mapping (as we explored in the report referenced below) - Generating a chaincode-internal Java data access/persistence layer, “parameterized” by the storage model - Demonstration on a representative example (e.g., our earlier work on faithfully implementing TPC-C to Fabric) - (If we have time): declaring OCL (Object Constraint Language) constraints on the models and enforcing them in the data access layer

gitjavahyperledger fabric+3
1 active years
Explore
Hyperledger - Automated Fault-Tolerant HTLC for Cross-Chain Atomic Asset Exchange logo

Hyperledger - Automated Fault-Tolerant HTLC for Cross-Chain Atomic Asset Exchange

Hyperledger

The Hash Time Locked Contract (HTLC) is a well-known pattern for dis-intermediated asset swaps, i.e., as a mechanism to exchange assets between two parties in two different blockchain networks in an atomic manner without a trusted mediator (or trusted third party). HTLC support has been implemented in the Hyperledger Weaver Labs project, with mechanisms to lock, claim, and unlock assets supported in both the contract and higher application layers. At present, the protocol requires several manual steps by the application users carrying out the exchange or agents acting on their behalf. We would like to automate this process as much as possible by augmenting the relay module in Weaver to communicate events and trigger transactions in foreign networks; this requires both research and software development. Further, HTLC is known to have flaws that could violate system integrity properties, because it relies on parties to execute certain actions by a certain timeout or forever lose the opportunity to carry out those actions; this makes the basic protocol intolerant to system crashes. Research is needed to (provably) determine the best way to make the HTLC protocol fault tolerant, using the features of the blockchain networks maintaining the assets and the Weaver relays mediating the exchange. Augmenting the existing HTLC mechanism within Weaver will provide practical validation of this research.

rustnode.jsgo+5
1 active years
Explore
Hyperledger - Automated Testing for Climate Emissions Ledger logo

Hyperledger - Automated Testing for Climate Emissions Ledger

Hyperledger

The utility emissions channel is a Hyperledger Fabric application which calculates Greenhouse Gas (GHG) emissions from utility bills and stores them on a Fabric ledger. This can then be used to generate audited emissions for businesses and individuals and help them calculate and offset their total carbon footprint. Because the application involves looking up data and performing numerical calculations, it's important to have automated tests to make sure that it's done correctly. As part of this project, you will develop automated tests for the utility emissions channel which will validate that the application is working as expected. These tests will verify that the application is looking up the utility bills for the correct customer and time frame, using the correct emissions factors data to calculate GHG emissions, recording them correctly on the Fabric ledger, and finally tokenizing them correctly on an Ethereum network. There are currently tests written to submit requests via REST API which connects to the chain code. The tests could be enhanced and eventually packaged along with deployment scripts so that a fresh testing instance could load all the data and run all the scripts to validate the results. Expected Outcome At the end of the project, you will have had a lot of fun, helped with climate change, and created an automated test suite to validate the utility emissions channel's emissions calculations.

node.jsautomated testing frameworksfabric+1
1 active years
Explore
Hyperledger - Automated gateways through smart contracts logo

Hyperledger - Automated gateways through smart contracts

Hyperledger

The objective of this project is to improve the interoperability of different blockchain networks by developing smart contract gateways that can interact with multiple networks. These gateways will automate, trace, and secure the process of submitting transactions to other blockchain networks. To achieve this goal, the project will involve creating smart contract gateways for various blockchain networks, including those using the same platform, as well as gateways to submit transactions to heterogeneous networks. The initial focus will be on developing gateway smart contracts for connecting multiple separate Hyperledger Fabric networks, and the next step will be to create gateways to connect Hyperledger Fabric to other heterogeneous networks, such as Hyperledger Indy and Besu. The project's primary objective is to evaluate system-level and large-scale integrations, which will be accomplished by setting up an extensive network of blockchains using Hyperledger Fabric as the source blockchain and other networks as destination networks. Overall, the project aims to enhance the efficiency, security, and traceability of cross-blockchain transaction submissions, thereby improving the overall functionality of blockchain technology.

hyperledger fabricblockchaindlt
1 active years
Explore
Hyperledger - Benchmarking Cross-Chain Bridges logo

Hyperledger - Benchmarking Cross-Chain Bridges

Hyperledger

Cross-chain bridges are a vital part of the blockchain landscape as they enable data and value to move seamlessly across different blockchains. Security is of utmost importance in this area, as these bridges can be vulnerable to malicious attacks and manipulation. In addition to securing bridges, measuring their performance and scalability is key to understanding if one is meeting the highest standards and is capable of encountering users' needs. This is mandatory to achieve mass adoption of the technology by single users and businesses. There have been some efforts to design and implement interoperability solutions across different blockchains, some of which are within the Hyperledger ecosystem (see links in the next section). Furthermore, preliminary research has been conducted to benchmark interoperability solutions, however, we feel there is currently a lack of studies that thoroughly compare bridges – used both within and between Hyperledger and public blockchains used in the industry. We aim to address this gap and conduct such evaluation studies, mainly through benchmarking. The goal of this project is to benchmark cross-chain solutions, an essential step for measuring the performance of any solution. As the adoption of cross-chain bridges grows it is increasingly important to have benchmarks to measure cross-chain solutions' performance and security.

blockchainnode.jstypescript+4
1 active years
Explore
Hyperledger - Blockchain Integration for Climate Emissions Data with Fabric and Cactus logo

Hyperledger - Blockchain Integration for Climate Emissions Data with Fabric and Cactus

Hyperledger

The Carbon Accounting and Certification Working Group is developing an Operating System for Climate Action, where data from a Hyperledger Fabric channel is tokenized on an Ethereum network. We would like to create a more robust integration with Hyperledger Cactus. Learning Objectives As part of this project, you will learn about 1) Hyperledger Fabric chain code development 2) Hyperledger Cactus cross-chain integration 3) REST APIs 4) Ethereum and Solidity 5) Open source development and project management Expected Outcome Implementation of an integration from Hyperledger Fabric utility emissions data channel to issue tokens on an Ethereum network using Hyperledger Cactus. Documentation and tutorials showing how the integration is done.

node.jsethereumsolidity+2
1 active years
Explore
Hyperledger - Blockchain Network Operation in a Decentralized Way logo

Hyperledger - Blockchain Network Operation in a Decentralized Way

Hyperledger

Now most users can easily deploy a blockchain network. On this basis, they need to manage the blockchain more flexibly and safely. Hyperledger cello will implement a fully decentralized BaaS. Each organization can independently deploy and manage its own baas, including their own private keys. Among organizations that have deployed cello, blockchain networks can be flexibly established. Through learning and development work, complete the design and development of some interfaces and front-end pages of the platform

pythonnode.jshtml+5
1 active years
Explore
Hyperledger - Cacti - Implement Standardized Secure Asset Transfer Protocol logo

Hyperledger - Cacti - Implement Standardized Secure Asset Transfer Protocol

Hyperledger

Cacti enables two blockchain or DLT networks to transfer digital assets between each other using different mechanisms and modules, inherited from the older Cactus and Weaver projects. The Node Server acts as a container for business logic to orchestrate (or trigger) transactions across multiple networks toward achieving some desired simultaneous state change in those networks. The Relay acts as a gateway, or an ingress/egress appliance, for a given network to send communication to, and receive communication from, another network. Using the Relay or the Node Server or both, one can effect a digital asset transfer from one network to another, sample protocols for which have already been implemented in Cacti with samples for demonstration. Parallelly, there is an ongoing effort to standardize blockchain/DLT interoperation protocols through consultation and brainstorming among experts within the field under the IETF's aegis. The goal of this project is to implement the more current SATP draft specification in Cacti, in the process augmenting the Cacti Relay to be a gateway that provides a reference or template for any other standardized implementation. Using other Cacti modules and sample apps, secure transfers of digital assets using SATP must also be demonstrated. If time permits, performance measurements may also be conducted to benchmark the protocol, and specifically the Relay.

rustnode.jsjava+5
1 active years
Explore
Hyperledger - Cacti - Ledger Data Sharing with Proof in Besu and Ethereum logo

Hyperledger - Cacti - Ledger Data Sharing with Proof in Besu and Ethereum

Hyperledger

Cacti provides a protocol and trigger mechanism for the sharing of ledger data or data derived from smart contracts (called "view", and identified by a "view address") deployed in a network with another network using relays for communication and consensus-driven proof generation and verification in the end networks. Some parts of the protocol are generic and DLT-agnostic but others, specifically protocol drivers or connectors and core ledger operators (typically built as smart contracts) are DLT-specific. Presently, Cacti provides DLT-specific data sharing mechanisms for Hyperldger Fabric and Corda. The goal of this project is to add similar support, i.e., build modules, plugins, and API for permissioned networks built on Hyperledger Besu. As an optional extension, these mechanisms will then be extrapolated to share data to and from public Ethereum. This will involve designing and basic building blocks or capabilities for view proof generation, proof verification, and access control of remote data requests, in the form of smart contracts. Higher up the stack, the Cacti SDK for Besu must then be augmented to enable network apps to trigger data sharing requests and submitting the responses for validation to local smart contracts.

soliditynode.jsprotocol development+5
1 active years
Explore
Hyperledger - Cacti - Polkadot connector logo

Hyperledger - Cacti - Polkadot connector

Hyperledger

Creation of polkadot connector plugin, alongside its cactus-polkadot-all-in-one docker image (hosting a sample polkadot ledger for testing purposes) and the test-tooling package for the AIO Learning Objectives - Hyperledger Cacti codebase - Hyperledger Cacti connector design - Understanding of various interoperability solutions, design and usage of cactus api server - Expected Outcome - Creation of polkadot connector - Creation of polkadot all in one docker image - Creation of polkadot test tooling classes - Documentation, architecture reference diagrams for the polkadot connector

javascripttypescriptblockchain+1
1 active years
Explore
Hyperledger - Cactus and Hedera Hashgraph integration logo

Hyperledger - Cactus and Hedera Hashgraph integration

Hyperledger

Hyperledger Cactus is a blockchain decentralised integration tool designed to allow users to securely integrate different blockchains started by companies Fujitsu and Accenture. Cactus has pluggable architecture which makes easy to integrate various blockchain by creating plugin, currently plugins for Fabric, Besu, Quorum are implemented. Cactus allows to transfer not only assets but also data between multiple blockchains. Hedera Hashgraph is a DLT built on top of an asynchronous BFT algorithm, providing smart contract, token, and consensus services to end users. The flexibility - Document ready-to-use integration of Hedera and Cactu, - Document example of integration using Hedera's Testnet and Hedera's Previewnet - Document example of integration between another blockchain and Hedera using Cactus

gojavajavascript+6
1 active years
Explore
Hyperledger - Chia Connector for Hyperledger Cactus logo

Hyperledger - Chia Connector for Hyperledger Cactus

Hyperledger

Develop a Cactus Chia connector plugin + test infrastructure (container images, container manager class, etc.) from scratch. Include end to end test cases powered by Jest and the said testing infrastructure that prove that the connector is working as intended with a locally simulated Chia network. You will be creating a new package in the Cactus monorepo from scratch under the packages/cactus-plugin-ledger-connector-chia/ path. All the information presented here can also be found at the GitHub issue tracker of Hyperledger Cactus, filed under issue #1634 => github.com/hyperledger/cactus/issues/1634

gitdockernode.js+6
1 active years
Explore
Hyperledger - Client Connector for Hyperledger Besu (Ethereum) logo

Hyperledger - Client Connector for Hyperledger Besu (Ethereum)

Hyperledger

Develop a connector that provides both synchronous and asynchronous modes of interacting with a running Hyperledger Besu node. The connector would act as an interface between an enterprise application and the Hyperledger Besu node for data ingestions and it could provide event subscription options. The scope of the project would also include an end-to-end test on a sample network.

javablockchainspring boot+2
1 active years
Explore
Hyperledger - Cross-Chain State Modelling and Analysis logo

Hyperledger - Cross-Chain State Modelling and Analysis

Hyperledger

The emergence of blockchain interoperability is reducing the risk of investing in blockchain by avoiding vendor lock-in, leveraging interoperation with off-chain systems, and providing a truly open ecosystem, enabling a network of blockchains. In particular, in the technical report we wrote, we designed a survey aimed to understand the socio-technical challenges that blockchain interoperability poses, with the goal of offering a unique opportunity to link the underlying technology with human experience and values. We discovered that end-users are particularly concerned with visualizing and analyzing cross-chain cost and throughput, with some indication that measuring energetic expenditure in the cross-chain setting would also be valuable. Following that survey, we implemented a simple PoC that obtains transaction receipts from different blockchains and aggregates them in a unified repository. This project aims to build on top of what was done and create a cross-chain model (taking into account what end-users what to analyze from such model) automatically from input cross-chain transactions. This project will take a cross-chain use case, create a model and allow end-users to extract relevant metrics, promoting a better understatement of the business logic running on blockchain infrastructures, and of interoperability.

blockchainresearchtypescript+3
1 active years
Explore
Hyperledger - DRman Utility to provision and administer DID based verifiable credential registries logo

Hyperledger - DRman Utility to provision and administer DID based verifiable credential registries

Hyperledger

The project DRman has an end goal of developing a stand-alone utility to provision Verifiable Credential Registries [VCR]. The utility can also be used to administer the registry containing credentials issued by the organizations. The functionalities like creation, verification, modification, and revocation of credentials, form the core of this project as it enables the administrator to manage the VCR with ease. The significant aspects to be considered here are Creation, Onboarding (Enable/Restrict Access) of members, and Management(add/update/revoke) of DIDs. a) Creation (of DID Registry): Function to create a DID Registry for an organization on Git. The automation is already done for this part and can be tracked at https://github.com/DIDman/DRman/issues/3. b) Onboarding: Function to add enable/restrict access to members of an organization to a repository (e.g., using a combination of GitHub private tokens, GitHub username & users DID). c) Manage: Function to list APIs that are needed to add/update/revoke access DID’s or (DID Document) saved as files on the repo. This summer, the project holds a variety of interesting automation issues to be addressed that focus more on onboarding and management of the organizations that intend to add themselves to the DID-based Verifiable credential registry.

shellrustdecentralized identity+2
1 active years
Explore
Hyperledger - Decentralized Identity Management for Trusted Interoperation logo

Hyperledger - Decentralized Identity Management for Trusted Interoperation

Hyperledger

The goal of this project will be to build a template or sample Interoperation Identity Network (IIN) by minimally augmenting existing decentralized identity registries built on Hyperledger Indy and Aries, adding support for group Decentralized Identifiers (DIDs), and optionally proposing changes or additions to W3C standards for DIDs and Verifiable Credentials (VCs). To demonstrate the working of identity plane protocols, existing Cacti IIN agents for Hyperledger Fabric must be augmented, and IIN Agents for Corda must be built, enabling data sharing and asset transfer across networks built on either Fabric or Corda. Also, a sample trust anchor must be designed and implemented as a service to issue VCs to network members.

javascriptpythoncryptographic concepts+6
1 active years
Explore
Hyperledger - Demonstrate Interoperability using Hyperledger Bevel and Cactus logo

Hyperledger - Demonstrate Interoperability using Hyperledger Bevel and Cactus

Hyperledger

Hyperledger Cactus support ledger Interoperability but use a local deployment for testing; Hyperledger Bevel supports production-worthy deployments. This project aims to support Cactus deployment using Bevel to demonstrate production-like usage of Hyperledger Cactus. The steps will be following: 1. Deploy a Hyperledger Fabric network using Bevel on a Managed Kubernetes cluster 2. Deploy a GoQuorum network using Bevel on a Managed Kubernetes cluster (can be the same cluster for simplicity). 3. Make changes in Hyperledger Bevel code to deploy the Cactus connectors in both the above networks. 4. Run Cactus test cases.

hyperledger fabricgoquorumansible+4
1 active years
Explore
Hyperledger - Deploy Carbon Accounting Network with Bevel logo

Hyperledger - Deploy Carbon Accounting Network with Bevel

Hyperledger

The Hyperledger Labs blockchain-carbon-accounting project has progressed significantly, and we're looking to move to production deployment of it. The deployment of a Hyperledger Fabric, however, has been a difficult and time consuming process in the past. Working with the maintainers of Hyperledger Bevel, we would like to streamline the deployment processes for both Fabric and Besu networks. Our goal is to allow any organization to join the networks using its own cloud infrastructure. At the end of the project, we are looking for: - Successful deployment of blockchain-carbon-accounting across multiple cloud networks, such as Digital Ocean, AWS, and Azure. - Scripts for further maintenance of the networks. - Detailed tutorials and learning materials which would benefit both blockchain-carbon-accounting developers and the broader Fabric, Besu, and Bevel communities.

hyperledger fabrichyperledger besunode.js+4
1 active years
Explore
Hyperledger - Design/Development of a mini game to explore decentralized Identity & Payments logo

Hyperledger - Design/Development of a mini game to explore decentralized Identity & Payments

Hyperledger

This project is meant to serve as a proof-of-concept for implementing decentralized identity and payment rails in the gaming (and by extension a future metaverse) ecosystem. This project has the following distinctive goals: 1. Implement a mini game project as a proof-of-concept (POC) that demonstrates use of decentralized identity and payment systems using Hyperledger chains such as Indy & Aries for Identity and Firefly for digital assets. 2. Conduct research on existing methods used for identity and payments and how use of Hyperledger blockchains can provide utility functions in such ecosystems 3. Conduct research and coding on how this game project can implement digital wallets for storing credentials and digital assets using design principles and recommendations from the Open Wallet Foundation

game designblockchaindevops+1
1 active years
Explore
Hyperledger - Developer Marketing logo

Hyperledger - Developer Marketing

Hyperledger

The Hyperledger Foundation is looking for a Developer Marketing mentee to support marketing efforts tied to our developer ecosystem. This mentee will work alongside the Hyperledger Foundation Marketing Manager in support of social media marketing, developer events and Hyperledger Global Forum our annual global conference in September and conduct research on which marketing activities can be leveraged to grow developer engagement. Responsibilities will include conducting market analysis, monitoring social platforms, and preparing promotional materials - Collaborate with the team to perform market analysis and research on the latest trends around developer engagement and marketing - Contribute to the content calendar with social media postings on a weekly basis - Monitor analytics with the rest of the team to identify viable ideas, trends, and growth patterns

blockchainopen source developer ecosystemsocial media+3
1 active years
Explore
Hyperledger - Document, Review, and Implement Hyperledger AnonCreds ZKP Cryptographic Primitives logo

Hyperledger - Document, Review, and Implement Hyperledger AnonCreds ZKP Cryptographic Primitives

Hyperledger

Hyperledger AnonCreds includes specifications and implementations of AnonCreds (Anonymous Credentials) Zero-Knowledge Proof (ZKP)-based verifiable credentials. AnonCreds extends the capabilities of “typical” verifiable credentials by including important privacy-preserving features including selective disclosure, ZKP predicates (e.g., proving I’m older than 21 based on my date of birth without sharing my date of birth), and not revealing any correlatable identifiers in presenting credentials. The version 1.0 specification (based on CL-Signatures as initially implemented in Hyperledger Indy) is near completion, and work has begun on the version 2.0 specification that will retain and extend the privacy-preserving features of AnonCreds v1.0, while improving capabilities, performance, extensibility, and security. An implementation based on the Version 2.0 specification will occur in parallel with the development of the specification. - For the Version 1.0 specification, the primary task will be to extract the cryptographic primitives from identified sources, confirm alignment with the Rust implementation of AnonCreds, and include the cryptographic primitives in the specification. This is the last step of the specification to make it ready for submission to a standards development organization (SDO). - The Version 2.0 specification, the task will be similar, but the work will extend he focus as appropriate to implementation of the cryptographic primitives.

cryptographygitblockchain+1
1 active years
Explore
Hyperledger - Documentation Standards logo

Hyperledger - Documentation Standards

Hyperledger

To establish consistent and comprehensive documentation standards for the Hyperledger Foundation open-source blockchain platforms. Our goal is to provide developers, users, and other stakeholders with high-quality technical documentation that is accurate, accessible, and easy to understand. Our end goal is to ensure that the technical documentation for the Hyperledger community is of the highest quality, making it easier for developers to build on these platforms and for users to understand and utilize them effectively. Learning Objectives - Develop an understanding of best practices for creating open source documentation - Learn how to collaborate with a community to develop documentation guidelines and templates - Gain experience in technical writing and editing - Learn how to use documentation tools and templates Expected Outcome - A set of documentation guidelines and templates that can be used by all Hyperledger projects - A style guide for Hyperledger documentation - A list of recommended documentation tools and templates - A plan for integrating the new guidelines and templates into existing Hyperledger projects - A series of blog posts or tutorials on how to use the new guidelines and templates

technical writingos documentation toolscommuncation+2
1 active years
Explore
Hyperledger - Documentation and Use Cases for Climate Action logo

Hyperledger - Documentation and Use Cases for Climate Action

Hyperledger

The Carbon Accounting and Certification Working Group is developing an Operating System for Climate Action, which is a set of applications for obtaining and certifying data, creating tradeable tokens for emissions and offsets, and using DAO's to coordinate collective action. As part of this project, we're looking for technical writers who could help both document the technologies and how they could be applied to actual use cases. We've started with a few ideas and would like your help refining them with actual or potential projects. We'd also like help reaching out to and interviewing potential users of the applications to get their feedback on how they could be used. As part of this project, you will learn about 1) Blockchain technologies including Hyperledger Fabric and Ethereum 2) Applications such as Distributed Autonomous Organizations (DAO's) 3) Interviewing skills 4) Technical writing and documentation Expected Outcome Improved documentation of the blockchain carbon accounting applications. Tutorials on how to develop and enhance the applications. Use cases for the applications.

programmingtechnical writingdistributed ledger technology
1 active years
Explore
Hyperledger - Ecosystem Analyst logo

Hyperledger - Ecosystem Analyst

Hyperledger

Implementations of Hyperledger technologies span multiple industries, including finance, supply chain, trade, health, media, telecom and more. The beauty of our open source technology community is that anyone can use and build upon it for their specific needs and use cases. There are hundreds of implementations and capturing them in an easy to find and useful manner is a key enabling tool. Helping our community and the public to better understand use cases is a key part of helping advance the impact of distributed ledger technology. It validates ideas others have, provides avenues for reaching out and sharing lessons learned, and is a key part of building the Hyperledger community. In addition, we would also like to track academic papers and courses related to Hyperledger projects in order to develop an understanding of the academic landscape. In gathering and organizing the above information, the mentee will leverage their broad view of Hyperledger use cases as well as understanding of the overall blockchain space to identify potential opportunities for growth in uses or applications of Hyperledger technology. This can include use cases where our community isn’t as present, where we can explore doing further outreach and education. In addition, the mentee will make recommendations and potentially also work on developing ways for the use case and academic information to be leveraged for educational and ecosystem-building content and activities.

databaseresearchblockchain+1
1 active years
Explore
Hyperledger - Enable Kubernetes Operators support for Fablo logo

Hyperledger - Enable Kubernetes Operators support for Fablo

Hyperledger

Fablo is a tool to generate the Hyperledger Fabric blockchain network and run it on Docker. It's main goal is to provide a super-easy start with Hyperledger Fabric. It has a declarative approach - a whole network is described in a single file. Right now only the Docker environment is supported and we want add support for Kubertnetes Operators. Participating in the project will allow you to gain significant experience with Hyperledger Fabric network lifecycle and Kubernetes Operators. You will work with a "translation" of the current Docker-backed flow to Kubernetes. The expertise gained with working on the project is a good start in a broad range of professional careers related with Hyperledger Fabric and/or Kubernetes. It is also a great warmup before Certificated Fabric Administrator and for Kubernetes certifications. Fablo generates Docker compose file and some bash scripts for automation of the network configuration. We want to add an option to generate network configuration for Kubernetes Operators. We expect following outcome: - Fablo is able to generate YAMLs needed for K8S deployment. IIt can be implemented as a single YAML file deployed by single organization (minimal). It can be also split for multiple organizations for independent deployments (nice to have) - Fablo supports current Docker features for K8S (like, up, down, prune, chaincode upgrade.). The scope of supported features is flexible and depends on the work required for adding basic support for K8S.

linuxbashtypescript+4
1 active years
Explore
Hyperledger - Enhance Blockchain Explorer to accommodate new features for Hyperledger Fabric logo

Hyperledger - Enhance Blockchain Explorer to accommodate new features for Hyperledger Fabric

Hyperledger

Blockchain Explorer is a GUI tool that allows users to view blocks, transactions, nodes, channels, chaincodes and other associated information about the blockchain network. The aim of this project is to enhance the existing application in-terms of new features and uplift the user-interface with the robust design. Blockchain explorer uses fabric-sdk to get the details from the fabric network and stores the data in the postgres database, which is later used by the explorer UI. The developers will get a chance to get involved in the entire software development life cycle with the proposal-implementation of new features, review the peer developed code, write the unit test cases, refining the existing code efficiently to adhere to the coding standards and much more.

hyperledger fabrictypescriptreact+7
1 active years
Explore
Hyperledger - Expand Minifabric with k8s operator support logo

Hyperledger - Expand Minifabric with k8s operator support

Hyperledger

Minifabric supports deploy Hyperledger Fabric in both docker and K8S environments, however, it currently does not support Hyperledger Fabric running as k8s operators. Making Minifabric deploying Hyperledger Fabric onto K8S and running as K8S operators will allow hyperledger fabric network nodes with taking advantages of K8S operator benefit. This work will involve the participators to develop K8S operators, deploying K8S operator controllers and managing K8S operator life cycles, at the same time, the participators will be able to learn Fabric and Fabric deployment model. This is a great opportunity for anyone who would like to know K8S and know Hyperledger Fabric.

goyamlansible+2
1 active years
Explore
Hyperledger - Explorer User Interface redesign logo

Hyperledger - Explorer User Interface redesign

Hyperledger

Blockchain Explorer provides a graphical user interface to explore blocks, transactions, nodes, channels, chaincodes in a blockchain network. The goal of this project is to redesign the user interface of hyperledger explorer project to provide an easy as seamless experience for the user. The goal is to make Blockchain explorer as the common explorer tool for all the hyperledger DLT projects. Learning Objectives - To implement all the user research , analysis and design techniques to design a very compelling user experience for hyperledger fabric. - Gain an indepth understanding of Hyperledger DLT projects. - Developer user experience and user interface design skills. Expected Outcome - User flows , wireframes, style guide and high fidelity mockup of the new user interface design for Hyperledger Explorer

web appadbobe xdfigma+4
1 active years
Explore
Hyperledger - Extend existing Iroha - Cactus integration logo

Hyperledger - Extend existing Iroha - Cactus integration

Hyperledger

Hyperledger Cactus is a blockchain decentralized integration tool designed to allow users to securely integrate different blockchains started by companies Fujitsu and Accenture. Cactus has pluggable architecture which makes easy to integrate various blockchain by creating plugin, currently plugins for Fabric, Besu, Quorum are implemented. Cactus allows to transfer not only assets but also data between multiple blockchains. On the other hand Iroha (version 1.x) is great with asset management, and has functionality to store data, which makes those two projects a perfect fit! In previous HL Summer Mentorship Project the integration was successfully made (link). As a result of the project commands and queries from HL Iroha were integrated, it was Iroha 1.2, but after that year multiple features and changes was added to Iroha (e.g. Healthcheck). What is more - not all nice to have features was integrated (list of missing features). It is also important to make the configuration flexible to make its possible to set up connection between two different blockchain networks (e.g. Iroha → Iroha). In short, the project's goal is to: 1. Implement missing features + tests + documentation 2. Update Iroha version to newest in the integration. 3. Make the plugin configurable 4. Create tutorial demonstrating how to set up connection between multiple networks (at least Iroha - Iroha networks)

node.jsjavascriptopenapi+2
1 active years
Explore
Hyperledger - Extend secure DID Registry for Hyperledger frameworks on Github/Gitlab logo

Hyperledger - Extend secure DID Registry for Hyperledger frameworks on Github/Gitlab

Hyperledger

A DID registry is a type of verifiable data registry that can be simply referred to as a role, a system performs to mediate the functionalities like create, verify, update, and deactivate the decentralized identifiers. The mentee will have an opportunity to learn -- The application and automation of the Decentralized Identity Hyperledger Aries and Ursa code base -- Public key cryptography -- Application of Hyperledger Ursa in enabling Zero-Knowledge proof -- Git, Shell Scripting, RUST -- Open source contribution, documentation, and sense of ownership Expected Outcome -- Command-Line utility to automate the process of creating a DID Registry for the members of organizations utilizing Github/Gitlab as Verifiable Credential Registry, On-boarding organizations, and features for easy management -- Proper test cases and documentations -- Codebase maintained with proper read me document

hyperledger ursashellgit+3
1 active years
Explore
Hyperledger - Fabric-Ethereum token bridging logo

Hyperledger - Fabric-Ethereum token bridging

Hyperledger

One of the key use cases of blockchain integration is asset bridging: in essence, "locking" an asset (typically, a native coin or token) in a smart contract on its authoritative ledger and making available corresponding, newly minted (wrapped/shadow/...) assets on another. By now, bridging is supported by quite mature solutions in the cryptoworld; however, the same is not true for "consortial" distributed ledger technologies. At the same time, such functionality can be expected to become an important requirement in the not too distant future - Analysing the implementation approaches of standard "token models" (ERC20, ERC-721, ... - as far as this has been already done) in native Fabric chaincode and creating conceptual mappings between standard Ethereum token types and Fabric-native assets (including, but not limited to, the different authentication and authorization approaches). - Creating a brief review of the bridging approaches and mature technologies widely used in the cryptoworld. - Performing a requirement analysis for bridging assets from Fabric to Ethereum-based networks (and back), taking into account that the parties performing the bridging have to be explicitly given permission to do so by an authority and may be subject to regulatory requirements. - Based on the available open-source components, designing and prototyping a Fabric-Ethereum bridge fulfilling the requirements As the proposed project bridges multiple fields, creating a centralized solution.

hyperledger fabricethereumsolidity+5
1 active years
Explore
Hyperledger - Git Commit Signing with DID's, Part Deux logo

Hyperledger - Git Commit Signing with DID's, Part Deux

Hyperledger

In the summer of 2019, Hyperledger ran a mentorship geared towards getting the Git version control tool to understand and use cryptographic credentials in decentralized identity (DID) documents to sign and verify commits. The root cause analysis led the project in the direction of creating a patch set for Git that enabled Git to use any signing tool more easily rather than just its existing support for GnuPG. Work is still ongoing to get those patches landed into Git and out in the wild. This mentorship anticipates the completion of that work and extends the previous work with the construction of a software application that can be called by Git to sign/verify commits using credentials stored in DID docs.

pythoncc+++5
1 active years
Explore
Hyperledger - Global Scouting of DLT / Blockchain Educational Opportunities logo

Hyperledger - Global Scouting of DLT / Blockchain Educational Opportunities

Hyperledger

The Learning Materials and Development Working Group at Hyperledger is looking for two enthusiastic mentees willing to scout and map existing opportunities to learn about DLT and Blockchain around the globe. Our Wiki Page is the entry point to the Galaxy of Hyperledger. Our team keeps a Resource Library of Hyperledger Projects and Tools, Use Cases, Key Terms, Learning Materials for Special Interest Groups and Working Groups, Templates, Meetups, Labs, Marketing, and News. As well as a sinopsis of current events, announcements, community events, requirements for Best Practice Badges, GitHub resources. We proof-read edX Blockchain courses for Linux Foundation (Hyperledger). We have 50+ registered and recorded meeting agendas. We want to identify and contact potential allies to link our inner Hyperledger Universe with the rest of the world. We need scouts to explore, register and map the outer territories beyond our community. Mentees shall learn how to structure a taxonomy of DLT / Blockchain Educational Opportunities, where to find them, and how to analyze their objectives and products. They shall build a comprehensive Global Directory of DLT / Blockchain Educational Programs, register their websites, identify their working teams, make initial contact, and identify their potential interest to become part of an Open Source Educational Alliance with LMDWG, Hyperledger, and the Linux Foundation.

communicationscoutingmapping+2
1 active years
Explore
Page 8 of 11
678910

Looking for a program first?

Start with GSoC, European Summer of Code, Outreachy, or LFX — then drill into orgs.

All programs
Hyperledger - Hyperledger Bevel documentation redesign logo

Hyperledger - Hyperledger Bevel documentation redesign

Hyperledger

A documentation serves best when understood and designed based on user needs. Although Hyperledger Bevel current documentation is comprehensive and robust, it still requires improvement and can be much more effective and useful if designed based on user and community needs. The project scopes to structure the existing documentation of Hyperledger Bevel and redesign it from the perspective of user personas and their deployment needs. It would equally benefit product users and developers, and increase usability and adoption. Learning Objectives - Hyperledger Bevel concepts, features and operations - Documentation techniques and best practices - Hyperledger Bevel community, users and use-cases Expected Outcome - Complete redesigned of documentation based on the decided structure and theme

markdownpythonblockchain+1
1 active years
Explore
Hyperledger - Identity Mixer Support for Fabric Gateway SDK for Java and Client API for Java logo

Hyperledger - Identity Mixer Support for Fabric Gateway SDK for Java and Client API for Java

Hyperledger

Idemix is a cryptographic protocol suite, which provides strong authentication as well as privacy-preserving features such as anonymity, the ability to transact without revealing the identity of the transactor, and unlinkability, the ability of a single identity to send multiple transactions without revealing that the transactions were sent by the same identity. More details here - https://hyperledger-fabric.readthedocs.io/en/release-2.2/idemix.html Current JavaSDK doesn't support to store Idemix credentials in Hyperledger Fabric Wallet. Objective of this mentorship program to support wallet to store idimix identities. - Ability to store Idemix Identity in a Wallet by using Fabric Gateway SDK for Java - Ability to store Idemix Identity in a Wallet by using Fabric Gateway Client API for Java - Ability to use the Stored Idemix Identity from a Wallet to fire transaction to the Hyperledger Fabric Network in both Fabric Gateway SDK for Java and Fabric Gateway Client API for Java - Write Unit Tests and Add Examples in fabric-samples Repository

hyperledger fabricjavablockchain+1
1 active years
Explore
Hyperledger - Implement Client Side Security for Climate SIG Fabric Application logo

Hyperledger - Implement Client Side Security for Climate SIG Fabric Application

Hyperledger

The Carbon Accounting and Certification Working Group is developing an Operating System for Climate Action, where there is a Hyperledger Fabric Utility Emissions Channel with utility data. Currently, the security certificates for accessing Fabric are held server side. A client application authenticates the user through standard username/password authentication and then access the Fabric chain code on behalf of the user. We would like to explore a client driven authentication for the Fabric application, similar to how Metamask is used with Ethereum dApps such as the Emissions Tokens Network. In such a use case, the user would sign into a web portal, enter and upload their information, and then sign the transaction with a local security key or a dApp wallet such as Metamask. As part of this project, you will learn about 1) Hyperledger Fabric chain code development 2) REST APIs 3) dApp security and wallets 4) Open source development and project management Expected Outcome Implementation of an application with client side authentication for Hyperledger Fabric utility emissions data channel. Documentation and tutorials showing how this is done.

hyperledger fabricnode.jsweb and dapp security frameworks+1
1 active years
Explore
Hyperledger - Implement a CLI for node interactions in Hyperledger Solang logo

Hyperledger - Implement a CLI for node interactions in Hyperledger Solang

Hyperledger

Hyperledger Solang is a Solidity compiler written in Rust. It currently targets Substrate contracts pallet (Polkadot) and Solana smart contract runtimes. After successful compilation, users need to upload the compiled contract artifacts to a blockchain node, so it can be interacted with. At the time of writing, this needs to be done manually via third-party web front-ends. Which results in an inefficient and tiring process during iterative contract development. The goal of this mentorship is to implement a Command Line Interface (CLI) for Solang that can be used for node interactions instead. This includes uploading and deploying contracts on-chain as well as submitting transactions to contracts.

blockchainsmart contractrust+3
1 active years
Explore
Hyperledger - Implement an SSA intermediate representation for the Solang compiler logo

Hyperledger - Implement an SSA intermediate representation for the Solang compiler

Hyperledger

Solang is an open-source Solidity compiler written in Rust. It generates an intermediate representation in a Control Flow Graph (CFG) for each function in a Solidity contract during compilation. The CFG contains high level expressions and instructions, which help in some aspects of code analysis and optimization, but are not suitable for more advanced optimization passes, such as liveness analysis and partial redundancy elimination. In this project, mentees will have hands-on experience implementing a modern Single Static Assignment intermediate representation for the Solang compiler. This addition will bring many advantages for the compiler, such as the possibility to break down complex constructs into lower level instructions and the facilitation of code analysis. We propose for the mentorship the introduction of a new intermediate representation to live between the existing one (the CFG representation - read more about it at the Additional Information section below) and the LLVM-IR. It should feature three-address code in a Single Static Assignment (SSA) minimal form. The construction of such a form happens in two steps: Phi function insertion Variable renaming The objective is to decouple the types and expressions we have used for the AST from the existing CFG intermediate representation. In addition, the new low level intermediate code must contain assertions that ensure the instructions are created with valid operands and expressions.

compilerrustblockchain+1
1 active years
Explore
Hyperledger - Implement cross chain contract invocation using 'ServiceMesh' way logo

Hyperledger - Implement cross chain contract invocation using 'ServiceMesh' way

Hyperledger

Since permissioned blockchain has been adopted widely in various industries, the need to integrate different permissioned blockchains rises up recently. The two core problems of this case are chain contract interoperability and transaction atomic. Many frameworks and solutions proposed currently are a bit complex. We introduced a lightweight protocol and reference implementation inspired by the ‘ServiceMesh’ pattern in the microservice integration area. Combine with a stateless off-chain relay and an extended on-chain contract development kit as a ‘SideCar’ for different permissioned blockchains. Contract developers can focus on writing business logic since the on-chain contract development kit uses an AOP(aspect-oriented programming) approach to delegate the contract interoperability. In addition it also provides a lock API for locking contract state which can be used in two-phase commit cases. The off-chain relay uses an event based architecture to coordinate different permissioned blockchains. Learning Outcome 1) Implement the on-chain contract development kit for Hyperledger fabric using JAVA. 2) Implement the on-chain contract development kit for Consensys quorum or Hyperledger Besu using Solidity. 3) Implement the off-chain relay plugin for Consensys quorum or Hyperledger Besu.

gojavasolidity+4
1 active years
Explore
Hyperledger - Implement iroha-cpp library for Hyperledger Iroha 1 logo

Hyperledger - Implement iroha-cpp library for Hyperledger Iroha 1

Hyperledger

Hyperledger Iroha 1 is blockchain implemented in C++. To interact with Irohas' nodes (perform commands and queries) there are few client libraries - iroha-python, iroha-javascript, iroha-java, iroha-ios. Despite the fact that Iroha has implemented iroha-cli in C++ there is no client library in C++. What is more iroha-cli is deprecated and not all commands are fully supported. The internship project in short words is to refactor iroha-cli and extract from its iroha-cpp library. Using the library would require project of entire library (inspiration are rest of libraries). Optionally the library should be compatible with C language (extern "C") to make it easy to use the library from multiple programming languages.

c++gitprotobuf+5
1 active years
Explore
Hyperledger - Improve Kubernetes Operators support for Fablo logo

Hyperledger - Improve Kubernetes Operators support for Fablo

Hyperledger

Fablo is a Hyperledger Labs project that aims to manage a local Hyperledger Fabric network on Docker. Previous edition of Hyperledger Mentorship Program resulted with the implementation of the initial, experimental support for Kubernetes Operators (using Bevel Operator). The overall objective of the current mentorship program is to improve test coverage for Kubernetes Operators support for Fablo, implement crucial missing features and fix most important issues that come up as a result of testing. First, the mentee is responsible for implementing Bash scripts with automatic tests of a running HLF network, in a similar manner it is already done for Fablo on Docker. Tests need to verify the support for Fablo’s features, like network lifecycle support, using Fablo hooks, managing complex HLF network topologies, and others. On the basis of it, the mentee is going to create a set of issues and start working on them in the second part of the internship. Additionally the project includes implementing a few Fablo features supporting testing: `fablo invoke/query`, `fablo enroll` and `fablo chaincode list`.

bashdockernode.js+2
1 active years
Explore
Hyperledger - Improve User Experience from Getting Started to Continuous Engagement logo

Hyperledger - Improve User Experience from Getting Started to Continuous Engagement

Hyperledger

Hyperledger India Chapter started with the https://start-here.hyperledger.org to help new developers look for contribution opportunities. The tool provides an option to see through a list of all "Good First Issues", "Open PRs" and "Releases". The requirement, in this proposal, is to extend or improve the website to include - role-based navigation (eg. Developer, Business User, Contributor, etc) to information. The process will involve adding easy to access links or information for project documentation, community contribution guidelines, guiding (new & experienced) users towards how to start & what tasks require contribution, informing the latest happenings within the community (i.e. figuring out available events and meetups), and Calendar(s). The cherry on top of it would be to have navigations defined for different users and search capability. The task would start with the survey on what somebody looks for within the community, understand what troubles them. The project is aimed at providing an improved user experience.

user experience designjavascriptgo lang+7
1 active years
Explore
Hyperledger - Improvement in HLF-Connector, Hardening the production readiness aspects logo

Hyperledger - Improvement in HLF-Connector, Hardening the production readiness aspects

Hyperledger

The HLF-Connector is a project within the Hyperledger Labs community that provides a way to connect to and interact with Hyperledger Fabric Blockchain Networks from external applications using REST APIs & Kafka based Topics. This connector acts as a gateway between Fabric and non-Fabric applications, allowing external applications to securely read and write data to the Fabric blockchain through both synchronous and asynchronous modes of interaction. HLF-Connector provides a convenient and flexible way to integrate Fabric blockchain networks into external applications, allowing developers to build robust and secure decentralized applications that can interact with the Fabric network. Learning Objectives - Understand Hyperledger Fabric conceptually. - Learn enterprise integrations for practical usage of blockchain technology. - Become proficient in micro-service development. - Design API interfaces and work to scale by handling asynchronous interfaces. - Learn open source processes. - Work closely with community experts. Expected Outcome - Design and implement new features in the connector. - Updating the usage documentation.

javablockchainhyperledger fabric+1
1 active years
Explore
Hyperledger - Iroha 2 DSL logo

Hyperledger - Iroha 2 DSL

Hyperledger

Iroha 2 currently has WASM-based smartcontracts. WASM, however, imposes a maintainer burden on the user, so upgrading these takes work. We also have an ISI based on easily upgradeable smartcontract facilities, which are difficult to compose into arbitrary logic but require no manual intervention for upgrading to newer versions of Iroha. We would like to involve the community in creating a domain-specific language for creating and composing logic made out of ISI. Iroha 2 DSL is our most important project. Therefore, we would like it to be considered with top priority if not all Iroha-based projects can be considered for the internship program. Learning Objectives - Explore domain-specific optimisations not ordinarily possible in regular compiler design. - Explore the design of ergonomic languages. - Improve the understanding of Rust. Expected Outcome - (Optional) Well-defined Iroha DSL grammar - A binary application (compiler) that parses DSL and produces ISI according to a well-defined grammar - A set of example files written in the DSL covering the following simple use-cases -Cross-blockchain transfer -Modification of metadata -Transference of permission tokens

rust typerust traitblockchain+1
1 active years
Explore
Hyperledger - Iroha 2 FFI client library bindings logo

Hyperledger - Iroha 2 FFI client library bindings

Hyperledger

Currently, the Hyperledger Iroha v2 clients are linked statically or via a sophisticated code generation process that is both brittle and necessitates an inordinate amount of work for each ABI-breaking change to the Hyperledger Iroha v2 core library. Instead, we plan to create a shared C-ABI-based dynamically linked library that will be used by all clients and SDKs and the reference implementation of a Rust client: iroha_client_cli. Learning Objectives The mentee shall learn about - The C-ABI - The Rust facilities for dynamic linkage - unsafe programming in Rust - low-level structure representations - Undefined behaviour Expected Outcome This project would enable the dynamic linking of SDK, resulting in an improved SDK ecosystem and better support for existing languages like Python or TypeScript.

rustblockchaindlt
1 active years
Explore
Hyperledger - Iroha 2 blockchain explorer update logo

Hyperledger - Iroha 2 blockchain explorer update

Hyperledger

The Iroha 2 blockchain explorer is a web-based UI that inspects the entire state of an Iroha v2-based blockchain. In the scope of this internship, the mentee shall learn how to construct a frontend service to a blockchain, organise the UI and cater to unique challenges associated with the specific needs of specific blockchain ledgers such as Hyperledger Iroha v2. Learning Objectives The mentee shall learn how to: - Build a web-based UI in Vue. - Connect said Web-based UI to a backend service. - Implement UTF-8-based encoding of public keys (optional). - Learn about UI/UX challenges associated with making things work cross-platform, cross-form-factor. Expected Outcome - The state of the Iroha v2 blockchain explorer shall be improved.

rustjavascripttypescript+2
1 active years
Explore
Hyperledger - Learning Tokens logo

Hyperledger - Learning Tokens

Hyperledger

We propose to use the composable Interwork Alliance Token Taxonomy Framework (IWA TTF) to produce a Learning Token that recognizes, registers, and rewards community engagement in teaching and learning experiences, certifying, at the same time, the acquisition of skills and competencies. Communities that agree upon valuable behaviors can turn those behaviors into unique token representations of their value and set up clear rules for its creation and supply, able to resist modification or tampering, and, most important, capable of being transferred per-to-peer. Our Learning Token is proof of behaviors that benefit learning communities, individual members, and collectivity. With IWA TTF, we shall define common token concepts with a clear understanding of our requirements. We shall specify properties for particular behaviors. We shall link their base Token Classification Hierarchy with our Taxonomy of DLT / Blockchain Educational Opportunities as initial meta-data for standard artifacts and control message descriptions.

collective learningcommunity engagementhyperledger fabric+3
1 active years
Explore
Hyperledger - Learning Tokens @ Hyperledger Besu logo

Hyperledger - Learning Tokens @ Hyperledger Besu

Hyperledger

Learning Tokens register the process of transfer and acquisition of knowledge. They track what we know and how we learned it in individual profiles that help personalize education. They measure engagement in the transfer of knowledge, support educational management, and foster Anatole France's words, nine-tenths of education is encouragement. Learning Tokens recognize, register, and reward community engagement in collective learning while certifying skills acquisition and individual competencies. In 2021, we did a global directory of DLT/Blockchain learning places. Last year, we defined artifacts for learning tokens, and now we shall code their Smart Contracts for MOOCs. Learning Objectives - Understand the tokenization of learning experiences. - Use the Inter Work Alliance Token Taxonomy Framework, IWA-TTF. - Apply IWA Token Designer to create Learning Tokens Templates. - Deploy them in Hyperledger Besu. - Understand granular learning interactions in MOOCs. - Explore simple ways to integrate Learning Tokens and MOOCs. Expected Outcome - Deploy Learning Tokens in Hyperledger Besu. - Report about connecting IWA-TTF to Hyperledger Beso - Explore alternatives to integrate Learning Tokens into MOOCs. - Report about possible alternatives to integrate Learning Tokens into MOOCs

solidityjavascripthyperledger besu+5
1 active years
Explore
Hyperledger - Make Solidity Language Server Functional logo

Hyperledger - Make Solidity Language Server Functional

Hyperledger

A language server is what makes it possible to rich editing like to go to definition or code completions in source code editors. The Solang Solidity Compiler does have a language server, but it is very rudimentary. The aim of this mentorship is to make the language server much more complete, will make developing Solidity code using this language server will be a much greater developer experience. During this mentorship you will learn how language servers work, and you'll need to walk the parsed Solidity abstract syntax tree in various ways to for example find where a variable is defined (Go to definition), or to find all usages of a variable (Find all references), or find the type definition (Go to type definition). This means walking a complex data structure, and understanding how source code is represented as a abstract syntax tree, which is the result of parsing and semantic analysis, the first stage of an compiler.

parserssyntax treerust+3
1 active years
Explore
Hyperledger - Multiple Data Integration to Fabric Climate Accounting Network logo

Hyperledger - Multiple Data Integration to Fabric Climate Accounting Network

Hyperledger

The Hyperledger Labs blockchain-carbon-accounting project includes a Hyperledger Fabric network for recording the carbon and Greenhouse Gas (GHG) emissions that cause climate change. Since there are many activities that cause such emissions, the network is designed to accept data from multiple sources of measurements. In this project, we will demonstrate integrations from measurement sources with blockchain networks by integrating the ThoughtWorks cloud computing emissions calculator, the NREL OpenPath mobile application, and other web- and mobile-based API's sources to turn instrumented readings into emissions measurements. It will leverage previous projects involving Hyperledger Cactus, Vault security engines, and client security for Hyperledger Fabric.

node.jshyperledger fabrichyperledger besu+4
1 active years
Explore
Hyperledger - Onboarding Mentor and Mentee Program logo

Hyperledger - Onboarding Mentor and Mentee Program

Hyperledger

In collaboration with the Mentors, the Mentee can provide valuable updates to the Hyperledger Onboarding Documentation and the Hyperledger Start Here guide (https://start-here.hyperledger.org/) to help new community members gain a quicker and deeper understanding of Hyperledger blockchain projects and technology. The expected outcome would be for the mentee to update the Hyperledger Onboarding Documentation and the Hyperledger Start Here guide (https://start-here.hyperledger.org/) to help new community members gain a quicker and deeper understanding of Hyperledger blockchain projects and technology. This would be through the development of content and graphics that are relevant to the onboarding process, based on research and outreach to members of the Hyperledger Community. The mentee will create personas and process flow diagrams to arrive at the best framework for consolidating the Hyperledger onboarding documentation into a unified and easy to access resource. Update the dashboard and the landing page for driving the user engagement. Develop the ability to search events and happenings within the Hyperledger community.

user experience designhtmlcss+6
1 active years
Explore
Hyperledger - One-stop-shop Hyperledger Fabric performance analysis with Hyperledger Caliper logo

Hyperledger - One-stop-shop Hyperledger Fabric performance analysis with Hyperledger Caliper

Hyperledger

Performance evaluation of DLTs is a complex process stemming from the inherent complexity of distributed systems. One way to mitigate such complexity is the separation of concerns: use task-oriented solutions for different aspects of the process: - The System Under Test (SUT) is deployed in a representative operating environment. - A dedicated, purpose-specific load generator tool submits representative requests to the SUT. - The SUT is closely monitored during the load generation process, and the measured data is typically stored for post-mortem analysis. - A detailed analysis is performed on the measured data using dedicated data analysis techniques. A summarizing report is the typical final output of the process, containing insights about the SUT. Hyperledger Caliper provides capabilities to integrate lightweight components that can retrieve aggregated results from external components and incorporate them into the generated report. The goal of the project is to provide a single entry/exit point to the performance analysis (once the SUT and its monitoring are configured) by: Providing an open, well-designed, and thoroughly documented side-car service for the detailed performance analysis of distributed Fabric transaction traces. And integrating it into the Caliper load generation and response measurement process as part of the final report. The project will heavily build on the PSWG's Performance Sandbox, aiming to "standardize" its flow and methodologies independently

gitnode.jsdata analysis+2
1 active years
Explore
Hyperledger - Optimising pipelines using Github Actions for Caliper and Caliper-Benchmarks logo

Hyperledger - Optimising pipelines using Github Actions for Caliper and Caliper-Benchmarks

Hyperledger

Performance benchmarking distributed systems (such as DLTs) is a challenging task, comprising of multiple aspects, such as scalable workload generation, representative workload definitions, and comprehensive data analysis. Hyperledger Caliper is a general-purpose benchmarking tool with the goal of mitigating the aforementioned aspects of performance benchmarking. Hyperledger Caliper-benchmarks provides a set of example benchmarks for use with Hyperledger Caliper. In order to be able to assist maintainers/contributors to Caliper and Caliper-Benchmarks, a build system is utilised to run tests to verify a PR doesn't break anything plus it provides a continual deploy mechanism to publish Hyperledger Caliper artifacts to DockerHub and NPM so end users can have access to the Caliper tool. These build systems use different build pipeline implementations. The goal of this project is to optimise how Caliper and Caliper-Benchmarks verify PRs and publish artifacts using Github Actions and to improve how testing is done to ensure that the artifacts to be published actually work as expected.

gitbashjavascript+4
1 active years
Explore
Hyperledger - Performance analysis and Benchmarking of Besu using Caliper with complex workloads logo

Hyperledger - Performance analysis and Benchmarking of Besu using Caliper with complex workloads

Hyperledger

The objective of this project is to perform a performance and benchmarking analysis of BESU, a Hyperledger project, in private networks (QBFT, IBFT, CLIQUE) using Hyperledger Caliper. This project aims to identify the strengths and weaknesses of BESU in terms of maximum transactions per second, latency, computation power, hard disk space, etc. Additionally, this project aims to add support for more complex and well-known workloads like ERC20, ERC721 in Caliper, which are used by general Ethereum users. This project will provide valuable insights into the performance of BESU and will help developers optimise it for better performance. Learning Objectives Through this project, the mentee will: - Develop skills in benchmarking and performance analysis of blockchain networks - Gain experience in working with Hyperledger Besu and Hyperledger Caliper - Learn to add support for new workloads in Caliper - Improve their programming skills by working on a real-world open-source project - Learn to write technical research reports and documentation. Expected Outcome The expected deliverables of this project are: - A detailed report on the performance of BESU in private networks (QBFT, IBFT, CLIQUE) - A set of benchmarks for BESU in private network with different configurations - Support for ERC20, ERC721, etc workloads in Hyperledger Caliper - Documentation on how to use the benchmarking tool and the new workloads.

javajavascriptblockchain+1
1 active years
Explore
Hyperledger - Privacy-preserving federated learning framework based on Fabric and Aries logo

Hyperledger - Privacy-preserving federated learning framework based on Fabric and Aries

Hyperledger

This project utilizes Hyperledger Fabric to develop a federated learning framework with committee consensus. Hyperledger Fabric is used for storing and tracing global model update exchange. A customized committee consensus mechanism is required to reduce a load of consensus computation by selecting a random smaller subset of nodes to participate in consensus each round. In order to protect the identity of local data owners, the proposed framework will be integrated with Indy, Aries, and Ursa stack projects to offer self-sovereign identity. The mentee will work with the project mentors to gather and validate the requirements, and design the appropriate technical solution.

hyperledger fabrichyperledger arieshyperledger indy+3
1 active years
Explore
Hyperledger - Runtime-checked automated programming for chaincode development logo

Hyperledger - Runtime-checked automated programming for chaincode development

Hyperledger

Can we make ChatGPT write chaincode for us? Automated programming for other blockchain platforms is an already emerging topic, but Fabric has not been really addressed yet. This is an experimental mentorship with equal weight in research and hands-on coding, with the following goals. - To review existing examples and approaches of automated programming for smart contracts of other platforms (i.e., Solidity). - To explore the technically feasible options of automated chaincode programming for Hyperledger Fabric (incl. ChatGPT) and select one for further work. - To formulate a chaincode specification style which “seems to work well enough” on a set of representative examples with automated programming. (We don’t know yet what will work; One-shot or iterative? Requirement set or Behavior-Driven Development (BDD)? Conversational or formal specification? And so on.) - To create support for translating the specification partially or fully to runtime verification code, which can wrap the chaincode implementation. On the last point: starting from a specification is a tried and tested way to create verifier code either manually or automatically and is much easier to do correctly than creating the implementation correctly from a specification. We plan to keep this last point “classic”: i.e., no ChatGPT here. Specification-based verification criteria are usually amenable to development time verification, too (with static analysis, model checking, etc.).

chaincodehyperledger fabricblockchain+1
1 active years
Explore
Hyperledger - SLA Self-Assessment with Hyperledger Fabric logo

Hyperledger - SLA Self-Assessment with Hyperledger Fabric

Hyperledger

The overall project plan is divided into three phases while the mentee is properly guided by their mentor in each phase. 1. In the first phase, the development of the Fabric chaincodes for the SLA operations and their integration points occurs in the context of an entire decentralized architecture. 2. In the second phase, building on the required interactions with on- and off-chain data is addressed with details as understood and designed on the previous phase. 3. Finally, the holistic approach is developed in the third phase, where permissioned ecosystem is formed end-to-end and its related documentation is produced.

hyperledger fabricslacollaborative+2
1 active years
Explore
Hyperledger - Solang Solidity Compiler optimizations and error handling logo

Hyperledger - Solang Solidity Compiler optimizations and error handling

Hyperledger

Solang is a Solidity compiler that targets several blockchains, including Solana, Substrate and ewasm. The mentorship project consists of three goals that can provide mentees with a broad knowledge of a compiler's inner-workings. The three tasks are in different stages of the compiler. Solang’s parser analysis halts compilation entirely when there is any invalid expression or function declaration. This should be improved so that it continues parsing the Solidity contract after encountering an error, providing better diagnostics (warnings and errors) to the developer. The parser utilizes Lalrpop and the mentee would be using its error handling capabilities to implement a solution. Often the length of a dynamically allocated array is known at compile time as the allocation happens with a constant. When the length is required at some later point (e.g. for bounds checks for array indexing), the length is retrieved again. Mentees will add an optimization to make the length a compile time constant. Solang has an implementation of multiplication of integers of 256 and 128 bit. This does not have overflow detection. This requires improving the multiplication in the solang stdlib.

compileralgorithmdata structures+3
1 active years
Explore
Hyperledger - Support Decentralized Governance for Smart Contracts in Fabric Python SDK logo

Hyperledger - Support Decentralized Governance for Smart Contracts in Fabric Python SDK

Hyperledger

With the introduction of Fabric v2.x, a more decentralized way of chaincode management is implemented. There are several improvements over the previous lifecycle and it requires several changes on the sdk. This project aims to support decentralized governance for smart contracts in fabric python sdk and add features such as private data sharing/verifying and external chaincode launcher. The projects will provide a user-friendly and easy-to-use tool for fabric developers and operators. Learning Objectives 1) Contributing and collaborating in an open-source project 2) Advanced understanding for DLT(distributed ledger technology) 3) Understand the basic workflow of fabric 4) Being able to implement features for SDK 5) Writing good documentations Expected Outcome 1) update on the chaincode lifecycle management --Multiple organizations must agree to the parameters of a chaincode --Deliberate chaincode upgrade process --Simpler endorsement policy and private data collection updates --Inspectable chaincode packages --Start multiple chaincodes on a channel using one package --Chaincode packages do not need to be identical across channel members 2) add private data sharing & verifying features 3) (optional) add features for writing smart contracts in python

pythondltfabric+3
1 active years
Explore
Hyperledger - Support NFT standards in Weaver for cross-network asset operations logo

Hyperledger - Support NFT standards in Weaver for cross-network asset operations

Hyperledger

Weaver, a Hyperledger labs project, is a DLT interoperation framework that supports data sharing, asset exchange and asset transfer between blockchain networks built on independent DLTs while preserving core blockchain tenets of decentralization of the participating blockchains and without relying on trusted mediating individuals or networks. True interoperability of tokens among different networks, whether they are built on permissoned or open blockchain technology, requires standards around tokens so that they can be exchanged or transferred across network boundaries independent of the underlying DLT implementation. The Enterprise Ethereum Alliance (EEA) has made significant strides in this direction by drafting ERC (Ethereum Request for Comments) standards for managing different types of assets. The widely used ERC-20 standard helps manage fungible token types, whereas ERC-721 and ERC-1155 standards help manage non-fungible token (NFT) types and multi-token types respectively. The scope of the project covers interoperation support for these three prominent ERC token types across Hyperledger Fabric, Corda and Hyperledger Besu networks. Weaver currently supports interoperation between ERC-20 token types for Hyperledger Besu networks. The goal of this project is to add support for ERC-721 and ERC-1155 standards for interoperation among Hyperledger Besu networks, and extend support for ERC-20, ERC-721 and ERC-1155 token types to interoperate across all three DLT platforms.

soliditynode.jsgo+2
1 active years
Explore
Hyperledger - Technical Deep Dive Workshop Content Creation for Hyperledger Cactus logo

Hyperledger - Technical Deep Dive Workshop Content Creation for Hyperledger Cactus

Hyperledger

We are in the inception of interoperability, and Hyperledger Cactus plays a central role. In this internship, you will learn about blockchain interoperability and Hyperledger Cactus. The project is about two main goals: 1) becoming knowledgeable in interoperability and an expert in Hyperledger Cactus 2) producing content for a ~4 hour-long interoperability workshop that the Cactus maintainers are planning on creating sometime in the fall of 2022. Apart from creating content, the interns are encouraged to also contribute to Cactus' documentation and fix bugs that may come up during the production of the content itself. An example for the latter would be when the intern is trying to put together a tutorial for something and it turns out that the feature being demonstrated has a problem with it that needs fixing before the content can be presented. The opportunity is two-fold: 1) Make valuable contributions to the Hyperleger Cactus codebase - experiencing the OSS workflow end to end 2) Have the opportunity to present/demonstrate certain parts of the framework in the workshop itself (if the intern is so inclined - this is definitely what the mentors will recommend they do of course)

gitdockernode.js+6
1 active years
Explore
Hyperledger - Telecom Decentralized Identities Network logo

Hyperledger - Telecom Decentralized Identities Network

Hyperledger

The proposed integration of Decentralized Identity (DID) with telecom services aims to provide customers with a secure and convenient way to manage their digital identities, while also offering telecom companies an opportunity to become trusted identity brokers. The integration addresses the challenge of maintaining customer engagement by enabling customers to have a single identity that they can use to access services. The integration also presents a significant opportunity for telecom companies to become identity brokers, leveraging their existing customer base and regulatory relationships. As issuers of verified KYC information, telecom companies can support identity verification by offering APIs to third-party service providers. The integration of DID with telecom services has the potential to revolutionize the telecom industry and offers significant benefits to customers and operators alike.

blockchainnode.jsreact+6
1 active years
Explore
Hyperledger - The Giving Chain logo

Hyperledger - The Giving Chain

Hyperledger

The Giving Chain is a Social Impact project created by the Hyperledger Princeton Meetup. The Purpose of the project is to decentralize local charity giving by creating the Giving Chain and the R2D application. The application will use participants cell phones to create an asset to be donated. The R2D (Recipient to Donor) then notifies the participant in the giving chain that an asset has been created and ready to be donated. The asset is then track till it is received by someone with need. This donation system lets donors track donation as well as creating a dignified way in which people can receive assistance. Learning Objectives 1) Create a supply chain blockchain. 2) Examine the relationships needed to create a Social Impact Project Expected Outcome An operational blockchain that will revolutionize local charity giving. can also be adapted for targeted disaster relief

blockchaindistributed ledger technology
1 active years
Explore
Hyperledger - The Use of NLP and DLT to Enable the Digitalization of Telecom Roaming Agreements logo

Hyperledger - The Use of NLP and DLT to Enable the Digitalization of Telecom Roaming Agreements

Hyperledger

The project looks at how to facilitate the process of Telecom roaming agreements drafting and negotiation. The project looks at first constructing a library of drafting articles with a set of variables that will be extracted from the available templates and previous roaming agreements using Natural Language Processing process NLP. The second part will be towards translating the drafting and negotiation process as a chaincode on Blockchain to digitalize the process and provide a maintainable and actionable copy of the agreement. The project focus on how to be able to digitalize the legal process and make it automated through smart contracts to be more efficient and less error prone. The expected outcome of this project, would include: 1. Building a drafting library and an NPL model that will include a digital version of the most relevant and important articles in a the GSMA AA.12, AA.13 and AA-14 roaming agreement templates. 2. Developing a chaincode that will map all steps of the drafting and negotiation business processes for roaming agreements. 3. Building a PoC for UI to handle the agreement construction 4. Writing a solution document summarizing the implementation details

fabricjavascriptgo+3
1 active years
Explore
Hyperledger - Towards Blockchain Interoperability logo

Hyperledger - Towards Blockchain Interoperability

Hyperledger

This project intends to propose a solution to this real-world problem, and it is research-focused. The goal is to give a strong contribution to the Hyperledger ecosystem in terms of the state of the art in blockchain interoperability. Some questions that this project aims to answer are: How can we interoperate Hyperledger technologies with other blockchains?, How can Hyperledger initiatives position themselves to tackle blockchain interoperability?, What standards we require to define middleware between blockchains? What are the consequences of employing smart contracts with external processes and data (the external part means another connected blockchain)?, The key to the survivability of this technology? In other to try to answer those questions, in this project the mentee(s) will start by studying some of the most prominent blockchain interoperability solutions already available or being proposed, and how they can be used to promote and strengthen Hyperledger technologies. Then, the mentee will design and develop a framework for creating, deploying and maintaining services with several blockchains. The applicability of the solution to be proposed is to be demonstrated through the exploration of a use case, implementing several blockchains (including Hyperledger Fabric) to increase the dependability of blockchain-powered services administrated by several stakeholders, serving as a proof-of-concept.

blockchainhyperledger fabricjavascript+6
1 active years
Explore
Hyperledger - Upgrade Fabric network from 1.4.x to 2.2.x using Hyperledger Bevel logo

Hyperledger - Upgrade Fabric network from 1.4.x to 2.2.x using Hyperledger Bevel

Hyperledger

yperledger Bevel supports production-worthy deployments for Hyperledger Fabric. And all production systems need to undergo updates which can often be live-updates. This project aims to complete a live upgrade of a Hyperledger Fabric network from version 1.4.x to 2.2.x using Hyperledger bevel and document the steps as well as make any changes needed to automate any steps possible.

hyperledger fabricansiblehelm+3
1 active years
Explore
Hyperledger - Visual Studio Code support for Hyperledger Caliper artifacts logo

Hyperledger - Visual Studio Code support for Hyperledger Caliper artifacts

Hyperledger

Performance benchmarking distributed systems (such as DLTs) is a challenging task, comprising of multiple aspects, such as scalable workload generation, representative workload definitions, and comprehensive data analysis. Hyperledger Caliper is a general-purpose benchmarking tool with the goal of mitigating the aforementioned aspects of performance benchmarking: 1. It provides a flexible architecture to allow scalable workload generation. 2. It collects and reports results based on detailed client-observable execution traces. 3. It allows the implementation/plug-in of custom workload behaviors to meet the diverse criteria of a wide range of business scenarios. The flexible support of the aforementioned performance benchmarking aspects inherently makes the setup and configuration of a Caliper-based project cumbersome and error-prone: - The user must provide information about the system under test (SUT) in the form of a network configuration file. - The user must also specify the flow of the benchmark run in the form of a benchmark configuration file. - The runtime behavior of Caliper components can be influenced in detail through a configuration file. - As with most programming-related projects, a Caliper-based project should employ best practices to make its structure flexible and maintainable. The goal of the mentorship project is to deliver a Visual Studio Code extension that can help users perform the aforementioned tasks in an assisted and possibly automated manner.

gitnode.jsvisual studio+5
1 active years
Explore
Hyperledger - Visualization and Analysis of Cross-chain Transactions logo

Hyperledger - Visualization and Analysis of Cross-chain Transactions

Hyperledger

The emergence of blockchain interoperability is reducing the risk of investing in blockchain by avoiding vendor lock-in, leveraging interoperation with off-chain systems, and providing a truly open ecosystem, enabling a network of blockchains. However, there are very limited efforts on the value/semantic level of interoperability - which soon will become a bottleneck for interoperability. In particular, the human-challenges related to the adoption of such technology have received little attention, with few significant contributions to date. Yet, real innovation can be achieved only by adopting a holistic approach. Designing for blockchain interoperability poses several socio-technical challenges thus offering a unique opportunity to link the underlying technology with human experience and values. This project aims to advance the state of the art on understanding blockchain interoperability on the value/semantic layers - In particular, how can someone conjugate human-centric design, service design, and sustainability to blockchain interoperability? How can one make informed choices on the best cross-chain synergies? How can someone visualize cross-blockchain transactions? Expected Outcome 1 ) Implementation, testing, and documenting the set of technological artifacts required to answer the research questions 2) Scientific paper (or technical report) on the achieved results, that can be used to disseminate the knowledge created on this internship

blockchainangularreact+3
1 active years
Explore
Hyperledger - aries-vcx based message mediator logo

Hyperledger - aries-vcx based message mediator

Hyperledger

Implement message mediator service written in Rust with pick-up v2 protocol support on top of aries-vcx crate. Learning Objectives - Learn about self sovereign identity and Aries protocols - Learn about writing scalable server applications - Learn Rust language - Learn Github Actions and CI process in general Expected Outcome - Web service for Aries message mediation - CI jobs to test the implementation

programmingblockchaindlt
1 active years
Explore
Hyperledger - aries-vcx next-gen mobile wrapper logo

Hyperledger - aries-vcx next-gen mobile wrapper

Hyperledger

Implement rust wrapper around aries-vcx to enable consuming the library in mobile setting using modern FFI approach using uniffi library. Additionally implement aries mediator client to unlock full mobile support. Learning Objectives - Learn about self sovereign identity and Aries protocols - Learn Rust language - Learn basics of Kotlin language, basics of Android development - Learn Github Actions and CI process in general - Learn about FFI (Foreign Function Interface) by using uniffi library Expected Outcome - uniffi_aries_vcx rust crate which generate mobile bindings for aries-vcx library - implement mediator client with aries message pick-up protocol support - simple android demo application which can be run in simulator - CI job to build Kotlin and iOS bindings, CI job to test the wrapper

programmingblockchaindlt
1 active years
Explore
Hyperledger - making chaincode fault tolerant software logo

Hyperledger - making chaincode fault tolerant software

Hyperledger

The proposed project includes the following key activities: A systematic review of the applicability of fault-tolerant software patterns to Hyperledger Fabric chaincode as the potentially faulty software Creation of programming idioms for applying the applicable patterns to Hyperledger Fabric chaincode Prototyping "fault tolerance gadgets" (libraries) for easy application to chaincode The book "Patterns for Fault Tolerant Software" from R. Hanmer (Wiley, 2013) is a good reference of the patterns that the project will target. This is a research-focused project which is relatively light on programming. At the same time, a rather deep dive into the workings of Hyperledger Fabric is expected.

hyperledger fabricanalytical thinkingblockchain+1
1 active years
Explore
Hyperledger AnonCreds v2 ZKP-based Credential Revocation Manager Implementation logo

Hyperledger AnonCreds v2 ZKP-based Credential Revocation Manager Implementation

Hyperledger

Hyperledger AnonCreds v2 takes the privacy-preserving features of AnonCreds v1 Verifiable Credentials to a new level. AnonCreds v2 adds support for newer, mature cryptosuites (including BBS+ Signatures), and for a number of important Zero Knowledge Proofs (ZKP) that enable an even better balance between verifiability and privacy. AnonCreds v2 also adds a crucial new, highly-scaled approach to ZKP-based credential revocation – a crucial element of almost all verifiable credential ecosystems. Called ALLOSAUR, this new scheme allows a single revocation registry to be created by an verifiable credential issuer that scales to support millions of credentials in a fast, low-data manner. Instead of sharing millions of credential revocation statuses (revoked or not), the scheme relies on the transfer of just a handful of integers between participants, enabling secure revocation without a verifiable credential holder from having to share a correlatable identifer for themself to the verifier. ALLOSAUR requires the creation of a new component in the verifiable credential ecosystem, the revocation manager, which is the goal of this Hyperledger Mentorship – to implement a scalable ALLOSAUR revocation manager. The implementation will at least be partially in Rust, with flexibility on the choice of languages/frameworks for the web service.

cryptographyzero knowledge proofsgit+2
1 active years
Explore
Hyperledger Besu - Create K8 / Openshift Operators logo

Hyperledger Besu - Create K8 / Openshift Operators

Hyperledger

Hyperledger Besu is an Ethereum client written in Java. Operators are a method of packaging, deploying, and managing a Kubernetes or an OpenShift application. This project aims for the mentee to design, build and test operators for Project Besu. The code to this will then become part of the Besu project and added to the code repository.

programmingkubernetesopenshift+3
1 active years
Explore
Hyperledger Cacti - Core Operators Modules for DLTs logo

Hyperledger Cacti - Core Operators Modules for DLTs

Hyperledger

Cacti provides modules, toolkit, and protocols to enable networks built on distributed ledgers to interoperate and carry out transactions spanning their boundaries, such as asset transfers, asset swapping, and ledger data communication. For ease of building DLT-agnostic protocols in Cacti, we need to build modules corresponding to various DLTs supported by Cacti that implement these core operators and expose them using a standard API. The goals of this project are as follows: 1. Design and build DLT-specific core operator modules for Cacti by leveraging existing Cactus or Weaver packages. This involves identifying building blocks of unique features in either, and integrating legacy Cactus and Weaver packages wherever they offer a common feature. 2. Design and implement a common DLT-agnostic API, following the OpenAPI standard, using which any DLT-specific core operator module can be invoked by application-specific business logic on-demand. 3. Add suitable API support within the common Cacti client API for ease of application development 4. Do a research survey of existing blockchain/DLT literature to identify a potentially exhaustive set of core operators any DLT network must possess (or harness) to interoperate with other networks.

node.jsgolangjava+5
1 active years
Explore
Hyperledger Cactus - Cactus-samples - Business Logic Plugins for Hyperledger Cactus logo

Hyperledger Cactus - Cactus-samples - Business Logic Plugins for Hyperledger Cactus

Hyperledger

The Hyperledger Greenhouse, powered by the Hyperledger Foundation, provides several Business Blockchain Frameworks & Tools, some of which compose the state of the art private blockchains. In particular, Hyperledger Fabric is amongst the most famous permissioned blockchains; Hyperledger Indy tackles the first big initiative to promote decentralized identity support; Hyperledger Caliper is a comprehensive blockchain-testing framework; Hyperledger Quilt enables a specific type of blockchain interoperability - enables payments across any payment network — fiat or crypto - using the Interledger protocol. Cactus is a blockchain integration tool designed to allow users to securely integrate different blockchains, promoting blockchain interoperability. This way, Hyperledger Cactus aims to provide Decentralized, Secure, and Adaptable Integration between Blockchain Networks. Hyperledger Cactus is currently undergoing a major refactoring effort to enable the desired to-be architecture which will enable plug-in based collaborative development to increase the breadth of use cases & Ledgers supported. To fully explore Cactus’ capabilities, and to promote the project’s adoption, one needs several business logic plugins that realize cross-blockchain use cases (similarly to fabric-samples). Many are proposed on the whitepaper, but few are implemented.

blockchaintypescriptresearch+4
1 active years
Explore
Hyperledger Caliper - Declarative workload behavior definition for Hyperledger Caliper logo

Hyperledger Caliper - Declarative workload behavior definition for Hyperledger Caliper

Hyperledger

Hyperledger Caliper is a general-purpose benchmarking tool with the goal of mitigating the aforementioned aspects of performance benchmarking. It allows the implementation/plug-in of custom workload behaviors to meet the diverse criteria of a wide range of business scenarios. Implementing a workload module for Caliper currently has some limitations and usability obstacles. The goal of the project is to provide means for defining complex workload behaviors in Caliper in a declarative manner, using solely/mostly configuration files. This should be accomplished with a general built-in workload module implementation that acts according to a configuration-based workload specification. Expected Outcome The mentee must complete the following tasks by the end of the internship: 1) Survey the workload definition capabilities of relevant workload generators/benchmark tools and typical workload requirements of relevant standards or existing workloads. 2) Specify/design a flexible and extendable YAML-based configuration schema for the declarative definition of complex workloads. 3) Implement a built-in Caliper workload module capable of generating requests based on the above configuration. 4) Thoroughly test the implemented module. 5) Provide developer and user documentation for the schema and the implemented module. 6) Port some of the Caliper microbenchmarks to the declarative schema as proof of concept.

gitjavascripthyperledger caliper+2
1 active years
Explore
Hyperledger Caliper documentation platform update logo

Hyperledger Caliper documentation platform update

Hyperledger

The goal of the project is to enhance the accessibility, consistency, and comprehensiveness of the Caliper documentation. This mentorship project aims to transition the current Caliper documentation site to utilize the common documentation template adopted by Hyperledger projects. This standardization effort will ensure a seamless user experience across Hyperledger documentation, facilitating easier navigation and comprehension. Furthermore, the project will focus on content improvement to ensure that the documentation covers all aspects of Hyperledger Caliper comprehensively, including installation, configuration, usage, and troubleshooting, with up-to-date and accurate information. The mentee can gain a wealth of knowledge and skills that are valuable not just for this specific project but for their professional development in technical writing, documentation management, and basic understanding of blockchain technology.

markdownhyperledger caliperdocumentation frameworks+2
1 active years
Explore
Hyperledger Caliper testability and robustness improvement logo

Hyperledger Caliper testability and robustness improvement

Hyperledger

This mentorship project aims to significantly improve the testability, test coverage, and robustness of the Hyperledger Caliper blockchain benchmark platform. Hyperledger Caliper is a blockchain benchmark tool that allows users to measure the performance of a specific blockchain implementation with a set of predefined use cases. The project will involve assessing the current testing framework, identifying gaps in test coverage, designing and implementing comprehensive test suites, and integrating best practices for testing to ensure the platform's reliability and performance. Expected Outcome and Deliverables - Comprehensive Test Suites: Develop and implement a suite of tests that cover all aspects of Hyperledger Caliper, ensuring high test coverage. - Documentation: Provide detailed documentation on the testing framework, test cases, and guidelines for future contributions to maintain test quality. - CI/CD Pipeline: A fully functional CI/CD pipeline that automates the testing process, ensuring that every contribution is thoroughly tested. - Contributor documentation: A detailed documentation about the internal working of Caliper components to facilitate future contributions.

javascriptnode.jsblockchain+3
1 active years
Explore
Hyperledger Cello - Operate Blockchain Network in an Efficient Way logo

Hyperledger Cello - Operate Blockchain Network in an Efficient Way

Hyperledger

Today, most users adopt Blockchain in order to collaborate with each other, however, it is difficult to manage a large blockchain network because of multiple organizations and nodes. Hyperledger Cello is aiming to resolve the following challenges, 1) Facilitate creation of blockchain network, can help user without blockchain background to setup their network nodes quickly. 2) Cross organization communication, can connect blockchain networks among multiple organizations. This project targets to design and implement a practical operational system equipping with decentralized functionalities to solve above challenges, based on Hyperledger Cello code base. Learning Objectives 1) Work closely with community experts and developers to learn the open-source culture and skills; 2) Learn the advanced knowledge inside the blockchain and distributed ledgers; 3) Practice hand-on experience with web application design and implement. Expected Outcome Help design and implement the blockchain operation dashboard and api server.

fabricpythonnode.js+6
1 active years
Explore
Hyperledger Cello - Operate and Govern Blockchain Networks in Decentralized Way logo

Hyperledger Cello - Operate and Govern Blockchain Networks in Decentralized Way

Hyperledger

Blockchain is helpful for collaborative applications, however, it is difficult to manage because of the decentralized features. Another challenge is how to efficiently govern a blockchain network among various organizations. Hyperledger Cello is aiming to resolve the following challenges, 1) Facilitate creation of blockchain network, can help user without blockchain background to setup their network quickly. 2) Security, need to implement mechanism to protect key pairs. 3) Cross organization communication, can connect blockchain networks among multiple organizations. This project targets to design and implement a practical operational system equipping with decentralized functionalities to solve above challenges, based on Hyperledger Cello code base.

distributed systempythonnode.js+10
1 active years
Explore
Hyperledger Collaborative Learning - A Distributed Smart Contract Management - Unpaid logo

Hyperledger Collaborative Learning - A Distributed Smart Contract Management - Unpaid

Hyperledger

Cello, as a decentralized BaaS, has been able to help users create blockchain networks and achieve channel management. Cello will help users to install, instantiate and test smart contracts. Learning Objectives - Work closely with community experts and developers to learn the open-source culture and skills; - Learn the advanced knowledge inside the blockchain and distributed ledgers; - Practice hand-on experience with web application design and implement; - Cultivate security awareness in software development process.

blockchainpythonnode.js+2
1 active years
Explore
Hyperledger Collaborative Learning - An Optimized BFT on Fabric - Unpaid logo

Hyperledger Collaborative Learning - An Optimized BFT on Fabric - Unpaid

Hyperledger

The current existing implementation of Hyperledger Fabric with Raft consensus has many shortcomings such as transaction censorship and no mechanism to safeguard the network if a malicious leader gets elected. The network also has limitations on scalability which restrict the type of use cases that can be built such as real-time applications that use IoT devices. This impedes blockchain adoption and limits the type of applications and use cases that can be built on Fabric. The goal of this project is to build BiniBFT, a Byzantine Fault Tolerance consensus library for Hyperledger Fabric which provides end-to-end security, high throughput with low latency and high scalability so that Fabric can be applicable for distributed and decentralized day-to-day applications. Learning Objectives - Building and Integrating a BFT library with Hyperledger Fabric. - Understanding how BFT consensus protocols work and optimizing algorithms for better performance. - Developing an understanding of how DLT networks like Hyperledger Fabric work. - Exploring the different ways in which BFT protocols can improve the performance and security of Fabric networks.

gohyperledger fabricblockchain+1
1 active years
Explore
Hyperledger Collaborative Learning - Design and Spec DIDMan based openwallet - Unpaid logo

Hyperledger Collaborative Learning - Design and Spec DIDMan based openwallet - Unpaid

Hyperledger

Designing an open wallet based on the DIDMan specification requires consideration of several key components. These include authentication, DID management, cryptographic operations, interoperability, user interface, security, and backup and recovery. The OpenWallet must have a secure authentication mechanism and support the DIDMan specification to manage DIDs, their associated keys, and metadata. The wallet must also support cryptographic operations, have a user-friendly interface, ensure security, and allow for backup and recovery. By adhering to the DIDMan specification, the wallet can ensure interoperability with other compliant systems and promote the adoption of decentralized identity technologies. Expected Outcome - The expected outcomes of designing and spec-ing an OpenWallet based on the DIDMan specification include developing a deep understanding of decentralized identity systems, gaining practical experience in implementation and cryptography, and prioritizing security and user experience. - Additionally, students can expect to learn about interoperability, open-source contribution, technical documentation, and real-world applications. - By achieving these outcomes, students will be equipped with the skills and knowledge needed to make meaningful contributions to the growing field of decentralized identity technologies.

dltblockchain
1 active years
Explore