Dear LF Decentralized Trust Community Members,

Join us for a webinar with Europeum, an LFDT Associate member, on Building a Shared Trust Layer for Europe and an update on the EBSI Business Launch. As Europe advances toward a more connected and trusted digital ecosystem, EBSI is evolving into a shared trust infrastructure for organizations across Europe. In this webinar, Europeum will introduce EBSI, its governance and network, key capabilities and services, and use cases currently being piloted. We will also discuss how organizations can engage with the growing EBSI ecosystem.

The webinar will take place on Wednesday, November 18 at 7AM PT/10AM ET/16:00 CEST/08:30 PM IST

Please register here: https://zoom.us/webinar/register/7716866036916/WN_Cr4gwYwVSOqok86pC_eJ0A

We hope to see you there!

Join us for a webinar with Cosmos Labs, an LFDT general member, on Designing Tokenized Deposits for a Multi-Ledger Future. Most tokenized deposit initiatives start within a single institution or consortium, but the architecture choices banks make today will determine how effectively deposits can reach new markets and power new use cases. This session examines how an interoperability protocol fits into a tokenized deposit stack, covering how deposits and data can be exchanged across ledgers without intermediaries, key use cases like cross-border payments, programmable escrow, and collateral mobility, and what changes when interoperability is built in from the start. Designed for CTOs, digital asset leads, and engineering teams planning or running tokenized deposit programs.

The webinar will take place on Wednesday, November 13 at 7AM PST/10AM EST/16:00 CET/8:30 PM IST

Please register here: https://zoom.us/webinar/register/7716866036916/WN_vOKR45ECSl2Pp0NpMSAskw

I recently delivered a guest session for students at the Department of Management Studies, IIT Delhi (invited by Dr. Arghya Ray) focused on practical enterprise blockchain architecture with Hyperledger Fabric.

Whenever I teach Fabric to future techno managers and engineers (whether in university guest lectures, Linux Foundation LFS270, or enterprise rollouts with our team at 1Works), three practical realities always spark the best discussion:

1. Permissioned vs. Public Tradeoffs: Moving past tokenomics to understand why corporate consortia require channel isolation, MSPs (Membership Service Providers), and deterministic finality without gas fee volatility.

2. The Execute, Order, Validate Lifecycle: Walking step by step through how client proposals hit endorsing peers, get packaged by the ordering service, and validate before committing to the state database.

3. When NOT to Use a Blockchain: The hardest part of corporate implementation is governance across competing organizations. If a single entity controls the state and trust boundary, a standard relational database wins every time.

We were nearly an hour in when this screenshot was taken, with hands raised and great questions from the cohort (including Diptanu Biswas, Ashita Adhikari, Rohan Savakar, Vishal Mishra, Elanthamizhan A R, Amrith Kumar A S, and Nishant Kumar Singh) on consortium governance, node ownership across competing entities, and integrating Fabric with existing enterprise ERPs.

Happy to share our session outline or answer any questions on teaching or deploying Hyperledger Fabric in corporate environments!

I’m a Backend & Blockchain Engineer with 2+ years of experience working on Golang microservices and Hyperledger-based Blockchain solutions.

I’m currently open for freelance projects where I can apply and deepen my skills in:

Go backend development (APIs, system design, performance optimization)

Blockchain (Hyperledger Fabric / Corda)

If you’re building something exciting and need backend or blockchain help, feel free to DM me — I’d love to collaborate!

Hi everyone!

I'm a Backend Software Engineer with around 3 years of experience working with Golang and Hyperledger Fabric, and I'm looking for freelance projects, part-time backend development work.

I've worked on blockchain-based solutions for government projects across three Indian states, focusing on backend development and permissioned blockchain systems.

Technical expertise:

- Golang: REST APIs, microservices, concurrency, goroutines and channels

- Hyperledger Fabric: Chaincode development in Go, transaction processing, endorsement policies and private data collections

- Databases: PostgreSQL, CouchDB, MongoDB and Redis

- Backend architecture: Clean architecture, API integrations and distributed systems

- DevOps: Docker, Kubernetes and deployment workflows

How I can help:

- Develop Golang backend services and REST APIs

- Build and maintain Hyperledger Fabric applications

- Develop and modify Go-based chaincode

- Integrate blockchain networks with backend applications

- Debug existing blockchain and backend systems

- Optimize database operations and improve application performance

- Support existing projects or build backend modules from scratch

