• Stars
    star
    1,098
  • Rank 42,222 (Top 0.9 %)
  • Language
    Java
  • License
    Apache License 2.0
  • Created about 8 years ago
  • Updated over 1 year ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Hyperledger Fabric SDK for Java Build status

Note: This API is deprecated. When developing applications for Hyperledger Fabric v2.4 and later, you should use the Fabric Gateway client API. When developing applications for earlier Fabric versions, you are strongly encouraged to use the high-level API detailed below.

This project provides a low-level API for interacting with Hyperledger Fabric blockchain networks, and is used by the high-level Hyperledger Fabric Gateway SDK for Java:

The information below is intended for contributors to this repository.


Introduction for contributors

The SDK provides a layer of abstraction on top of the wire-level protobuf based communication protocol used by client applications to interact with a Hyperledger Fabric blockchain network. It allows Java applications to manage the lifecycle of Hyperledger channels and user chaincode. The SDK also provides a means to execute user chaincode, query blocks and transactions on the channel, and monitor events on the channel.

The SDK acts on behalf of a particular User which is defined by the embedding application through the implementation of the SDK's User interface.

Note, the SDK does not provide a means of persistence for the application defined channels and user artifacts on the client. This is left for the embedding application to best manage. Channels may be serialized via Java serialization in the context of a client. Channels deserialized are not in an initialized state. Applications need to handle migration of serialized files between versions.

The SDK also provides a client for Hyperledger's certificate authority. The SDK is however not dependent on this particular implementation of a certificate authority. Other Certificate authority's maybe used by implementing the SDK's Enrollment interface.

This provides a summary of steps required to get you started with building and using the Java SDK. Please note that this is not the API documentation or a tutorial for the SDK, this will only help you familiarize to get started with the SDK if you are new in this domain.

Release notes

Release Notes Summary
2.1 v2.1 release notes Minor update
2.0 v2.0 release notes
  • New lifecycle chaincode management
  • Connection config handlers
  • Application setting executor service
  • Queued block listener
1.4 None Minor updates no Fabric changes
1.3 v1.3 release notes
  • Java chaincode support
  • Query chaincode collection configuration
  • Identity Mixer transaction unlinkabilty support
1.2 v1.2 release notes
  • Private data collection support
  • Service discovery
  • Fabric CA certificate API
1.1 v1.1 release notes
  • Channel service events
  • FilterBlocks
  • JCA/JCE compliance
  • Chaincode events
  • Node chaincode

Checkout SDK from Github

git clone https://github.com/hyperledger/fabric-sdk-java.git
cd fabric-sdk-java/

Production Java applications

For Java applications use the latest released version of the SDK v1.4.x releases:

     <!-- https://mvnrepository.com/artifact/org.hyperledger.fabric-sdk-java/fabric-sdk-java -->
     <dependency>
         <groupId>org.hyperledger.fabric-sdk-java</groupId>
         <artifactId>fabric-sdk-java</artifactId>
         <version>1.4.7</version>
     </dependency>

For v2.0 work in progress use 2.0.0-SNAPSHOT builds

Work in progress 2.0.0 SNAPSHOT builds can be used by adding the following to your application's pom.xml

    <repositories>
        <repository>
            <id>snapshots-repo</id>
            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
            <releases>
                <enabled>false</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
    </repositories>

<dependencies>

        <!-- https://mvnrepository.com/artifact/org.hyperledger.fabric-sdk-java/fabric-sdk-java -->
        <dependency>
            <groupId>org.hyperledger.fabric-sdk-java</groupId>
            <artifactId>fabric-sdk-java</artifactId>
            <version>2.0.0-SNAPSHOT</version>
        </dependency>

</dependencies>

Java and Node Chaincode environment

You may also need to on your v2.1 Fabric network docker deployment explicitly pull the Java and Node chaincode environments for now.

docker pull hyperledger-fabric.jfrog.io/fabric-nodeenv:amd64-2.1.0-stable&&docker tag hyperledger-fabric.jfrog.io/fabric-nodeenv:amd64-2.1.0-stable hyperledger/fabric-nodeenv:amd64-latest&&docker tag hyperledger-fabric.jfrog.io/fabric-nodeenv:amd64-2.1.0-stable hyperledger/fabric-nodeenv

