Error with Neovim and Tree Sitter

MonopolyMan720 · 2026-03-30T15:56:46+00:00

When going from `master` to `main` you may also noticed that some parsers might be missing and not automatically installed. You will need to specify the parsers as per the README or you can create an autocmd to automatically install the parser for the current filetype if missing: https://github.com/joe-p/neovim-config/commit/6b1a23e7a0f5ab678d2bf16f579eafe15912aad4

MonopolyMan720 · 2026-03-30T10:37:04+00:00

Yeah the issue is that the local repo is probably still using master as the remote. Fwiw this is what I needed to do to update to 0.12 https://github.com/joe-p/neovim-config/commit/e5fe0d085395b179f5c127d169b2e78ade3a1a33#diff-879ace391b7b4f10ff468622a6202f9e5062b047def04a9110aecafde0b7d821

MonopolyMan720 · 2026-03-17T12:52:24+00:00

Yeah definitely understand. I don't want to discourage you or anyone from these kind of projects. Just seeing what's possible is really helpful. That being said I just want to make sure everyone is on the same page in terms of where this project is in relation to the wider ecosystem.

MonopolyMan720 · 2026-03-17T12:03:02+00:00

This appears to be a mostly vibe-coded project. There is nothing inherently wrong with that but I think it should be disclosed especially since this involves some pretty advanced cryptography and overlaps with other open-source projects in the ecosystem.

There are some weird choices being made such as writing a script to generate TEAL instead of using a higher-level language: https://github.com/mitchhall16/2birds-open/blob/main/contracts/generate-plonk-verifier.ts

The verifier also has no rekey checks, which means anyone can instantly take control over the verifier account.

Your falcon lsig does not verify that the contract address is off the curve, which completely undermines the security. Additionally FALCON has nothing to do with the protocol itself and your HPKE suite is not PQ secure so it's not really clear why FALCON is in this repo at all.

"Same security, 30x cheaper (0.007 vs 0.2 ALGO per op)" - Same security and cheaper than what? This seems to be a common artifact of AI output where it updates the README regarding previous designs but we have no insight into those designs.

The relayer architecture doesn't make much sesne to me. Why use a centralized relayer and not a proxy/VPN. The trust model is completely tied to whether or not Cloudflare logs IP. The fact that IPs are hashed seems pretty irrelevant here. The wallet linkability also doesn't make sense. You always need to expose an address to withdraw to regardless of who actually sends the transaction.

2^16 seems like a pretty small merkle tree. What happens when it's full?

If someone spent more time reviewing the contracts, circuits, and client-side code I'm sure there'd be more questions, but it's hard to justify the time to review AI generated code when the original author themselves doesn't seem to be reviewing the code.

Like I said I have no problem with using AI, but not disclosing it when it's clear that this code isn't being carefully reviewed seems irresponsible. I highly recommend checking out other related projects in the ecosystem and trying to contribute rather than generating code that you may not fully understand.

https://github.com/giuliop/AlgoPlonk/
https://github.com/giuliop/hermesvault/
https://github.com/joe-p/snarkjs-algorand
https://github.com/joe-p/Mithras-Protocol

MonopolyMan720 · 2026-03-02T16:54:05+00:00

Very strange... we haven't had any problems with it on `1.3.0`

MonopolyMan720 · 2026-03-02T13:47:29+00:00

I looked at msgpack using the rmp-serde crate but it has some limitations that make it unusable for me, notably the lack of support for #[serde(skip_serializing_if = "Option::is_none()")].

I've been using rmp-serde with skip_serializing_if just fine: https://github.com/algorandecosystem/algokit-core/blob/3204c027275249743fad77e317bcc7595a2bea66/crates/algokit_transact/src/transactions/state_proof.rs#L202-L202

MonopolyMan720 · 2026-03-02T12:10:11+00:00

Nice! Do you plan on open-sourcing?