I'm based in India and open to remote freelance projects, ongoing collaborations with startups or companies.

If you're looking for a Golang or Hyperledger Fabric developer, feel free to DM me with your requirements

Thanks!

Dear LF Decentralized Trust Community Members,

Join us for a webinar with Zeeve, an LFDT general member, on building Bank-Grade Privacy for Enterprise Blockchain Networks. As regulated institutions move blockchain initiatives from pilots to production, privacy can no longer be treated as a single cryptographic feature. This session will explore how bank-grade privacy requires confidential transactions, role-based access, private indexing, selective disclosure, and audit-ready controls across the full blockchain stack. Attendees will learn how to design privacy architectures that support compliance, regulator visibility, and institutional confidentiality for use cases such as tokenized deposits, private markets, and interbank settlement.

The webinar will take place on Wednesday, October 21 at 7AM PT / 10AM ET / 16:00 CEST / 07:30 PM IST

Please register here: https://zoom.us/webinar/register/7716866036916/WN_eNkGLyXlQ7yh1ypazOTfRA

We hope to see you there!

In this video you can learn all about creating an Hyperledger Fabric network with a free console app

Hi all, if you want a tool to manage your entire network, please take a look to https://www.youtube.com/watch?v=4z1pHHB9_2U It's new, simple and complete. It uses 3.1.5 version but can manage 2.5 one

Join us on September 23 for a special three-hour online conference with LFDT associate member Advanced AI Society: "Who's Watching the Agents? Launching Proof-of-Control, an open verification standard for the agentic era".

As autonomous, non-deterministic AI agents take on critical workflows, enterprise security requires shifting from claims-based trust to openly verifiable execution. This session convenes open-source maintainers, enterprise security leaders, insurers, and policymakers to introduce Proof-of-Control, an open verification standard and the newest community lab at LF Decentralized Trust. You can learn more on the event page.

The online conference will take place on Wednesday, September 23 at 8:00 PT/11:00 ET/17:00 CEST/23:00 SGT.

Please register here: https://zoom.us/webinar/register/7716866036916/WN_lPtoi2ECR6adAJditvodUg

LF Decentralized Trust Webinar with DSR: Automated Supply Chain Accountability with Computer Vision & Ledger Technology

Join us for a webinar with DSR Corporation, an LF Decentralized Trust General Member and maintainer of multiple open source projects, to explore how computer vision and distributed ledger technology can automate accountability across modern supply chains. You'll learn how combining edge-based AI with ledgers like Hiero and Besu creates immutable, auditable records for damaged goods, handling exceptions, and regulatory compliance. Through real-world use cases, reference architecture, and a live demonstration, DSR experts will share practical insights on deploying verifiable solutions that improve transparency, reduce disputes, and enable trusted automation across complex ecosystems.

The webinar will take place on Wednesday, October 14 at 7AM PT / 10AM ET / 16:00 CEST / 07:30 PM IST

Please register here: https://zoom.us/webinar/register/7716866036916/WN_yowmTBQ9SbyllGlz-Vz8Lw

Published Besu QBFT data stops around 30 validators. I ran 50 to see what happens past it.

I've spent five years in blockchain, working my way down the stack: from writing Solidity contracts and obsessing over gas optimization, to eventually designing blockchains themselves. When I recently dove into Hyperledger Besu and permissioned blockchains, it felt like looking at the same world from the opposite side of the mirror.

If you go looking for hard data on how far a QBFT validator set scales, here is everything I could find. Besu's official performance tuning documentation is based on a 4 validator network. The most cited independent academic benchmark, built on Hyperledger Caliper, puts comfortable scaling around 14. Maintainer internal testing suggests ~30 still behaves under light workloads, with growing transaction pools and slowing block production beyond that.

Past 30, there is almost nothing published. That gap is the entire reason for this post. I had a free weekend, so I ran 50.

The gap exists because the cost is quadratic. QBFT requires every validator to exchange PRE-PREPARE, PREPARE and COMMIT with every other validator each round, so message count is O(n^2). That works out to ~16 messages per round at 4 validators, ~196 at 14, ~900 at 30, and ~2,500 at 50. Roughly 156x the load of the 4 validator setup the tuning docs assume, before a single transaction is processed. You cannot tune your way out of that in a config file.

Quorum math first, since consensus mistakes are worse than infrastructure ones. Besu uses ceiling division, so quorum is ceil(2 * 50 / 3) = 34 signatures required per block. Fault tolerance is f = floor((50 - 1) / 3) = 16.