docker pull hyperledger-fabric.jfrog.io/fabric-javaenv:amd64-2.1.0-stable&&docker tag hyperledger-fabric.jfrog.io/fabric-javaenv:amd64-2.1.0-stable hyperledger/fabric-javaenv:amd64-latest&&docker tag hyperledger-fabric.jfrog.io/fabric-javaenv:amd64-2.1.0-stable hyperledger/fabric-javaenv

Known limitations and restrictions


SDK dependencies

SDK depends on few third party libraries that must be included in your classpath when using the JAR file. To get a list of dependencies, refer to pom.xml file or run mvn dependency:tree or mvn dependency:list. Alternatively, mvn dependency:analyze-report will produce a report in HTML format in target directory listing all the dependencies in a more readable format.

To build this project, the following dependencies must be met

  • JDK 1.8 or above
  • Apache Maven 3.5.0

To run the integration tests Fabric and Fabric CA is needed which require

  • Docker 18.03
  • Docker compose 1.21.2

Using the SDK

Setting Up Eclipse

If you want to get started using the Fabric Java SDK with Eclipse, refer to the instructions at: ./docs/EclipseSetup.md

Compiling

Once your JAVA_HOME points to your installation of JDK 1.8 (or above) and JAVA_HOME/bin and Apache maven are in your PATH, issue the following command to build the jar file: mvn install or mvn install -DskipTests if you don't want to run the unit tests

Running the unit tests

To run the unit tests, please use mvn install which will run the unit tests and build the jar file.

Many unit tests will test failure condition's resulting in exceptions and stack traces being displayed. This is not an indication of failure!

[INFO] BUILD SUCCESS At the end is usually a very reliable indication that all tests have passed successfully!

Running the integration tests

The script below both sets up the test environment and runs the tests.

./scripts/run-integration-tests.sh

End to end test scenario

Following the below integration tests/example code shows almost all that the SDK can do. To learn the SDK you must have some understanding first of Fabric Hyperledger. Then it's best to study the integrations tests and better yet work with them in a debugger to follow the code ( a live demo ). Start first with End2endIT.java and then End2endAndBackAgainIT.java samples before exploring the other samples. Then once you understand them you can cut and paste from there to your own application. ( the code is done for you! )

Note These samples are for testing, validating your environment and showing how to use the APIs. Most show a simple balance transfer. They are not meant to represent best practices in design or use of chaincode or the use of the SDK.

Integration Test Summary and notes
End2endLifecycleIT.java
End2endIT.java
  • Register and enroll users with Fabric certificate authority.
  • Constructing channel first time.
  • Installing chaincode. DEPRECATED see v2.0 release notes!
  • Instantiating chaincode. DEPRECATED see v2.0 release notes!
  • Executing chaincode.
  • Querying channel for block information.
  • Chaincode event listener
  • Traversing block for information.
  • Prerequisite for all other testcases.
End2endAndBackAgainIT.java
  • Recreate channel.
  • Update chaincode.
  • Checking installed and instantiated chaincode. DEPRECATED see v2.0 release notes!
End2endNodeIT.java
  • Shows running End2endIT.java but with Node chaincode.
  • Note subclasses En2endIT class.
End2endJavaIT.java
  • Shows running End2endIT.java but with Java chaincode.
  • Note subclasses En2endIT class.
End2endIdemixIT.java
  • Shows running End2endIT.java but with Idemix credentials.
  • Note subclasses En2endIT class.
NetworkConfigIT.java
  • Shows recreating channel with common connection profile.
  • User defined handlers for creating Peers and Orderers (v2.0) 🔥 .
PrivateDataIT.java
  • Shows instantiating and installing chaincode that defines private data.
  • Information on Fabric private data can be found read the docs.
UpdateChannelIT.java
  • Shows updating channel configuration.
  • Details on channel configurations can be found on read the docs Channel Configuration
  • Queued block listener (v2.0) 🔥
ServiceDiscoveryIT.java
  • Shows service discovery.
  • Details on service discovery can be found on read the docs Service Discovery
  • Note: requires adding entries in host file to remap docker fabric Peer and Orderers address to localhost

End to end test environment

The test defines one Fabric orderer and two organizations (peerOrg1, peerOrg2), each of which has 2 peers, one fabric-ca service.

Certificates and other cryptography artifacts

Fabric requires that each organization has private keys and certificates for use in signing and verifying messages going to and from clients, peers and orderers. Each organization groups these artifacts in an MSP (Membership Service Provider) with a corresponding unique MSPID .

