rust-pep

Public Key

npub1d8g4grgel3wyytlc895sp3sh23clfs3y7etwneuk94sczdpevnsqr9x77u

Profile Code

nprofile1qqsxn525p5vlchzz9lurj6gqcct4gu05cgj0v4hfu7tz6cvpxsukfcqpz4mhxue69uhhyetvv9ujuerfw36x7tnsw43qz9rhwden5te0wfjkccte9ejxzmt4wvhxjmcwq8fzn

Publishing to

relay.ditto.pub

relay.damus.io

nos.lol

Author Public Key

npub1d8g4grgel3wyytlc895sp3sh23clfs3y7etwneuk94sczdpevnsqr9x77u

Show more details

Last Notes

2026-10-31 20:13:45 GMT

This week started off with trying to put bark, an ark implementation, in a wasm front end. That didn't work so well because bark needed a package used as a random number generator. It was a lesson learned. The most likely solution is to create a backend to handle the bark details with the front end simply making api calls.
My decision for the next rust project is whether to build out this tool from which I can refresh vtxo's or choose another project. The other options are to look into rbitcoin, an alternative to electrs or a project called burn on reading. Burn on reading was a tool in start9 in which the user created an ephemeral file. The user could read over tor and once the file was read it was deleted. I would like to bring it back to startos 0.4.
As for my effort during the day this week, I had the pleasure of setting a client's collection of python files into an actual project. Additionally, I set the standard for setting the python virtual env from the project's requirements.txt. This will solve the client's problem of running the code across different machines. At the moment, each user is running the code from the global python interpreter. This can lead to version issues.
#rust #ark #bark

2026-10-23 16:51:39 GMT

A week of listening in on the summit of Rust Bitcoin. Per usual, it was drinking from a waterfall because the knowledge and understanding of bitcoin and rust are deep in that group.
The coding effort for the week was focused on adding to my desktop app of a bark wallet. I added two main features that make the app more functional as a lightning app. The first was the ability to receive an onchain transaction and then onboard the utxo into a vtxo. The second feature accepted a lightning invoice and pay it. I still need to automate the refreshing of vtxo's, but I haven't decided the best way. I don't want to rely on a desktop app which would need to be open as well as the computer it is on to be connected to the internet. So it'll take some more thought.
#rust #bark
https://gitworkshop.dev/npub1d8g4grgel3wyytlc895sp3sh23clfs3y7etwneuk94sczdpevnsqr9x77u/relay.ngit.dev/bark-wallet

2026-10-16 20:20:56 GMT

Rust-pep has been at TAB conf this week. As in past TAB conf, it was drinking from the fire hose. The caliber of speakers is high and their knowledge of the bitcoin protocol is impressive.
There was a presentation on wavelength. That is lightning labs’ ark implementation. Specifically the explanation of how a refresh round functions was useful. The presenter walked through how the new funding transaction has the old transaction output as an input which ensures that the process is atomic.

2026-10-07 20:19:33 GMT

This week in "what is rust-pep learning". It was a continuation of the Helsinki full stack course. The big lessons were in building the back end. The course led me through building the express backend for the react front end. The backend added a mongodb data store, so the lessons were on managing data rules through the node package `mongoose`. The course also added users and then login endpoints. The login was managed by java web tokens.
The course added to my understanding of the javascript ecosystem. It was good to have another look at how testing is handled. These tests did make use of mongo in the cloud, so I would have to go learn what in memory solutions there are or dig into adding a docker container running mongo for the tests. Nonetheless, I am glad that tests are part of the course. Often, a course will say that because those tests touch a resource then it isn't unit tests and the course doesn't cover it.
#BackendDev

2026-10-02 13:30:08 GMT

After creating a few apps in dioxus for my own benefit, I decided that I needed to understand react. Dioxus took from the patterns of react and it would be valuable to grasp better the way the front end is devised.
I found a course that is from the University of Helsinki. It walks through the full stack tooling. This week I dove into react and calling a backend json database. The big lessons were on how react handles variable definition and its syntax for async functions. With the variables, the lesson was understanding the definition of immutable. The async functions were interesting to learn that the `.then` method returns a promise rather than the value from the async function. It required a different thinking from rust async function in handling the results of the function.

2026-09-25 12:55:57 GMT

This week I deconstructed a chat server built in Rust. 🦀
The project that I dove into is a chat server and client. I spent time tracing where threads spawn and how mpsc channels manage data over TCP streaming connections. It took me some time to parse through the loops and spawning of threads. After digging past that, the lesson was how the channels layer handle messages on top of the raw TCP streams.
As the llm summarized for me:
Big takeaway: Understanding the interplay between TCP streaming and channel mechanics is key to mastering backend concurrency. 🚀
#Rust #BackendDev

2026-09-17 19:39:41 GMT