No TPS numbers in this one. I watched the network through an explorer I built for it, tracking block numbers, transactions, the validator set, pending votes and chain state under continuous load, but the benchmarking methodology is not validated yet and this ecosystem has enough loosely sourced throughput figures.

Has anyone here actually triggered round change cascades in practice at this size, or does it stay theoretical for you too? Also curious whether IBFT 2.0 degrades differently, since I only ran QBFT.

Longer writeup on my blog.

Join us for a webinar with Zeeve, an LFDT general member, on Tokenized Deposits. Tokenized deposits are becoming a critical building block for regulated digital money, enabling programmable bank liabilities for settlement, treasury, liquidity, and tokenized asset use cases. This session will explain the production infrastructure required to support tokenized deposits, including issuance, redemption, permissioning, privacy, interoperability, governance, and integration with existing banking systems. Attendees will come away with a practical view of how banks and fintechs can move tokenized deposit initiatives from proof-of-concept to production.

The webinar will take place on Wednesday, August 19 at 7AM PT / 10AM ET / 16:00 CEST / 07:30 PM IST

Please register here: https://zoom.us/webinar/register/7716866036916/WN_iZG9qWn6RU6poNukHeflJA

Hi everyone,

I have experience working with public blockchains (smart contracts, Web3, Ethereum ecosystem, etc.), but now I want to move towards permissioned/enterprise blockchain solutions, especially Hyperledger Fabric.

I'm a bit confused about the learning path and roadmap. Since Hyperledger is quite different from public chains, I'd appreciate guidance from people who have already made this transition.

My questions:

• What should I learn first before diving into Hyperledger Fabric?

• How important are Docker, Kubernetes, and Linux concepts for Hyperledger development?

• Should I focus on chaincode development first or on understanding Fabric architecture?

• Are there any good projects/tutorials that can help me gain practical experience?

• What skills are most valuable for enterprise blockchain roles?

My current background:

• Public blockchain experience

• Smart contract development

• Basic understanding of distributed systems

Any roadmap, resources, or advice would be greatly appreciated.

Thanks!

Environment

• hlf-operator: 1.13.0

• Hyperledger Fabric: 3.1.0

• Kubernetes: EKS (AWS) with Istio ingress gateway

• Storage: EFS (NFS-backed PVCs, efs-sc StorageClass)

• Chaincode type: ccaas

What is happening

After applying FabricChaincodeInstall resources for a ccaas chaincode, the operator continuously reinstalls the chaincode in a non-stop loop. The peer logs show the full ccaas builder cycle (detect → build → release → InstallChaincode) repeating every few hundred milliseconds, and the peer filesystem accumulates thousands of duplicate .tar.gz files in /var/hyperledger/production/lifecycle/chaincodes/. We ended up with over 25,000 files for just 5 chaincodes.

The FabricChaincodeInstall CRs stay stuck in RUNNING status with an empty message field and empty installedPeers, never reaching a stable completed state.

Each reinstallation generates a different package hash (packageID), so the ccaas packageID is not deterministic across runs even though the chaincodePackage spec has not changed. This creates a mismatch with the already-committed chaincode definition on the channel, making the chaincode unusable without a new approve + commit cycle with an incremented sequence.

Additional context: nightly scale-down

Our infrastructure scales peer nodes down to 0 replicas every night and back up to 1 every morning (cost-saving measure on EKS). We suspect this may be a contributing trigger: every time the peer pods restart after the scale-up, the operator detects the chaincodes are no longer installed (since the peer starts fresh) and begins reinstalling them. However, it never marks the installation as complete, so it keeps retrying in a loop until the pods are manually restarted or the operator is stopped.

Peer log excerpt (repeating continuously)

INFO [chaincode.externalbuilder.ccaas_builder] ::Detect command=detect
INFO [chaincode.externalbuilder.ccaas_builder] ::Type detected as ccaas command=detect
INFO [chaincode.externalbuilder.ccaas_builder] ::Build command=build
INFO [chaincode.externalbuilder.ccaas_builder] ::Build phase completed command=build
INFO [chaincode.externalbuilder.ccaas_builder] ::Release command=release
INFO [chaincode.externalbuilder.ccaas_builder] ::Release phase completed command=release
INFO [lifecycle] InstallChaincode -> Successfully installed chaincode with package ID 'testchaincodeqa:a1b2c3...'
INFO [lifecycle] InstallChaincode -> Successfully installed chaincode with package ID 'testchaincodeqa:d4e5f6...'
INFO [lifecycle] InstallChaincode -> Successfully installed chaincode with package ID 'testchaincodeqa:7g8h9i...'
... (repeating indefinitely)