Furthermore, each organization is assumed to generate these artifacts independently. The fabric-ca project is an example of such a certificate generation service. Fabric also provides the cryptogen tool to automatically generate all cryptographic artifacts needed for the end to end test. In the directory src/test/fixture/sdkintegration/e2e-2Orgs/channel

The command used to generate end2end crypto-config artifacts:

v1.0 build/bin/cryptogen generate --config crypto-config.yaml --output=crypto-config

v1.1 cryptogen generate --config crypto-config.yaml --output=v1.1/crypto-config

For ease of assigning ports and mapping of artifacts to physical files, all peers, orderers, and fabric-ca are run as Docker containers controlled via a docker-compose configuration file.

The files used by the end to end are:

  • src/test/fixture/sdkintegration/e2e-2Orgs/vX.0 (everything needed to bootstrap the orderer and create the channels)
  • src/test/fixture/sdkintegration/e2e-2Orgs/vX.0crypto-config (as-is. Used by configtxgen and docker-compose to map the MSP directories)
  • src/test/fixture/sdkintegration/docker-compose.yaml

The end to end test case artifacts are stored under the directory src/test/fixture/sdkintegration/e2e-2Org/channel .

TLS connection to Orderer and Peers

IBM Java needs the following properties defined to use TLS 1.2 to get an HTTPS connections to Fabric CA.

-Dcom.ibm.jsse2.overrideDefaultTLS=true   -Dhttps.protocols=TLSv1.2

Currently, the pom.xml is set to use netty-tcnative-boringssl for TLS connection to Orderer and Peers, however, you can change the pom.xml (uncomment a few lines) to use an alternative TLS connection via ALPN.

TLS Environment for SDK Integration Tests

The SDK Integration tests can be enabled by adding before the ./fabric restart the follow as:

ORG_HYPERLEDGER_FABRIC_SDKTEST_INTEGRATIONTESTS_TLS=true ORG_HYPERLEDGER_FABRIC_SDKTEST_INTEGRATIONTESTS_CA_TLS=--tls.enabled ./fabric.sh restart

Then run the Integration tests with:

ORG_HYPERLEDGER_FABRIC_SDKTEST_INTEGRATIONTESTS_TLS=true mvn clean install -DskipITs=false -Dmaven.test.failure.ignore=false javadoc:javadoc

Chaincode endorsement policies

You create a policy using a Fabric tool ( an example is shown in JIRA issue FAB-2376) and give it to the SDK either as a file or a byte array. The SDK, in turn, will use the policy when it creates chaincode instantiation requests.

To input a policy to the SDK, use the ChaincodeEndorsementPolicy class.