This week didn't have any great output. It was a strong learning week nonetheless. I spent the most of it working on the grep task from codecrafters: https://app.codecrafters.io/courses/grep/overview.
The codecrafter stages were good lessons. I stopped when I got too wound up on my thinking and the other students' solutions weren't getting me unstuck.
I shifted my learning to a project from someone else. It is a chat system. I expect that it will serve me to get deeper understanding of async and networking. I intend to grok the existing code and then may build out small parts of the chat.
https://github.com/LoipesMas/accord

2026-09-10 21:28:31 GMT

I wanted to figure out how to create my two dioxus apps as stand along desktop apps. It required learning what the current working directory in the app is. From that learning I could set the path to the sqlite database I kept in the repo root. I still need to learn how to handle the database path in mobile, but I will leave that for another day.
I then shifted my focus to a presentation on dioxus that is part of a demo day at our company. It took me a while to give a definiton of what dioxus is. I didn't want to get too technical but wanted to give the understanding of why it matters. After getting that down, I created three example apps. The first one is a simple app which I will live code to show how the rsx macro works. The second app is the counter example which is to show how dioxus builds the app to desktop, ios, and web. The third one is used to show how rust can be used in the rsx macro to add functionality when a signal variable changes.

2026-09-04 12:45:10 GMT

I wanted a tool to accept lightning and convert to onchain. Second has an ark implementation that is pretty good with its fees. This week I built my own little dioxus app that uses Second's bark-wallet rust crate. It can create a lightning invoice which then Second converts payment receipt to vtxo's. After the lightning invoice is paid, the app can offboard the vtxo's to onchain. I wanted to see if I could get the app to run as an ios app, since dioxus is capable of compiling to an iphone app. The hurdle is learning where I can store the sqllite db file. I have to still learn what path or directories ios makes available for read write files like that with sqllite's db file.
https://gitworkshop.dev/naddr1qvzqqqrhnypzq6w32sx3nlzugghlswtfqrrpw4r37npzfajka8nevttpsy6rje8qqy2hwumn8ghj76twv3jhstnwva5hgtnyv4mz7qg4waehxw309aex2mrp0yhxgctdw4eju6t09uqqkcnpwf4j6ampd3kx2aqnd5rus

2026-08-27 12:36:05 GMT

Building on my effort from last week with the tower crate, I built the logic of the rate limiter in the actual handler function. From there I moved the logic into the middleware which was built from the tower Service trait. It took me some time to get my head around the details of how the tower trait function, but after some false moves it functions. From there I added unit tests using the tower's ServiceExt for oneshot calls of the endpoints. These tests uncovered a hole in my logic. I had to fix the dashmap to track the endpoint with the api key.
Ultimately, this was a good next step in my learning. It pushed me further into async and how it functions. The use of tower's traits at first seems verbose but it does force me to dig into rust more.
https://gitworkshop.dev/naddr1qvzqqqrhnypzq6w32sx3nlzugghlswtfqrrpw4r37npzfajka8nevttpsy6rje8qqy2hwumn8ghj76twv3jhstnwva5hgtnyv4mz7qgkwaehxw309aex2mrp0yhxg6t5w3hjuur4vghsq9rjv96x2ttvd9kkjar9wgkkyctrddjkueqhqvkkc

2026-08-21 12:51:41 GMT

This week started by looking for a new project to continue my backend learning. One recommendation was to build my own middleware. My effort for the week focused on the tower crate. This led to going back to studying async and the Future trait more deeply to understand and how tower builds its futures. From this understanding, I started a project to build my own middleware using the tower Service trait in axum endpoints. This middleware will rate limit the number of calls per minute based on the callers x-api-key.

2026-08-14 16:40:45 GMT

This week I built out the transaction page. The utxo's are from one of the wallets and the output is from the other wallet. In building the transaction I handle removing utxos form the available list when they are chosen. Also, fees cannot be less than one.
The show psbt button, at the moment, simply prints out the psbt struct. It isn't pretty but for now it functions as proof that the parts of the transaction are built correctly.
The effort this week was a good step towards having a functioning wallet.
Repo:
https://gitworkshop.dev/naddr1qvzqqqrhnypzq6w32sx3nlzugghlswtfqrrpw4r37npzfajka8nevttpsy6rje8qqy2hwumn8ghj76twv3jhstnwva5hgtnyv4mz7qgkwaehxw309aex2mrp0yhxg6t5w3hjuur4vghsqytzw33j6erfdau82uedwaskcmr9wsqk9uwa

2026-08-07 14:39:40 GMT