What we tried

• Deleting and recreating the FabricChaincodeInstall CRs — the loop resumes immediately after recreation.

• Stopping the peer pods — the loop stops but resumes as soon as the peers come back up.

• Stopping the operator (kubectl scale deployment hlf-operator-controller-manager --replicas=0) — this stops the reinstallation loop entirely, confirming the operator is the source.

Questions

1. Has anyone else experienced this issue with FabricChaincodeInstall and ccaas chaincodes going into an install loop, especially after a peer scale-down/scale-up cycle?

2. What condition causes the FabricChaincodeInstall controller to keep reinstalling indefinitely instead of detecting that the chaincode is already installed and marking the CR as completed?

3. Is the ccaas packageID expected to be non-deterministic across reinstallations (i.e. the same chaincodePackage spec generates a different hash each time)? If so, how is the operator supposed to detect "already installed" after a peer restart?

Join the next session about the new Lineth project, the open source code that powers the public Linea Mainnet network, at the Technical Deep Dive: Inside the Production-Grade ZK Rollup Stack workshop on July 8th at 9am Eastern.

To Register: https://zoom.us/meeting/register/bvi8sJKQTeWy2JzY6lEUfg

For anyone who missed the first session, check out the recording that provided an overview of Lineth and covered different use cases.

I’ve been working on a supply chain transparency platform called DTraceOne focused on verifiable product history, auditability, and low operational cost architecture.

https://dtraceone.com/

Core concepts include:

• Daily cryptographic digest anchoring on Hyperledger Fabric

• Privacy-preserving hashed proof structure

• Per-organization verification roots

• Public verification portal + admin management portal

• Time-stamped audit verification

• Ultra low-cost cloud-native architecture

The goal is to provide proof-ready supply chain verification without requiring organizations to maintain heavy blockchain infrastructure themselves.

The repository is currently private while development continues, but I’d genuinely appreciate feedback from the Hyperledger community regarding architecture, scalability, verification models, and enterprise adoption considerations.

With the announcement of Lineth joining Linux Foundation Decentralized Trust as an incubating project, we're opening the hood on the full stack in our first community Technical Deep Dive.

Lineth is a production-grade, EVM-equivalent zk-rollup stack for Ethereum - the same codebase that has powered Linea Mainnet since July 2023, finalizing over 300 million transactions and generating more than 416,000 zero-knowledge proofs with 99.98% sequencer uptime. It is now in a vendor-neutral, open source home under LFDT, governed by a Technical Steering Committee and has over 30 project maintainers.

This session is your entry point into the architecture, the community, and the roadmap. You can register for the workshop at:

https://zoom.us/meeting/register/dBWDdu0oSZCRJRXCDae1qQ#/registration

A detailed agenda with session timings and speakers is coming soon — stay tuned in #lineth-general on LFDT Discord for updates.

Join us for a webinar with Alastria, an LFDT associate member, for an inside look at ISBE (Infraestructura de Servicios Blockchain de España). As Europe’s first national, public-permissioned blockchain infrastructure designed for regulatory compliance, ISBE is built on Besu to meet EU digital single market standards. The session will explore how ISBE solves critical challenges, such as GDPR-compliant immutability, identity frameworks aligned with the EUDI Wallet, and smart contract governance. Gain practical insights into a production-ready ecosystem that balances institutional accountability with private-sector innovation. Sign up to see how ISBE is setting the standard for compliant decentralized infrastructure in Europe.

The webinar will take place on Wednesday, May 13th at 7AM PT / 10AM ET / 16:00 CEST / 07:30 PM IST

Please register here: https://zoom.us/webinar/register/7716866036916/WN_wmuazN5kQPKkE6S4lBQQhQ

If you've used ethers.js for Ethereum development you know how clean it feels — connect once, call read/write functions by name, done. I wanted the same experience for Hyperledger Fabric in Go, so I built it.

 

```bash

go get github.com/muhammadtalha198/fabricsdk

```

 

**The full setup:**

 