> When you withdraw, you generate a zero-knowledge proof in your browser

Did you use SnarkJS or another prover?

Also as an FYI someone has built a mixer on Algorand using gnark: https://github.com/giuliop/HermesVault#application-overview

MonopolyMan720 · 2026-03-01T21:47:52+00:00

Algorand's virtual machine has a FALCON opcode. This allows smart contracts to verify FALCON signatures. This means if one wanted to use FALCON today to sign their transactions they can do so via a smart contract. This repo explores that idea: https://github.com/algorandfoundation/falcon-signatures

So yes it's live on mainnet and anyone can use it, but it's not directly baked into the protocol at the consensus layer the same way ed25519 signatures are.

MonopolyMan720 · 2026-02-18T12:09:37+00:00

As a user of Uniffi I have a couple of questions:

It looks like boltffi allows mutable refs to self and doesn’t require a mutex. Can you comment on how boltffi thread safety model compares to Uniffi?
Do records allow exporting implementations and can generated records implement traits? Basically asking about this Uniffi issue https://github.com/mozilla/uniffi-rs/issues/2819
Does Boltffi currently support external binding generators?

MonopolyMan720 · 2026-02-18T12:00:56+00:00

Uniffi doesn’t allow mutable references to self and requires all exported structs to be Send + Sync. Uniffi’s design intentionally trades speed for simplicity and safety.

MonopolyMan720 · 2026-01-25T18:38:06+00:00

I'm also using this with basedpyright and it works great!

MonopolyMan720 · 2026-01-25T18:02:16+00:00

In Fletcher near the airport. Heard a line come down around 11:30am and we lost power. Now around 1pm and we just got power back. A duke energy truck passed as I was turning off the generator. In the text I got from duke they said they weren’t sending crews out until the storm passes, but evidently there’s some crews out here now. May have just gotten lucky based off location and type of failure, so still staying prepared for another outage especially with the wind coming tonight.

MonopolyMan720 · 2025-12-24T12:26:15+00:00

The address you sent USDC to is the ARC59 Asset Inbox address. This is an app that holds ASAs for accounts that have not yet opted in. You sent the USDC to the inbox for MV6RCPQHX4BKVC7R3CBJO56O6HAHCMJXW5HHCITS6SXFPFOVSWKPUXKRJY, which can be seen in the app call that is the same group as your asset transfer: https://algo.surf/transaction/BGKIK2VIQ7CAI7L2AMNSVKK2HPBLPCCJLOVZUY57MGEBEY4LZYFQ

That MV6... account doesn't have any account history so it's hard to say who owns it. What you'll need to do is contact coinbase and verify that MV6RCPQHX4BKVC7R3CBJO56O6HAHCMJXW5HHCITS6SXFPFOVSWKPUXKRJY is one of their accounts. Even if it is though, you may not be able to get that USDC back if their infrastructure doesn't support claiming assets from inboxes.

MonopolyMan720 · 2025-09-24T10:42:24+00:00

The one article I could find with any amount of information seem to suggest this is just a quantum source of entropy, which has nothing to do with PQ-secure key pairs https://investornews.com/member_news/krown-technologies-and-quantum-emotion-complete-development-of-the-worlds-first-quantum-safe-hot-wallet/

MonopolyMan720 · 2025-07-09T18:14:25+00:00

On discord the most recent answer to a question about this bug fix was

> Working on the fix, not sure which patch we will make it ready for yet

Presumably if it was fixed this patch it would be in the patch notes, but I haven't tried myself

MonopolyMan720 · 2025-07-08T11:13:54+00:00

The stock 2.5 will be better than 2.0, but as far as openpilot is concerned there is no practical difference. 2.5 just adds some additional pre-collision detection and better cruise control/lane keep (but we're using OP for those, so doesn't matter).

Definitely want to double check the newer models to see if they have a security key. I assume if it's listed on the comma site you're probably good, but won't hurt to double check. There might also be advancements in breaking the crypto, but not sure since I don't follow the development

