Skip to main content

3 posts tagged with "lampo"

View All Tags

· 3 min read
Vincenzo Palazzo

First of all, Merry Christmas!

In my free time, I have been working on a lightning node using LDK, which I've named Lampo (Italian for lightning), for more than 1.5 years.

The initial draft was developed as a toy lightning node to support lnprototest [1] for LDK. During its development, I realized I was nearing the completion of a small, self-contained SDK for building a lightning node with LDK. So, in March, I decided to take a shot at implementing a full node using the Lampo SDK.

I have currently supported the first basic commands listed in the following part of the code [2] (admittedly, it's not ideal, but a help command is on the way), and things seem to be working. I am also close to having integration tests between c-lightning (cln) and Lampo, in addition to including lnprototest protocol tests.

Hoping to attract users and contributors, I am excited to release the first public beta version v23.12 today and begin receiving initial feedback on features most desired by the community. However, I cannot promise that I will implement them all—though patches are certainly welcome, of course.

Small Real Life Example


Currently, Lampo only supports Bitcoin Core as a backend and utilizes a core wallet, so we do not have a separate wallet but derive one from a BIP 39 seed.

When you install Lampo on your machine and run lampod-cli for the first time, the BIP 39 words will be printed in your terminal:

➜  ~ lampod-cli --network-signet
✓ Wallet Generated, please store this words in a safe place/way
waller-keys maple have fitness decide food joy flame coast stereo front grab stumble

Then, each time you restart the node, you will need to input the words using --restore-wallet:

➜  ~ lampod-cli --network-signet --restore-wallet "maple have fitness decide food joy flame coast stereo front grab stumble"

To view your node's information, execute:

➜  ~ lampo-cli --network signet getinfo
"node_id": "039406c61582cc7a1282eda1c59c73fc3fa97cab1057e215136e35d5dd0c98c981",
"peers": 0,
"channels": 0

Now, you can open a new channel with one of our Lampo lightning nodes hosted on Signet:

➜  ~ lampo-cli --network signet connect --node_id 03cdc5ce9df1e05653a1f2db9e29bad1a1c81940315dd16e66216803aac07423aa --addr --port 39736
"port": 39736,
"node_id": "03cdc5ce9df1e05653a1f2db9e29bad1a1c81940315dd16e66216803aac07423aa",
"addr": ""

Then, open a new channel:

lampo-cli --network signet fundchannel --node_id 03cdc5ce9df1e05653a1f2db9e29bad1a1c81940315dd16e66216803aac07423aa \
--addr --port 39736 --amount 10000 --public true

For now, you'll need to monitor the logs for possible errors during the channel opening process, but we are working to streamline this soon.

To check if your channel is ready for use or to explore other channels, you can run:

➜  ~ lampo-cli --network signet channels
"channels": [
"short_channel_id": null,
"peer_id": "026b92e6cc3e0f24b42494672ecf65f3d147b9deb95186bf024da7a7745008ee75",
"peer_alias": null,
"ready": false,
"amount_satoshis": 100000,
"amount_msat": 96634000,
"public": true,
"available_balance_for_send_msat": 99000000,
"available_balance_for_recv_msat": 0

You can make a payment using the keysend or pay command. See the code for more details :) or join our Twitter community [3], where you can ask any questions you may have.






· 2 min read
Vincenzo Palazzo


In this post, we describe how we are testing our lightning node implementation and how we are integrating the Lightning Network Interoperability Initiative into our development.

Different kinds of integration testing Before start describe how we implement our integration testing, we need to introduce the definition of Vertical Integration Testing and Self Integration Testing.

From Lightning Network Interoperability Initiative we find the definition:

  • Vertical Integration Testing: An implementation must be tested alongside other implementations.
  • Self-Integration Testing: An implementation must be tested for compliance with its own standards (note: most major implementations are currently doing this).

So in this post, we describe how we choose to develop our integration testing and what kind of results there are to bring to us.

Lampo Node Integration testing Lampo is built with LDK which mean that we already have a tested library with a self-integration test, but this do not make us safe from bug.

In fact, an LDK node is required to implement a sequence of workflows to manage events and interact with external systems while an event is received or generated. This can introduce bugs and can lead us to strange bugs that are not happening on LDK integration testing. Another important source of bugs is the integration with other implementations.

To solve this problem and deploy a safer lightning node implementation, we are going to write a sequence of integration tests with the tool provided by the Lightning Network Interoperability Initiative and write a basic integration test between lampo and a core lightning node.

What we have found While writing this test required a big amount of work, we also had some security checks when we were migrating lampo to a new version of ldk or when we needed to reproduce a bug that happened with some specific version of core lightning.

Recently we were upgrading Lampo to a new version of LDK, and we noted that our payments from lampo to Core Lightning were failing. We found that something was wrong between LDK and core lightning and we are investigating this issue.

To read more about this issue or to help us please join our zulip dev channel



· 2 min read
Vincenzo Palazzo

Hello to the Lightning and Bitcoin communities!

We're thrilled to introduce Lampo, our open-source lightning node implementation crafted meticulously in Rust. As technology enthusiasts deeply entrenched in the world of Bitcoin and its associated technologies, we noticed a space for an alternative. A space for something robust, transparent, and community-driven. That’s where Lampo steps in.

Why Lampo?

While there are renowned lightning implementations like core lightning, lnd, and eclair, none resonated with our vision for an open-source lightning node built upon the ldk. Our goal is to offer a platform that's not just driven by business needs but also by genuine innovation and community feedback.

Unique Features

Lampo boasts features like swappable APIs, on-chain data sources, and a flexible wallet system. And yes, we’re future-ready! Plans are already underway to support Fedimint, LSP, and VLS. Our dedication towards creating a powerful architecture will ensure Lampo serves all the needs of the modern lightning network community.

Join the Conversation

Determined to maintain clarity, we’ve chosen specific channels for communication:

  • Developers, join us on Zulip.
  • Community members, our Reddit community awaits your insights.
  • For technical questions and feature requests, dive into our GitHub discussions.

In Conclusion

Lampo is more than just software; it's a movement. A movement towards better, more transparent, and community-centric lightning node technology. We're excited for you to join us on this journey, contribute, question, and help us shape the future of the Lightning Network.

Stay electrified!