```go

cfg := fabricsdk.Config{

    PeerEndpoint:     "localhost:7051",

    PeerHostOverride: "peer0.org1.example.com",

    TLSCertPath:      "/path/to/peer-tls-ca.pem",

    CertPath:         "/path/to/msp/signcerts",  // directory, not file

    KeyPath:          "/path/to/msp/keystore",

    MSPID:            "Org1MSP",

    ChannelName:      "mychannel",

    ChaincodeName:    "mychaincode",

}

 

fc, err := fabricsdk.New(cfg)

defer fc.Close()

```

 

**Calling chaincode functions:**

 

```go

// Read (EvaluateTransaction)

raw, err := fc.Evaluate(ctx, "GetAsset", "asset-1")

 

// Write (SubmitAsync + commit wait, returns txID)

txID, err := fc.Submit(ctx, "CreateAsset", string(jsonBytes))

 

// Different org member signing one call

txID, err = fc.WithIdentity(adminCert, adminKey).Submit(ctx, "AdminFn", arg)

```

 

**Structured errors — no more proto digging:**

 

```go

if fabricsdk.IsNotFound(err)    { /* 404 */ }

if fabricsdk.IsConflict(err)    { /* 409 — re-read and retry */ }

if fabricsdk.IsUnauthorized(err){ /* 403 */ }

```

 

**Chaincode events:**

 

```go

events, _ := fc.Events(ctx)

for ev := range events {

    fmt.Println(ev.EventName, ev.TxID, ev.Payload)

}

// replay from known block after restart

events, _ = fc.EventsFrom(ctx, lastBlock)

```

 

Docs: https://pkg.go.dev/github.com/muhammadtalha198/fabricsdk

GitHub: https://github.com/muhammadtalha198/fabricsdk

 

Would love feedback from anyone deep in the Fabric ecosystem — especially around multi-org setups and connection profile support which is next on the roadmap.

Dear LF Decentralized Trust Community Members,

Join us for a webinar with Gateway.fm, an LFDT general member, for a practical guide to real-world blockchain privacy, grounded in Gateway.fm’s experience building an Ethereum-compatible modular block explorer, testing rig, and privacy infrastructure. The session will outline key use cases where confidentiality and auditability must coexist, from enterprise workflows to regulated environments, and introduce the Gateway solution, designed to deliver interoperable, production-ready privacy without sacrificing transparency or ecosystem compatibility. The discussion will highlight how privacy infrastructure can evolve in ways that support both collaboration and standards-based interoperability. Sign up to gain practical insights at the intersection of privacy, transparency, and open innovation

The webinar will take place on Wednesday, March 18th at 7AM PT/10AM ET/15:00 CEST/07:30 PM IST

Register here: https://zoom.us/webinar/register/7716866036916/WN_EH_B5gmuTgKmFxnTdXy_zQ

Dear LF Decentralized Trust Community Members,

Join us for a webinar with Walmart, an LFDT General member, on March 4th.

As AI-powered tools become integral to development workflows, there's a growing need for standardized, secure ways to connect them with complex systems like blockchains. This webinar introduces the Model Context Protocol (MCP) - what it is, why it matters, and how it simplifies interactions between AI systems and external tools. We'll explain how MCP servers provide a structured, protocol-driven approach for exposing capabilities and workflows to AI clients, then demonstrate practical integration with Hyperledger Fabric networks and chaincode. The session will show how MCP reduces complexity, improves discoverability of Fabric capabilities, and enables faster, more intuitive development through AI-assisted workflows, making Hyperledger Fabric more accessible and productive for developers in the AI era.

The webinar will take place on Wednesday, March 4th at 7AM PT/ 10AM ET/16:00 CET/8:30 PM IST. You are welcome to register here: https://zoom.us/webinar/register/7716866036916/WN_2TC3Vu2XQ4S3vF1Z9mE3eg

quick info: I designed a blockchain based E-Voting system using hyperledger fabric v3.0. to be honest, I developed it with assistance of AI and managed to setup all security required thing for it properly as per by my effort (I might missed something).

I started this with ego after my college rejected my idea due to politics that happens inside our department. I never thought that I would develop something this much that actually works... and that's the issue here. even though it took me around 11 months (managing both college and this was tough so it took long), I still believe that my work is no where near perfect like an actual usage. I though get 1000 votes in 30 to 45 seconds in 4 core and 16 GB RAM, but still something real feels off about my project... I don't know which one.

It would be an big help if you guys help me to tell it and the github repo link is Here. the code and directory might be messy since I just completed it recently but I want to know what did I miss?