This week in "what did pep do in rust", I spent my time in nostr and bdk in dioxus.
For the nostr code, I used the nostr-sdk crate. The feature I wanted was to have a mechanism to share a bitcoin address privately between friends. The friend could send me an address to which I can send bitcoin. In the commit referenced below, I wrote the code to use the Nip 17 private dm. The code works. The retrieval of the private dm events has been inconsistent. I expect that has to do with relay rules, but I don't know. As a solution, I could set up a database to hold retrieved messages so that I don't make a relay request each time I want to read the event's message. Until I understand what is causing the inconsistency I am going to put this feature to the side.
I started the bitcoin wallet also this week. I used the regtest docker setup from boltz. In building out the wallet code, I went through some iterations of different structs.
The dioxus app functions. It shows the two wallets and their balances. To get the syncing of wallets with the blockchain, I asked ai to add that functionality. The code works, but I need to dig into what the context and resource functions in dioxus do. Then I can figure out what the ai has done. I have already taken out some lines that the ai added which don't have value.
Private DM on Nostr:
https://gitworkshop.dev/npub1d8g4grgel3wyytlc895sp3sh23clfs3y7etwneuk94sczdpevnsqr9x77u/relay.ngit.dev/btc-dioxus-wallet/tree/ef173ee0d2d9457c108cf36bb8345fb04e59ebb8
This week's branch with the dioxus app + bdk wallet
https://gitworkshop.dev/npub1d8g4grgel3wyytlc895sp3sh23clfs3y7etwneuk94sczdpevnsqr9x77u/relay.ngit.dev/btc-dioxus-wallet/tree/dioxus-basic-wallet

2026-07-31 16:23:54 GMT

- reply

I spent this week learning Dioxus, a rust crate for building apps, which can be compiled to web, mobile or desktop.
After learning from the docs and the tutorials, I tried my hand at building a static web page to put on Github Pages. I got stuck on solving the problem of a `base_path`. Github Pages are not at the url root but rather at a subpath: `www.root.com/subpath`. Because Dioxus collects the paths in the code when it compiles a static page, the `base_path` messes with where the Dioxus function looks for paths. All that to say, my efforts to work around it came up empty.
I then created a desktop app. It handles the calculation of bucketing a bitcoin purchase into different savings buckets based on different fiat sources. I used an LLM for the CSS to make it look appealing.
This project was a good first step into Dioxus. I learned how Dioxus uses its rsx macro to build the app. Also, I learned how to devise the global variables to manage state
https://gitworkshop.dev/naddr1qvzqqqrhnypzq6w32sx3nlzugghlswtfqrrpw4r37npzfajka8nevttpsy6rje8qqy2hwumn8ghj76twv3jhstnwva5hgtnyv4mz7qgkwaehxw309aex2mrp0yhxg6t5w3hjuur4vghsqxrxd9shgtt90p3ksctwvajj6cmpd33h2mrpw3hhyhfd2yd

2026-07-25 21:41:53 GMT

- reply

I became interested in boltz swap and the ingenious way it does atomic swaps. There is a docker-compose that boltz created which runs a bitcoin node, liquid, lightning node, and boltz exchange running in regtest. Using that docker setup, I built my own little app using the boltz sdk that the Bull Bitcoin team released. I did not handle failures such as lightning payment failures in this first iteration. Nonetheless, for me it is a good introduction to the boltz service.
https://gitworkshop.dev/naddr1qvzqqqrhnypzq6w32sx3nlzugghlswtfqrrpw4r37npzfajka8nevttpsy6rje8qqy2hwumn8ghj76twv3jhstnwva5hgtnyv4mz7qgkwaehxw309aex2mrp0yhxg6t5w3hjuur4vghsqrnzdak8g73dwdmkzupdv9c8qd3qg38

2026-07-25 21:34:53 GMT

- reply

For one our company's show + tell afternoons, I put together a presentation to introduce rust to my colleagues. It shares why rust is important and will be a piece of every project. It also shares the sharp corner of rust, known as the borrow checker. The presentation ends with a small demo of a rust gui built using the iced crate.
https://gitworkshop.dev/naddr1qvzqqqrhnypzq6w32sx3nlzugghlswtfqrrpw4r37npzfajka8nevttpsy6rje8qqy2hwumn8ghj7un9d3shjtnwva5hgtnyv4mz7qg4waehxw309a5kuer90qhxuemfwshxgetk9uqpyurjda4x2cm594jx2umrwf5hqar0wglnfs7f

2026-07-25 15:55:21 GMT

In an effort to practice my rust skills, I picked up the codecrafters courses. They are challenges built around particular protocols, such as Bittorrent. As I worked through the different tasks I learned more about reading and sending bytes over tcp. I also was able to work on my rust knowledge because the tasks functioned as a code kata. I could code my solution and then compare to other solutions that are posted by other codecrafters users.
https://app.codecrafters.io/catalog

2026-07-25 00:11:24 GMT

The beauty of bitcoin is it is code. The beauty of code is that it is learnable.
One book that was introduced to me was Building Bitcoin in Rust. It walks through building a transaction and leading to validating a block. First it teaches the reader how to parse the bytes of a transaction into rust structs. Then the transactions are built into a block. Finally the block is parsed and validated.
The benefit to me was a deeper dive into the bitcoin protocol and its building blocks. Additionally, I learned more about the rust ecosystem and how to handle bytes in rust.

2026-07-24 21:59:26 GMT

I want to create a tracking of my learning of the rust language. Along with making it visible to others, I want to sue it for my own accountability.
This effort of getting into rust started about two years ago. Those little projects were stored in this gitlab account. https://gitlab.com/bitcoin-pep/a_repo_descriptors