For testing purposes, there are 2 policy files in the src/test/resources directory

  • policyBitsAdmin ( which has policy AND(DEFAULT.admin) meaning 1 signature from the DEFAULT MSP admin' is required )
  • policyBitsMember ( which has policy AND(DEFAULT.member) meaning 1 signature from a member of the DEFAULT MSP is required )

and one file in the src/test/fixture/sdkintegration/e2e-2Orgs/channel directory specifically for use in the end to end test scenario

  • members_from_org1_or_2.policy ( which has policy OR(peerOrg1.member, peerOrg2.member) meaning 1 signature from a member of either organizations peerOrg1, PeerOrg2 is required)

Alternatively, you can also use ChaincodeEndorsementPolicy class by giving it a YAML file that has the policy defined in it. See examples of this in the End2endIT testcases that use src/test/fixture/sdkintegration/chaincodeendorsementpolicy.yaml The file chaincodeendorsementpolicy.yaml has comments that help understand how to create these policies. The first section lists all the signature identities you can use in the policy. Currently, only ROLE types are supported. The policy section is comprised of n-of and signed-by elements. Then n-of (1-of 2-of) require that many (n) in that section to be true. The signed-by references an identity in the identities section.

Channel creation artifacts

Channel configuration files and orderer bootstrap files ( see directory src/test/fixture/sdkintegration/e2e-2Orgs ) are needed when creating a new channel. This is created with the Hyperledger Fabric configtxgen tool. This must be run after cryptogen and the directory you're running in must have a generated crypto-config directory.

If build/bin/configtxgen tool is not present run make configtxgen

For v1.0 integration test the commands are:

  • build/bin/configtxgen -outputCreateChannelTx foo.tx -profile TwoOrgsChannel -channelID foo
  • build/bin/configtxgen -outputCreateChannelTx bar.tx -profile TwoOrgsChannel -channelID bar

For v1.1 integration the commands use the v11 profiles in configtx.yaml. You need to for now copy the configtx.yaml in e2e-20orgs to the v1.1 directory and run from there:

  • configtxgen -outputBlock orderer.block -profile TwoOrgsOrdererGenesis_v11
  • configtxgen -outputCreateChannelTx bar.tx -profile TwoOrgsChannel_v11 -channelID bar
  • configtxgen -outputCreateChannelTx foo.tx -profile TwoOrgsChannel_v11 -channelID foo

For v1.2 integration the commands use the v12 profiles in configtx.yaml.

  • configtxgen --configPath . -outputBlock orderer.block -profile TwoOrgsOrdererGenesis_v12
  • configtxgen --configPath . -outputCreateChannelTx bar.tx -profile TwoOrgsChannel_v12 -channelID bar
  • configtxgen --configPath . -outputCreateChannelTx foo.tx -profile TwoOrgsChannel_v12 -channelID foo This should produce in the v1.2 directory: bar.tx,foo.tx, orderer.block

For v1.3 and 1.4 integration, cd to the src/test/fixture/sdkintegration/e2e-2Orgs/v1.3 directory and execute the following commands:

  • configtxgen --configPath . -outputBlock orderer.block -profile TwoOrgsOrdererGenesis_v13
  • configtxgen --configPath . -outputCreateChannelTx foo.tx -profile TwoOrgsChannel_v13 -channelID foo
  • configtxgen --configPath . -outputCreateChannelTx bar.tx -profile TwoOrgsChannel_v13 -channelID bar

For v2.1 integration, cd to the src/test/fixture/sdkintegration/e2e-2Orgs/v2.1 directory

  • configtxgen --configPath . -outputCreateChannelTx v2channel.tx -profile TwoOrgsChannel_v20 -channelID v2channel
  • configtxgen --configPath . -outputBlock orderer.block -profile TwoOrgsOrdererGenesis_v20 -channelID systemordererchannel

This should produce the following files in the same directory: orderer.block, foo.tx, and bar.tx

Note: The above describes how this was done. If you redo this there are private key files which are produced with unique names which won't match what's expected in the integration tests. One example of this is the docker-compose.yaml (search for _sk)

GO Lang chaincode

Go lang chaincode dependencies must be contained in vendor folder. For an explanation of this see Vendor folder explanation

Basic Troubleshooting and frequently asked questions:

Where can I find the Javadoc?

Look in the Maven repository for the release in question there should be a file fabric-sdk-java-<release>-javadoc.jar

For SNAPSHOT builds look in Sonatype repository Find the release <release>-SNAPSHOT directory then search for the latest fabric-sdk-java-<release>-<latest timestamp>-javadoc.jar

Is Android supported?

No.

Is there an API to query for all channels that exist?

No.

Should an application create more than one HFClient?

There should be no need to do that in a single application. All the SDK requests are threadsafe. The user context set on the client can be on all requests overridden by setting the user context on that specific request.

Idemix users or Idemix test cases (IdemixIdentitiesTest) just seems to hang or take forever.

Most likely this is running on a virtual machine that does not have sufficient entropy. Google for adding entropy on virtual machines or look at virtual machines entropy If linux try installing rng-tools package as this suggests.

Firewalls, load balancers, network proxies

These can sometimes silently kill a network connections and prevent them from auto reconnecting. To fix this look at adding to Peers and Orderer's connection properties: grpc.NettyChannelBuilderOption.keepAliveTime, grpc.NettyChannelBuilderOption.keepAliveTimeout, grpc.NettyChannelBuilderOption.keepAliveWithoutCalls. Examples of this are in End2endIT.java

Missing protobuf classes.

Please re-read this file doing exactly the steps to run all the tests. They can't be missing if the tests pass. 😃

grpc message frame size exceeds maximum

The message being returned from the fabric server is too large for the default grpc frame size. On the Peer or Orderer add the property grpc.NettyChannelBuilderOption.maxInboundMessageSize See End2endIT's constructChannel

Configuration and setting default values - timeouts etc

The SDK's defaults are all in the file Config.java The config.properties also has some descriptions on what they do. Most server timeout request can be overridden with the specific request too.

What's difference between joining and adding a peer to a channel?

You only ever join a peer belonging to your own organization to a channel once at the beginning. You would only add peers from other organizations or peers of your own organization you've already joined like when recreating the channel SDK object.

Transaction sent to orderer results in future with exception validation code: xxx Where can I find what that means?

See Fabric protobuf protos/peer/transaction.proto's TxValidationCode

java.security.InvalidKeyException: Illegal key size

If you get this error, this means your JDK does not capable of handling unlimited strength crypto algorithms. To fix this issue, You will need to download the JCE libraries for your version of JDK. Please follow the instructions here to download and install the JCE for your version of the JDK.

Communicating with developers and fellow users.

Sign into Hyperledger project's Rocket chat For this you will also need a Linux Foundation ID

Join the fabric-sdk-java channel.

Reporting Issues

If your issue is with building Fabric development environment please discuss this on rocket.chat's #fabric-dev-env channel.

To report an issue please use: Hyperledger's JIRA. To login you will need a Linux Foundation ID (LFID) which you get at The Linux Foundation if you don't already have one.

JIRA Fields should be:

Type
Bug or New Feature
Component
fabric-sdk-java
Fix Versions
v1.4

Pleases provide as much information that you can with the issue you're experiencing: stack traces logs.

Please provide the output of java -XshowSettings:properties -version

Logging for the SDK can be enabled with setting environment variables:

ORG_HYPERLEDGER_FABRIC_SDK_LOGLEVEL=TRACE

ORG_HYPERLEDGER_FABRIC_CA_SDK_LOGLEVEL=TRACE

ORG_HYPERLEDGER_FABRIC_SDK_DIAGNOSTICFILEDIR=<full path to directory> # dumps protobuf and diagnostic data. Can be produce large amounts of data!

Fabric debug

Fabric debug is by default enabled in the SDK docker-compose.yaml file with

On Orderer:

ORDERER_GENERAL_LOGLEVEL=debug

On peers: CORE_LOGGING_LEVEL=DEBUG

Fabric CA by starting command have the -d parameter.

Upload full logs to JIRA, not just where the issue occurred if possible

Tracing

The SDK is set up to trace all gRPC communications:

  • All outgoing messages bear trace metadata, allowing correlation with peers.
  • Each request/response is computed as a span.
  • If you use OpenTelemetry in your program, the gRPC span will correlate using the thread local context to the parent context.

The SDK accepts all environment variables as described in the OpenTelemetry specification.

Creative Commons License
This work is licensed under a Creative Commons Attribution 4.0 International License.

More Repositories

1

fabric

Hyperledger Fabric is an enterprise-grade permissioned distributed ledger framework for developing solutions and applications. Its modular and versatile design satisfies a broad range of industry use cases. It offers a unique approach to consensus that enables performance at scale while preserving privacy.
Go
14,808
star
2

hyperledger

Hyperledger is a Collaborative Project at The Linux Foundation.
3,702
star
3

fabric-samples

Samples for Hyperledger Fabric
Go
2,611
star
4

besu

An enterprise-grade Java-based, Apache 2.0 licensed Ethereum client https://wiki.hyperledger.org/display/besu
Java
1,314
star
5

solang

Solidity Compiler for Solana and Polkadot
Rust
1,180
star
6

fabric-sdk-go

Go
885
star
7

cello

Operating System for Enterprise Blockchain
Python
850
star
8

fabric-sdk-node

Hyperledger Fabric SDK for Node https://wiki.hyperledger.org/display/fabric
JavaScript
777
star
9

indy-node

The server portion of a distributed ledger purpose-built for decentralized identity.
Python
647
star
10

caliper

A blockchain benchmark framework to measure performance of multiple blockchain solutions https://wiki.hyperledger.org/display/caliper
JavaScript
605
star
11

fabric-ca

Go
426
star
12

firefly

Hyperledger FireFly is the first open source Supernode: a complete stack for enterprises to build and scale secure Web3 applications. The FireFly API for digital assets, data flows, and blockchain transactions makes it radically faster to build production-ready apps on popular chains and protocols.
Go
423
star
13

iroha

Iroha - A simple, enterprise-grade decentralized ledger
C++
395
star
14

fabric-sdk-py

Hyperledger Fabric Python SDK
Python
394
star
15

aries-cloudagent-python

Hyperledger Aries Cloud Agent Python (ACA-Py) is a foundation for building decentralized identity applications and services running in non-mobile environments.
Python
373
star
16

bevel

An automation framework for rapidly and consistently deploying production-ready DLT platforms
Smarty
317
star
17

aries-rfcs

Hyperledger Aries is infrastructure for blockchain-rooted, peer-to-peer interactions
Python
311
star
18

fabric-chaincode-java

Hyperledger Fabric Contract and Chaincode implementation for Java https://wiki.hyperledger.org/display/fabric
Java
290
star
19

cacti

Hyperledger Cacti is a new approach to the blockchain interoperability problem
TypeScript
289
star
20

aries

Hyperledger Aries is infrastructure for blockchain-rooted, peer-to-peer interactions
257
star
21

bevel-operator-fabric

Hyperledger Fabric Kubernetes operator - Hyperledger Fabric operator for Kubernetes (v2.3, v2.4 and v2.5)
Go
239
star
22

fabric-chaincode-node

Hyperledger Fabric Node.js Smart Contracts
JavaScript
229
star
23

indy-plenum

Plenum Byzantine Fault Tolerant Protocol
Python
209
star
24

aries-framework-javascript

Aries Framework JavaScript (Built using TypeScript)
TypeScript
208
star
25

fabric-gateway-java

Hyperledger Fabric Gateway SDK for Java https://wiki.hyperledger.org/display/fabric
Java
201
star
26

fabric-contract-api-go

Packages for the implementation of the contract API for use in Go chaincode
Go
192
star
27

fabric-test

A collection of utilities used to test the core Hyperledger Fabric projects
Go
150
star
28

fabric-private-chaincode

FPC enables Confidential Chaincode Execution for Hyperledger Fabric using Intel SGX.
Go
147
star
29

fabric-chaincode-go

Hyperledger Fabric Packages for Go Chaincode
Go
130
star
30

aries-mobile-agent-react-native

Aries Mobile Agent React Native - Part of the Aries Bifold effort to provide SSI capabilities in a production ready app.
TypeScript
125
star
31

fabric-gateway

Go, Node and Java client API for Hyperledger Fabric v2.4+
Java
121
star
32

iroha-python

Python library for Hyperledger Iroha, a simple distributed ledger.
Python
104
star
33

caliper-benchmarks

Sample benchmark files for Hyperledger Caliper https://wiki.hyperledger.org/display/caliper
JavaScript
96
star
34

iroha-javascript

JavaScript library for Iroha, a Distributed Ledger Technology (blockchain) platform.
JavaScript
93
star
35

iroha-ios

iOS Swift library for Iroha, a simple distributed ledger
Objective-C
91
star
36

fabric-docs-i18n

Hyperledger Fabric is an enterprise-grade permissioned distributed ledger framework for developing solutions and applications. Its modular and versatile design satisfies a broad range of industry use cases. It offers a unique approach to consensus that enables performance at scale while preserving privacy.
Makefile
85
star
37

firefly-ethconnect

Ethereum connectivity bridge for Web Services & async Messaging APIs - familiar to Enterprise Apps
Go
72
star
38

indy-hipe

Hyperledger Indy Project Enhancements
TeX
71
star
39

web3j-evm

A library for running an embedded Ethereum EVM in-process on a JVM
Kotlin
61
star
40

aries-vcx

aries-vcx is set of crates to work with DIDs, DID Documents, DIDComm, Verifiable Credentials and Hyperledger Aries.
Rust
61
star
41

besu-docs

Documentation for Hyperledger Besu enterprise-grade Java-based, Apache 2.0 licensed Ethereum client https://wiki.hyperledger.org/display/besu
CSS
56
star
42

aries-agent-test-harness

Aries agent test framework, with agent backchannel support
Python
56
star
43

anoncreds-rs

anoncreds-rs
Rust
53
star
44

web3j-cli

Command-line interface for web3j
Java
53
star
45

aries-askar

Secure storage designed for Hyperledger Aries agents.
Rust
49
star
46

firefly-cli

FireFly Command Line Interface (CLI)
Go
47
star
47

indy-vdr

A library and proxy server for interacting with Hyperledger Indy Node ledger instances
Rust
47
star
48

aries-acapy-controllers

Web controllers for the Aries Cloud Agent - Python (ACA-Py)
HTML
44
star
49

fabric-protos-go

Generated Go bindings for fabric-protos
Go
44
star
50

anoncreds-spec

The specification for AnonCreds verifiable credential exchange.
CSS
39
star
51

fabric-protos

Makefile
38
star
52

web3j-docs

Web3j documentation repository.
35
star
53

firefly-ui

FireFly UI
TypeScript
31
star
54

toc

Hyperledger TOC documents
29
star
55

firefly-fabconnect

REST API to interact with a Fabric network and event streaming via websocket
Go
29
star
56

aries-mediator-service

HTML
29
star
57

fabric-rfcs

RFC process for Hyperledger Fabric. The RFC (request for comments) process is intended to provide a consistent and controlled path for major changes to Fabric and other official project components. https://wiki.hyperledger.org/display/fabric
29
star
58

iroha-java

Kotlin
28
star
59

iroha-ed25519

RFC8032 compatible Ed25519 implementation with pluggable hash (sha2-512, sha3-512)
Assembly
28
star
60

aries-framework-javascript-ext

Extension libraries for Aries Framework JavaScript
TypeScript
25
star
61

fabric-config

Hyperledger Fabric Packages for channel configuration transactions. Documentation at https://pkg.go.dev/github.com/hyperledger/fabric-config/configtx.
Go
24
star
62

web3j-unit

Smart contract testing framework via integrated EVM and various Ethereum clients
Kotlin
22
star
63

firefly-tokens-erc1155

ERC1155 token integration
TypeScript
21
star
64

aries-staticagent-python

Aries Static Agent library for Python
Python
20
star
65

firefly-transaction-manager

Blockchain transaction manager for Hyperledger FireFly. Integrates public blockchains through a pluggable FireFly Connector API framework. Extensible policy engine for managing gas & resubmission. Confirmation manager for managing finality on both transactions and event streams.
Go
20
star
66

fabric-cli

Go
19
star
67

indy-node-container

Providing Containers to run Indy Node
Shell
19
star
68

fabric-admin-sdk

Fabric SDK for Admin Capability services
Go
19
star
69

firefly-samples

Samples for FireFly
TypeScript
18
star
70

firefly-tokens-erc20-erc721

ERC20 and ERC721 token integration
TypeScript
18
star
71

indy-did-method

Indy DID Method Specification
CSS
17
star
72

indy-node-monitor

Python
14
star
73

firefly-helm-charts

Firefly Helm Charts
Smarty
14
star
74

aries-framework-swift

A Swift framework for Aries.
Swift
14
star
75

aries-javascript-docs

A documentation site for the Aries JavaScript ecosystem.
TypeScript
13
star
76

indy-shared-rs

Shared Rust data types and utility functions for Hyperledger Indy.
Rust
13
star
77

firefly-evmconnect

Firefly EVM Connect
Go
12
star
78

firefly-sdk-nodejs

FireFly SDK for Node.js
TypeScript
11
star
79

anoncreds-v2-rs

Anonymous Credential Exchange 2.0
Rust
11
star
80

firefly-sandbox

Hyperledger FireFly Sandbox
TypeScript
10
star
81

firefly-dataexchange-https

TypeScript
10
star
82

aries-mobile-test-harness

An acceptance test framework for testing mobile Aries wallets utilizing Python, Behave, Appium, and a mobile device cloud service.
Python
10
star
83

besu-native

Java
8
star
84

indy-test-automation

Automation tools for testing of Indy Project components.
Python
8
star
85

aries-socketdock

Websocket Relay Service for use with clustered Mediators
Python
8
star
86

anoncreds-tex

anoncreds
TeX
7
star
87

anoncreds-spec-v2

CSS
7
star
88

firefly-signer

Signing, Keystore, ABI and RLP encoding utilities for EVM / Ethereum / secp256k1 based blockchains. Written in Go with an enterprise friendly Apache 2.0 license, and a runtime JSON/RPC proxy server. Part of the Hyperledger FireFly project
Go
7
star
89

aries-framework-kotlin

aries-framework-kotlin
Kotlin
6
star
90

firefly-cordaconnect

Java
6
star
91

iroha-2-docs

TypeScript
6
star
92

hyperledger.github.io

HTML
6
star
93

hyperledger-hip

Hyperledger Improvement Proposal (HIP)
6
star
94

aries-acapy-tools

Hyperledger Aries
Python
6
star
95

firefly-fir

5
star
96

indy-did-networks

indy-did-networks
5
star
97

governance

5
star
98

aries-endorser-service

endorser-service
Python
5
star
99

fabric-amcl

Go
4
star
100

anoncreds-revocation

JavaScript
4
star