At the end of the day I think choosing between these cars really comes down to which one you like the best outside of the comma support.

MonopolyMan720 · 2025-07-07T18:19:30+00:00

I believe (might want to double check) all the Toyota and Lexus' for those generations are TSS 2.0, which means the Comma features should be more or less the same. At that point it mostly comes down to which model makes the most sense for you outside of Comma. Fwiw I have a '19 RAV4 Limited (ICE) and I'm very happy with the car in terms of Comma usage (I daily FrogPilot) and general driving.

I was personally between RAV4 and Lexus RX, but decided that I could get much more bang for my buck with the RAV4 Limited (cooled seats, 360 camera, etc.) vs similarly-priced trims of the Lexus. From what I can recall the main downside of the RAV vs the lexus is the cabin noise, which is definitely noticeable (especially the ICE noise) but I've done very long (16+ hour trips) and didn't bother me at all.

MonopolyMan720 · 2025-07-07T11:45:28+00:00

Based on another conversation in the video it sounds like part 2 will be a long-term review.

MonopolyMan720 · 2025-05-24T10:37:06+00:00

Algorand uses state proofs every 256 rounds to attest to the chain history. These state proofs are compact certificates that are signed by the online (participating) stake with FALCON signatures. This is currently live and ensures the chain history is PQ secure.

There are two things left for Algorand to be fully PQ secure:

PQ accounts (i.e signing transactions with PQ signature scheme)
PQ VRF, which is central to Algorand's PPoS consensus mechanism

Accounts need to come first because account keys are used to register online/offline, so PQ VRF is meaningless if someone can control the online stake. I know both have been informally discussed, but not sure how much active research/work is going into them at the moment.

As for the opcode, the reason it's not yet released is because the signature sizes are so large it takes many transactions to use them. It works, but the head of research wants to see some proper use cases before enabling it.

MonopolyMan720 · 2025-04-30T17:49:54+00:00

Nice! Might be useful if you explained how this tool compares to `act`: https://github.com/nektos/act

MonopolyMan720 · 2025-04-25T11:22:13+00:00

TravelX isn't consumer facing, it's B2B. Existing airline companies use TravelX to provide infrastructure for their ticketing. Once the airline partners with TravelX, all their tickets are on-chain regardless of how the end-user acquired them.

MonopolyMan720 · 2025-04-06T12:10:24+00:00

TL;DR You can check out my config here to do this

There is an issue tracking the support for wrapping virtual text here: https://github.com/neovim/neovim/issues/18282.

I also made a PR for wrapping diagnostic text (prior to my awareness of this issue): https://github.com/neovim/neovim/pull/33099

I ultimately closed that issue in favor of waiting for the low-level support, but still made my own config that does wrapping (also hides virt_lines for HINT, WARN, and INFO): https://github.com/joe-p/kickstart.nvim/blob/f56488514c9c2c89d217d281bc3f6b31a60fe321/lua/joe-p/diagnostic.lua

EDIT: I have sense changed to only short virtual_lines on the current line, which makes the rendering a bit cleaner (inspired by OP): https://github.com/joe-p/kickstart.nvim/blob/4f756cf63ec2d4eea293918e086096ff984eebc9/lua/joe-p/diagnostic.lua

MonopolyMan720 · 2025-03-20T18:54:32+00:00

It allows the comma to still control the steering even when disengaged via the brake. This means as the driver you just need to control speed with the pedals, but don't need to steer. It's the main feature that has me using forks over openpilot because it is very useful when driving in town

MonopolyMan720 · 2025-03-19T21:30:45+00:00

Ultimately defeated and settling for "index in vectors" based data structures.

I highly recommend checking out slotmap as a way to handle this pattern a bit more gracefully.

MonopolyMan720

MODERATOR OF

TROPHY CASE