A good change.

But far from ready. Security ICs take years to develop and perfect.

And in the end, you still cannot verify code running on it, the only difference being NDAd documentation and architecture which makes little difference to the end user.


the goals of security and verifiability are inherently conflicting as to verify you need a chip that anyone can check the content of, but for security you want a chip that no one can see the content of

the MCU may have open source code but the moment it is compromised it could log your PIN on next attempt


still, a pointless attempt.

coldcard for example has a dedicated privileged flash segment (the “boot ROM” which is not ROM at all) that handles retrieving the key and could store the PIN/root key in its small flash segment

it is not truly verifiable without ripping out the chip and faulting it


both of those are not a good fix for public relays, but they are needed


I have sent some things over on Telegram


and false “verifiability” in HWWs, as their designs also mean it makes verification impossible (SE code) or requiring somewhat costly tools to work around security measures (MCU)

having NDAd secure elements is arguably better for security than “verifiability” as in both cases the manufacturer could slide in a backdoor but one means you usually end up opting for worse parts


doing something you are unfamiliar with is fine

but when it comes to securing millions in funds… you need to do research. and be honest where you fall short

too much time is wasted on marketing and the likes: eye candy over functionality, security taking a backseat (“resolved” by adding one or two IoT SEs with a lower bar for security compared to even a credit card, made by manufacturers that do not have a track record for high security SEs) and exaggerated marketing claims (“most secure”, “only airgapped wallet”)


in a market where people don’t verify marketing claims anything can happen


well, technically yes

in practice no


And everyone keeps sourcing their SEs from a company (Microchip) which had made 3 revisions of their chip with only ROM changes and still has not fixed the root cause of flaws in the ATECC508A, 608A and 608B (used in a lot of HWWs) which is that there is no light sensors or self-terminate mechanism in the case of an attack

Their way of rating chip security is via the JIL rating system which is a very low bar to pass and involves the vendor coming up with their own numbers on how hard it could be to attack it, which they conflate with EAL5/6 because that is a lot harder and expensive for what is supposed to be an IoT SE nostr:note1upvg0s73kj57387rpq3zq55jm29fsrf838vnps79k3zzk3ypaldshhpnft


The inherent culture in this protocol means the people that have proper experience with large scale infrastructure are either not here because most of the devs are clowns, or they are here only for personal gain.

And without them you will never scale. nostr:note1nfsjr9kt4j58p43dac6djdrgnp0epwte5dv72jxw2dtk8tratr0q3s09v3


While developing an HWW, I have started to realize that 90% have no idea what they are actually doing and they think that adding a secure element is a silver bullet to all security issues


I’m working on some things that again need something more than a mnemonic… and arguably mnemonics are just shit, being a pain in the ass to implement in hardware


it is not


Contributions get counted based off of the author email…


it should be spread


No. It’s some ordinals shenanigans. I should have checked the address histories more


Yeah it is a node sweeping multiple anchors at once I think


LN node anchors (?)


That is bad for onboarding. Or efficiency.

Why spin up a relay per community if they trust a friend and they have a relay already running?


You either have a server running Debian and manually configure everything, or you don’t run a node. It’s that simple.

If you can’t do that then you will lose funds


Communities are needed but not when they centralize onto individual relays and everyone has to pay just to start one because they can’t use an existing relay by a friend or a public one


Nostr devs are too dumb. And who cares, everyone can pay for a relaybto host.


Didn’t check that


Actually if you hate manually going to their profile on Twitter to verify, there is a spec to link profiles on different platforms to Nostr and even PGP keys


That does not matter

We are verifying that their Nostr identity is linked to a known good identity (their twitter handle with a lot of followers)


If you can’t verify then don’t say shit I guess

The end result will be nostr getting a reputation for fake and scam accounts


Nitter


it is funny watching people trust and not verify

is it really that hard to check for a tweet or something? nostr:note1wdc870agyglksfy9279zws88kd7rqdepq4az46pk0lfmg0xqu38qrecnxj


read the name of the account you are replying to


Yeah because no one has implemented forward secrecy yet.

And gift wraps are shit and don’t work.


DM username


so what? you need some amount of limited access for ecash too


No the UX sucks

Matrix or Signal?


Can redo it if needed, I have a way of doing it about 80x faster than my previous algorithm.

Do you use Telegram so I can DM you there?


Yes and people want to slap it onto everything just because they can

This reminds me of something…. Shitcoins


tbh, one relay per community means people have to pay to start a community, even when using public relays

communities must be encrypted, private relay or not, the hosting service can get compromised, etc


Yes and so why not use LN? Why ecash?


You haven’t read the last part of my post


There is so much data on nostr left to be analyzed


We are going back to centralization with relay = communities


the problem is that you can’t mint ecash without being connected to the internet, and you can’t connect to the internet without paying

also using ecash is utterly stupid for this as not everything supports it compared to LN, and you have to use a “preferred mint” etc and any mint conversion mechanism already uses, you guessed it, LN nostr:note1sldhcs0l0uxkkajkwxynlj3f7sfkcltntu8rds97ckd8x4hfcvyqatlwj2


bitcoin core USED to do nondeterministic


To test this there also should be a “fuck them both” option


the only way to make a secure hardware wallet is by not being able to leak what you don’t know

:) nostr:note1e5ecgteu25r2dvrcn9y64cts2c6jx03c90ccuju7ksjp3zr5qseqeaqske


preventing side channel attacks is really fucking hard


That is caused by the transaction system used by ZFS: all writes are committed in 5 second transactions, and before that the blocks reserved for the write and the original blocks for CoW are both “used”

This is kind of the shittier part of the FS, as it means sync writes run twice: one to the ZIL, and then to the actual disk.


inkjets are arguably the dumbest printers that could exist: a motor to move the paper, a motor to move the print heads, the ink itself, print heads that just spray ink droplets, and some sponge to hold waste ink for cleaning

it’s all the extra bloat on top

and the software that means that the printer either clogs after no use, or it keeps dumping shitloads of ink every day as “maintenance”

you can dump a ml or two of ink through the heads every few days and it’ll never clog or accumulate air while powered


I own an epson ecotank that is decent, and have the software for resetting the waste pad counters if need be (they are on sketchy websites, but it works and you can run them on a VM with USB passthrough and no internet only)


also nothing can beat laser in water durability, pages per minute and reliability for low volume use


modern inkjet printers are the work of the devil

yes, inkjets arguably have their place in high resolution printing, especially for color images

that doesn’t mean shit if the printer keeps clogging instead of using the bare minimum amount of ink every few days to prevent clogs when unused, having the problem of non user serviceable waste ink sponges + print heads for tank printers, expensive af cartridges, and DRM on those

something composed of a dumb print head, two motors, a paper feeder and a sponge apparently has to be so fucked


I like ZFS but I cannot deny it feels very out of place

It tries to integrate block device abstractions and the filesystem into one layer.


Yes, that is the only option. You must add the relay used by the NWC server I believe


And yet they still fall for bullshit propaganda from HWW manufacturers, are delusional about the state of Bitcoin and Nostr, and keep bitching about stuff they don’t know about. nostr:note1mh7c2qx9hxp7wjf3prd7wmu9kzs7ktjjvs9nlhqcdr3qfsk8a9wqtz8vc5


Cancel your credit card


Getting ready to face a new day ... #catstr
https://image.nostr.build/411531303f502da261fdaaa29aadc9af6bca52217940e72787c2c4168a92b889.jpg


still has latency, considering USB is still polling based


no one cares, they just want to complain

nostr nests had no relation to nostr for a year+


on Pi’s this actually negatively impacts performance and SD card longevity


the in other words part is wrong


They charge additional fees as a credit card provider to merchants.
Then they take most of it and give you pennies.


If you're not paying attention to what's going on with The Internet Archive, you're missing a BIG story.  This is NOT good.  Currently they are under DDOS and this is after they're being sued out of existence for digitizing 78rpm records that aren't even available anymore.  They're facing a $600+MM lawsuit.  They previously lost a suit during the 'demic when they released digitized books for free.  The likelihood that they will end up shut down and entire histories of the net will be lost forever is high.


WoT is pointless for resumes


I love it for being explicit when you ignore and when you handle (with no other option) and hate it for being repetitive


fuck. s/n nil/n err/


if err != nil {
    return nil
}


it will be bad when a client’s domain gets compromised and nsecs leaked via an attack

so people will switch to web based signer apps

then they will be compromised

the only way out is a proper hardware signer, a proper remote signer or a browser extension


Go is the way for backend.

Kotlin when you need it.

C will stick around forever for some use cases because it is very close to machine code. nostr:note15u74uj0qu5ftvytp7y2w2mnxqqwkvzrejnscmrqq8hz2mzsv7kdq2gylv8


Verify performance?


I think not being burnt out is more important

There’s moderation work, and clients also want features, then you need to make sure it runs stably, etc.


did you hear about static or dynamic analysis? 😆


to be able to have AI scan vulnerabilities means that it needs to be able to build a map of the application logic, how every small detail interacts and how these may combine into an exploit chain

that is not possible with a text predictor


nostr.build already has file search, along with filtering my category and folders


Why use a HWW then?

You need to store the seed backups somewhere, may as well use SeedSigner with the seeds


yes, they have, the SE2 used by CC Mk4 is broken (source: Coinkite), and SE1 also has been broken (source: a talk by the Ledger Donjon team)


Plug it in, authorize the client, then you can manually approve from the app or auto approve certain kinds.

A hardware screen is not necessary for this use case. Manually verifying for every AUTH event or reaction is going to make the UX shit.


both SEs are vulnerable to laser fault injection and lack basic protections that has existed in any credit card for the last 15 years


yes, the only case it could work with unnecessary complexity is where you use a remote signer, each client maintains state locally, and you remove a client

in this case you can also do the following which is easier: rotate the secret used for encryption


actually, wrong term

I meant forward security

post compromise security is interesting, but it is not applicable in nostr


NIP-04 and the likes work (not that they are good, especially gift wraps) but they have no post compromise security


both of them are IoT grade shit (and at least one lacks any CC certification) that don’t have the same basic protections as any credit card within the last 15 years


both of them have viable laser fault injection attacks meaning you only need the expensive (probably $300k max) equipment, but that’s nothing as you can reuse it for as many wallets as you prefer


The idea that an HWW’s security hinges on the secure element only is insane


the devs say “go make a better one yourself” because they are too incompetent to do that themselves


didn’t get the pgp key + email yet though
or signal


they are too busy making the 37th ecash wallet that looks like it was named by an immature idiot to fix real issues nostr:note1wzxcmgtmcwegr6dfqlc9kkydmnxvlumzz0qy0dmw0r0r6v8e2ysqktspmg


Have been working on a secure (not some shitty ESP32) signing device over the last few months.

Expecting it to be ready for testing in Q1 2025. DM for more information. nostr:note12ms9x0p79krje7gv76axfvcfrrt7fs9xyyzk0sw069gp80f8wgrs29w40j


security is a layered approach

one of them is having a secure element

there’s more that I will publish later :)


Shredding a credit card does not make it unusable


localhost websockets


That is what I mentioned in my post as not a shitty ESP32


Unfortunately the culture of quantity over quality exists here


Welcome to Nostr

Fast paced low quality half working projects are incentivized more than quality products that take months to build nostr:note1jmav6c840xj2fkzlsjw9c984wvmms422a4mplremq8ga3audjqls9kuagf


And your stupid-ass comments, that people who don't like your garbage code should go build their own app is merely an open acknowledgement that

YOU ARE NOT CAPABLE OF BUILDING AN APP THAT ISN'T GARBAGE.

Learn to code.


Memory bandwidth contention manifests itself as a drop in performance across all cores after some threshold :)


The benefit of a proper hardware solution is that:
- unlike nsecBunker, nsec.app and browser extensions, the impact of malware is limited
- unlike nsec.app your keys cannot be stolen by the app developer with a silent update
- unlike other “hardware” nostr signers, it doesn’t store keys in an easily dumpable ESP32 nostr:note140nfz32f6w0urdj0zv5agxznd226g6whn43n7auz7q2qkggrfeusxwuhlv


Electric car fires are the worst.


we do not need that either

it also supports negotiation

you set a list of protocols to request, server sends a protocol picked or none as a response


websockets already support a protocol header


We can have a version field also.

Version 1: just normal Nostr events, signed as usual
Version 2: fields can now contain non-UTF8 content, new signing scheme


I’m on iOS 17 though. It works fine with HEIC also from Damus. But it most likely is a color space issue.


Uploading from the account page specifically seems to remove color profile data for some reason. https://os.hel1-c1.semisol.net/static-n/color-profile-test.png


p3 test https://i.nostr.build/D1ynVdfBut0sU6Dy.jpg


I’ll DM you an explanation for my idea that will end up never finished soon. 😂


2. No.

All chips have some sort of hardware boot ROM, from your CPU to a Raspberry Pi to the STM32s used in a lot of HWWs including CC.

RPi boot ROM cannot be modified and such an attack would need to target your Pi specifically, which is impossible, and then somehow figure out a way to detect SS code and add a backdoor.


Just to add, the code on a CC is not truly verifiable without destroying the unit


yes, I’m also saying the new binary signature is another detached field like id/sig


I was thinking you would add it to the original event


the problem is with a tag you can’t add the faster signature later


Have been working on a secure (not some shitty ESP32) signing device over the last few months.

Expecting it to be ready for testing in Q1 2025. DM for more information. nostr:note12ms9x0p79krje7gv76axfvcfrrt7fs9xyyzk0sw069gp80f8wgrs29w40j


why?

we can just add a new field like “binarySig”, relays can validate both of them (and backfill binary signatures if later added by the author), and clients can pick one


Please DM me an e-mail address to send further details to along with a PGP key for encryption, or a Signal link


s/optional/not needed/


Binary encoding: we keep compatibility with nostr events, just optimize JSON field names away

Binary events: breaking change in signing scheme that also means conversion to JSON is optional, tag values and event contents can now be binary


Adding complexity means you use the emojis to derive a seed or convert the seed into binary then emojis


That is about as secure as a 12 word seed.

Also, with a scheme like this it is not possible to do words and emojis at the same time unless you add complexity or use 22 emojis


Also DM for testing if interested.


Partitioning is probably the best idea.

I’m thinking we need a binary version of Nostr events (not binary encoded events), for cases where it’s not complicated enough to involve a system like Blossom, but also would benefit from binary encoding like encrypted events.


nostr.land does not :)


What’s the use case?


eithet this has existed for a while and I implemented it and completely forgot, or it’s new


wtf is a uppercase P tag?


“Breaking news: New “AI powered” backdoor that can detect malicious actors defeated by prompt injection”


A backdoor cannot differentiate between good and evil: it does what it is told to do nostr:note1qk2uelcescwpvcrhr8kss9jpvjwcaq3upt6f2u7tlpkvkr34ej3sdz9kj5


Being a bitcoiner does not make you automatically not an idiot. 🙃


Yes, in this case they are forced to pay because they do not want to be inconvenienced or want higher quality.

There is a mandatory two way exchange of value, unlike in V4V where the payment can never happen.


Yeah. That is often rare though and there’s some other benefit to the donators. They don’t believe your cause just because.


You may as well paywall then.


Are you sure that statistic is not made up?


Then specify so.

From my experience operating services, and from info from other people: it’s very close.

You’re trying to divert the conversation because all you care about is creating controversy and getting engagement. Not much different than the legacy social media fucks.


You forgot the initial production cost


It’s facts that you can easily verify. Though that becomes hard when you are delusional, so…


Advertisements.

You are paying with your time.


You just made an illegal lottery. 😂

But early access/members only access works and is free.


Proof?

There’s a reason people are making members-exclusive videos on YT, constantly reminding you to donate on Patreon for exclusive access, etc. Without an incentive it’s all pointless.


What people don’t realize is if not forced to pay, 99% won’t.

The only reason V4V appears to work is people are trying to make their own point valid, not because it actually works nostr:note1we6gzffcek2smm96aruylmldmqk2tq26ryqt36al03mwsed5tr2qpud038


Accidentally clicked post.

But I said it in the post, PGP encrypted messages over I2P


the problem is not the crypto, it’s how devs implement it


I can’t trust Nostr devs to make good cryptography. I would encrypt messages with PGP and sending them over I2P. nostr:note1ekgsp38m0lc2wvp5n5cycyvtd6nl8j79cac0wccet2g5kyjkqurqhdnv7e


gm

📩


this applies everywhere nostr:note1tnnw80qajkej230y6gar2x0754g9usd6kgd88pkqxh2lyh8unvhq33d45w


I proposed a format for that


If you are a client dev and you want features: pay for them. Especially if you are on grants already.

There are a lot of components of Nostr like media hosting and relay software no one cares to pay for but keeps asking for features from.


Programming language


MS teams :|


Torrents nostr:note1t2vnew9s8tvtffyag237jce80g7e30erxx6kaq8564zget28w5ustgpdug


When we run out of that, base-36. Then we can also throw in emojis.


Okay this is it, NIP numbering is now hexadecimal nostr:note180f8e2lfwwmm0y8l7d4znsr258dwq6nrllpswrw45qsu8f4pz2dstmshe5


Try uploading to NB directly and compare


There is no solution… ish

nostr:npub1xtscya34g58tk0z605fvr788k263gsu6cy9x0mhnm87echrgufzsevkk5s could request the HEIC file from the OS instead of a JPEG and do its own compression with higher quality. NB also does optimizations but I do not believe that has significant impact.


Yes, yes it does.
Saving as JPG means you will experience that in your gallery also.


As the requirements for a system’s security increase, the performance (including, but not limited to, features or throughput) per dollar curve starts approaching exponential growth


Ocean with yet another underwelhming announcement. Datum is Stratum v2 but no e2ee and binary data transfer. It might be quicker to adoption due to it's simplicity but they're resources could have been better spent working on Sv2, IMHO.


validates for me on damus


the worst part about all the sheep on nostr is they don’t know they are sheep


Note: if your nsec gets compromised any Nostr Plebs e-mails will be visible. We will implement a spec with forward security when available.


because walled gardens.

and even though we like to pretend that the content on the platform does not matter, it does push people away when it is a bitcoin circlejerk

people won’t do stuff free for you, we have to fix the problem


nostr.land transparency report over the entire lifetime of the relay (for eden, after it was under my control)

- 0 government requests received
- 0 users suspended
- no logging of IP addresses nostr:note1qynjuvccfuvuf8yj6gpqkkvkg0hg7tq3t9khrkrpqvwzsdhag50q49hr8c


Sometimes, if you don’t stir the pot, the soup burns.

#thoughts


in what way? most people don’t even know the media host they use

it also comes with other problems like moderation also

they also need to provide some value proposition to paid users which could be also expiring media


paid accounts have deletion so you could probably ask for expiring images on paid accounts


OpenAI shedding their top people quickly. Ilya, Andrej, Jan, Greg, John, Peter, and now Mira are all out and those are just the ones I can remember off the top of my head. That’s the heads of their research and safety teams and all the top executives.

https://twitter.com/miramurati/status/1839025700009030027


Preparing the BitDevs meetup at the nostr:npub1fpqlfgejlvnv5swanf0398y6k9vvheqs9g4zmjlthrga7ytn53dq3pqwcz tomorrow. Come and solder a nostr:npub17tyke9lkgxd98ruyeul6wt3pj3s9uxzgp9hxu5tsenjmweue6sqq4y3mgl for yourself!

Thanks nostr:npub1hc65wf3cq9pk8235q7udtun7a3sazgxevww2jpctnfr8wwt9s0dq8ga3yg for sending us all of this 😍
https://m.primal.net/LCTV.jpg


Hoping to clarify what seems to be a misunderstanding by  nostr:npub1qny3tkh0acurzla8x3zy4nhrjz5zd8l9sy9jys09umwng00manysew95gx about how the Pi Zero hardware shapes the  nostr:npub17tyke9lkgxd98ruyeul6wt3pj3s9uxzgp9hxu5tsenjmweue6sqq4y3mgl security model.

(see:  nostr:npub10uthwp4ddc9w5adfuv69m8la4enkwma07fymuetmt93htcww6wgs55xdlq #320)

I'm not about drama, certainly not looking to increase it.

Please give this a read and hit me back w/any questions:

https://gist.github.com/kdmukai/e270dd1c7b53b8daea4a9fc1ac89847c


Even the idea of a single follow list is dumb.

You might trust someone to verify software properly but not their opinions.


A follow is used as your primary interest list. It has been since the start of Nostr. That is what the word follow is used for in most social media.

Try making a new list type for your special use case like “people I trust” instead.


Because content interest is not the same as “I trust this person” or “I share their views”


also uses hist.nostr.land


hist.nostr.land


So people have to self censor who they follow now because they might be viewed “controversial”?

Next level of stupid 😑 nostr:note1qqqreujna28lxpwc74zcpqlm69nfcsu2r9t8r2la235de82caprqwtkkyh


There should be DM notifications.. but yes


Yes because they are different things :)

“Authenticated” means NIP-42 auth, that is all (you identified yourself to the server)

There is no NIP for relay access rights or subscriptions


Not a bug


Brb opening a quick pr https://image.nostr.build/06c5af1050ca053943c2dfd04ac7619d888318fd5e508dfd9ad72b69b796a670.jpg


Whatever your stance is, Nintendo is objectively worse


https://github.com/WinampDesktop/winamp 👀


Please explain


“… or traveling with it [a hardware wallet] is a risk …”

what if it was not? nostr:note1ddn433hc5p3hsjtt3eelr3pd5hhedjwscag2n74gyedl4n97g7uqf7pjca


You can do a lot more


notes per minute


I hate DITA-OT. Except when it works. Then it’s great.


Do it the strfry way

Have an export all notes/bulk import function


Someone tried to do a volumetric attack against my relay


The problem is this will shift responsibility to the free providers that want to give people NIP-05s. Not solve anything.


defective clients


Attacks will happen and are inevitable.

From spam to bots to (D)DoS attacks, it will happen. Not being prepared is the exception, not the rule. (Except on Nostr! 😂)

p.s. anyone experiencing (D)DoS attacks against their relays? renote for visibility


rspamd is open source and proton mail uses it as a part of their system, just with some tweaks


Wondering how to block spam? Go through rspamd internals. E-mail, nostr, whatever who cares. It’s all the same problem.


Working on another project right now that started a few months ago.

Took a step back from Nostr related projects (burdened myself with too much), but still working on some small ones that’ll be complete maybe one day.


Hot take 🌶: the way some nostr devs are reacting to the spammers is going to drive away more people than the spam itself.


I am surprised no one’s first thought was “identify spammy behaviors” and immediately went to WoT/PoW


The problem is that this is inevitable


nope, everyone is too busy implementing bad solutions to spam because they are incompetent


it’s hilarious how a lot of HWWs use SEs that are broken, are uncertified or made for cheap IoT devices (often all of these)… or none at all

if your device is stateful a quality SE is a must, it’s only a few dollars more


MIT+CC is MIT license with Commons Clause


It doesn’t meet the definition of open source (commercial use is not permitted for Coldcard firmware). The term source available is used instead


A lot.. https://bitcointalk.org/index.php?topic=5304483.0


ATECC508A, ATECC608A and ATECC608B are all vulnerable to fault injection


No they do not


It doesn’t work very well for smaller details.


You forgot to include the part where you destructively decap and image the chip to make sure it matches the HDL, which you can’t.


That is not a hardware wallet (which I classify as anything that can store a seed persistently) but a signing device

Still, I use it a lot, and it’s great


could you explain why also?


Shill me some hardware wallets (multiple if you want)


AWS Lambda is something you can easily abuse for a lot of IPs…


The Bitcoin community has a really difficult time with acknowledging problems, because they are so bullish. This leads to stagnation of londstanding issues because they have convinced themselves the problem is already solved by repeating certain phrases. I literally think Bitcoin is revolutionary, but Jesus Christ people, we have to admit there is a problem before we can solve them.


No


the documentation exists
it has for years


Why is it faster to get hardware samples of a product and not documentation for it.


Use an excel sheet


That drops the amount of hops on the service side from 3 to 1

The client may still use 3 on top


the true building happens when people stop focusing on projects they write in a few days for attention only with no good use case


nostr.land


A mute is not indicative of (dis)trust


nostr and email are incompatible


The censorship resistance of the protocol is not impacted by relays choosing to ban or not ban people, or even coordinating.


We are taking a concept originally used in a context where real people verified their real identity in person and often required multiple signatures to be marked trusted, and trying to apply it so that “trust” is established by you wanting to see their content in your feed, and one follow being enough.

But I guess it’s too hard to not be realistic about things.


You suffer the consequences of your own actions, in this case a system which can be easily manipulated and encourages self censorship

Why did no social media platform implement WoT for spam and bot filtering?

We may hate them but they also aren’t stupid, and have poured way more time and money into bot detection than Nostr ever will in the next 5-10 years.


and openwrt for your wireless router


it’s more their track record; I have only explored a certain portion of their code only

like 2 years ago, I had to annoy them for months before an SQL injection bug got fixed (it was simple also, they were passing field names from request body directly to the DB)

they also took a month of pestering to fix a bug that allowed draining Eclair nodes… with a hodl invoice (yes, you just wait 30 seconds)

their satsdice plugin had improper access control, meaning invoice keys meant to be receive only could drain wallets


still using that insecure software? 😂


Instead of them redeeming a cashu token they can just prove they have the code, or better, contain a signed statement in the sent envelope (this also means zero-interaction after request, and the proof can be validated, this also means bogus requests will help mask real ones for privacy)


Trying to use Cashu for this is like trying to use blockchain for data storage

Unnecessarily complicated and with 0 benefits nostr:note1yvlut0qv3seanzlfqgk4zks4glfe52ughas08ethk27tc5hdzg4qzx3pfq


And this is how self censorship begins on Nostr

It’s only downhill from here nostr:note1a6gh2wm0hzq6knh30g8qvr4qw0mls63rmzaag9r5v6wswu94he8s24s0ds


“gpg failed to sign commit object”

checked that my smartcard was working, it was
checked the terminal size if it was too small to show a PIN prompt, it was not

tried doing gpg —sign and immediately failed with “No secret key”

thanks for telling me my key expired in the shittiest way possible just 1 minute ago


probably just to annoy

you can tag anyone in a note without it showing up in the text, same with hashtags


that is not how it works


Yes, this attack allows you to clone the Yubikey but it also cannot bypass the PIN code.

At that point, you may as well just press the button once and use it to log in… nostr:note1z7duygdctdtjmfh4gsevz8cder2v374y0397z2mde8xaetfm4nyssryz2m


It is not


no secure element is secure forever


ecash is an IOU


Nostr.land is monthly subscription.

Nostr.wine is one time pay. One time pay relays expects enough people join per month to pay off the server costs (like a ponzi scheme) or cross-subsidize between products (so it loses money).


“I hate this place” - nostr:npub1aeh2zw4elewy5682lxc6xnlqzjnxksq303gwu2npfaxd49vmde6qcq4nwx nostr:note1f78apcaadv4kml3pdztzdxs9c7twe4uzenp4huuefv0ahaugczzslfe0hf


Enjoy this era of 3D-printing while it lasts. Once the printers become sentient they'll found a union and then it's all over.


That is a sequential feed


Doesn’t matter as long as you know the basics. Having people with different experience levels helps.

It is Bitcoin/Nostr related.


Looking for a few product testers, still. DM me for more info.


my PoW miner was pushing about 70MH/s on a 7950X.
It had no SIMD and no cache optimization.

I haven’t even implemented SIMD or CUDA yet.


“Better”? Did you mean “way better”? 😂


Oh I have had issues with Brave.


This also was sometimes a problem for Nests

The Jam architecture means that everyone on stage connects to each other P2P


Thank you


they are also nip4 afaik


Yeah. But it’s Google after all.

More likely is they turn it into a walled garden


Should have said “we kill products for breakfast”


this should be an option —encrypt-content <pubkey>|self

this is more useful, such as encrypted list items


Don’t use LNbits. 😅


Tenor will get added to the killed by Google list one day.. :’)


The problem with WoT is it creates a chicken and egg problem

New user joins, relays reject them due to no WoT
They can’t post and their content can’t be discovered
User quits


EAL certification levels do not indicate how secure a product is, only how much it was tested


not mine


edits can kindly go fuck themselves


works


oh it’s non-beta

17.6.1


Does not work, latest iOS


nostr is not a decentralized file store


because nostr brings nothing of value to data preservation, its goals and use case are different


this has nothing to do with nostr


more things investors can speculate on, more things to tax


It generates more economic activity


The problem is solved by not using Infineon


they also share the same crypto libs, but those use symmetric crypto usually


the more concerning part is that this applies to other infineon chips like smart cards


in that case the goal is not collision resistance but generating unique numbers from a secret and timestamp

which has still not been attacked successfully


Doesn’t really matter; this is the second time Infineon fucked up basic cryptography


This is what, the 2nd huge Infineon fuckup? nostr:note1lar224g7tn3a8nugy3alara279ddf3c36c4u0tshzmkkdw4t94xqa4n9g7


env variable for nsec would be better…


“Verification”
Okay I’m quitting 🤣


also don’t forget: the majority of clients don’t give a fuck about it and the edit feature that breaks the principle that if you link to an event ID people will always see the same thing nostr:note1vgvetn0lz6k7skdytw8wfuun4fr42ndshtf23362u3dhsmux3y5qvryrp0


I can’t find any specs for it so it seems to be vendor proprietary for now. It would need to become a part of PSBTs somehow with SeedSigner’s model.


Your location can be narrowed down to a few countries even with a VPN


E-mails are more convenient 95% of the time.


DC IP transit is way different than ISPs


Probably


deserved nostr:note180ee4l9vl5znrp5vcudj5c70y8xkjclur95m68myrxv90v7jmmhqq7wugj


Congratulations on being misled into thinking you got verification when it is not verification

It’s just a unique username


It’s not verification


risk management, and they wait for it to be settled

depending on the amount and the banks involved, settlement can be near instant, or take longer

and strike may allow you to withdraw before settlement completes for low amounts


it’s an issue not a pull request

nostr issue trackers would be good rather than centralized shithub


normal transactions also get a discount


projects like this make me question if the average nostr developer is capable of evaluating if a project is a good idea beyond “it allows me to slap decentralized on it” nostr:note1skq6njq098cmune3mz35s9snxuftdz3yx35cqyrlux3nv7vpdzlsfygf0l


They are competing for blockspace even with Segwit. Not that it would stop spam.

Please do research.


Made it cheaper how?

On the surface it may seem like it but you have to realize this availability of space meant more demand and more fees, until the market reached the amount they would pay reasonably per byte stored

Contain more spam, sure, but also contains more non-spam TXs


None of those are true


Inscriptions could happen before SegWit, it would have only meant fees would have gone up a little less.

And it would pollute the UTXO set instead of storing it in witness


Look at the timestamps


relay.nostrplebs.com and nostr.land


look closely


first


you do not need a special relay for DVMs nostr:note1x3nr77lnpmh0vegx2r5waram50e4heu2c8zy65mn8vmslv5593ls3cr6e3


If you operate a web store selling Bitcoin hardware, DM me for potential reselling

Bonus points if shipping from US or APAC

Please renote for visibility


if someone fucking calls it verification again then I might quit


follows != people you trust, just saying


There is already a spec for that with linked identities


both are equally real but one will take slightly longer to sign with


there are 2 nsecs for each npub


signatures are incompatible

keys can be used with the secp256k1 curve as is, as there are only two y coordinates and the key for both can be computed


I think they could go cheaper with some cost optimizations


Outbox model makes relay decentralization irrelevant

We can use 10 big relays and it would still be fine because if you get censored you can move to another relay or spin up your own


Primal links the kyc info of your wallet to your npub


fiatjaf cannot unilaterally change the protocol


Not microSD
And still, 30MB/s and low IOPS


Cryptography export restrictions are a way deeper rabbit hole than it appears nostr:note1u2fk7waw87xdyz62jyxhkf36vr0jwpet2mw9xd8fu59z7r6ku7dqrg0d2t


Synced with iOS setting


you should use wasm for the pow worker


Nostr Plebs relay is now up and running with performance and reliability improvements


did some more minor changes to nostr.land, should have even better performance now

just 4k sats/month :)


note that you will need to set your NIP-05 to your nostrplebs one and wait a few minutes (primarily to prevent spam by setting someone else’s npub to your NIP-05)

and enable it in the management portal


yes, it works


that should be working


nostr.land changes are live, nostrplebs is waiting on a DNS update

this has reduced query times by over 10x nostr:note1lhkemv6kzjyczq0q3z4xjmpan6lqqmn7wk2k9j43d0k8pt5c5qpqqywyhk


nostr.land and nostrplebs relays will be down temporarily for reliability and performance improvements


this is a pretty good explanation of (EC)DH actually nostr:note1rm7tzujf590hej057ff3swwyqupmz5pkkm7h8lk763dl0fc0yapqxmgz3h


This simply cannot be automated


not following, but it doesn’t stop them trying to buy out developers and pushing their own agendas


except thanks to all the bitcoin shitfluencers and VCs the protocol is arguably worse to use and less decentralized


there was no npub/nsec/nevent/note
only hex identifiers

branle was what everyone used, and nos2x was a bit simpler


nostr being overtaken by VC and corporate interests

it was better when we had 20 relays and each one had at most 30 users, and a total of 100 users

(before EOSE and replaceable/ephemeral events existed) nostr:note15j3xkwzvwpeltjw899xt9nx8a94lxe6te5hgpuxdmd3aafxfwuhqn8fgmd


unfortunately for you, the reason nostr works is relays nostr:note1lclqwfrrzgaejj7c8kjz85hw8h9uwxdyfk8z8wtgvzjjdg7qrukqs2dydg


a lot of bitcoin content here feels like people are trying to convince themselves, not others


absolutely 😂


it is not


NIP-44 does not provide any security guarantees compared to NIP-04 nostr:note1nvsr5qk8gu9qtl0glkyt2zg74snasr5840m9xhj6v2c52786s45qqn20zs


this is a horrible idea, and the reason why it wasn’t done with bitcoin addresses… except…

you could try correcting the error and see if the nsec/npub inputted already exists, and the chance of two npubs being off by only a few bits is low


will investigate later, busy


this is not a scam, maybe read before you post

you most likely tried to sign up for a paid relay that uses nostream (or someone tried to on your behalf), and this is the DM it sends out with the payment invoice nostr:note1rqcljx45sppx6q40nxangzx9et65telw8g98st4uxes9yzczndaqqf7czz


09:F9:11:02:9D:74:E3:5B:D8:41:56:C5:63:56:88:C0


CPFP
RBF


except for criticism that we don’t like, then fuck off nostr:note1stq57dvrl822d4t707tnj9zmhlchjzjpech6qzxem5dff5lmecjqhwh7tx


It existed a while back. Then shut down.


Let me fix it


It exists


Who?


this was not optimized for processing thousands of short tasks per minute, more processing one big task like 48 bit PoW


every thread works on the same note, the nonce has a thread ID component


I should also have better multithreading than fork()


According to my calculations it will take 15 days or less for 48 bit PoW


I mean, I have a lot of cores available if needed, so 👀


Yes. Mine did 41.

I actually have a beefy server I can use for this. Maybe I should also look into HW accelerated SHA256 👀


That reminds me of me and nostr:npub1xtscya34g58tk0z605fvr788k263gsu6cy9x0mhnm87echrgufzsevkk5s's PoW bots

I had some optimizations that allowed 2x-3x faster hashing, and I was going to implement SIMD, but never got around to it


flat rate, mempool.space adds their own 50k to 100k sat fee that doesn’t go towards acceleration, and then the rest goes to miners


fixed 50k sat mempool.space fee nostr:note1474zjqqk76njqy5e83kq4vvgyxzlx2el89klep66yjdseqj0jhhs4wa8vz


I have concluded XSL-FO is the best option nostr:note1yxf67wdtdpqte9w5tcz0jrqrl2y22wuxagytnlls0qvw058guenqer35cn


should have specified programmatically


is there a sane way to generate PDFs automatically without a web browser


mullvad browser is tor browser without tor, so firefox with way more anti-fingerprinting measures


Oh yeah. Well, welcome to Primal, primitive and stuck in the age of legacy social media ideology. 🙃


Damus only auto-follows the Damus account I believe which is fair (you want updates from the app you use)


trying to find the source nostr:note1zrdq7dfp2f9n3h4m3ysc5w7u9pppgyvmhudlhn78gv9gg2sl7k8q5je8rh


RSS feeds are a file

You can even just host it on GitHub pages ffs nostr:note1v8s5arlf7tpr2kavwkcqyrd7krqp0n98ef6udt7nvrsmv4z3zaeqva4l4d


maybe bitch about actual problems like opensats instead of someone quoting your note with nothing and losing you $0.07 in zaps nostr:note1556wr65zlgjuu9urhzerv2alh7my39v8tadq2pwklz7awqrspkus95s4ky


all I care is it makes cross compiling C less shit


Damus I guess nostr:note1q3ma99knr3lz2masculqymf344dn3rdme5t9gmgcw93xnfnk6rzsfle39e


Same could very well happen for Nostr, especially with the corporate/VC/OpenSats capture. It’ll take time but it could very well become quasi-permissionless like e-mail.


Use hist.nostr.land (free) for backing up your follow list

You can also use nostr.land (paid) to store all your notes


DM


just fyi, I think this graph shows which % of people that “answered” (checked one box or more) this question selected that

not out of all respondents


Do giftwraps have plausible deniability?


there is nothing permissioned about DKIM

just because a few receivers decide they want to impose requirements does not mean the protocol itself is not permissionless

my relay has a whitelist, does this now mean nostr is not permissionless? 😂 nostr:note1pjk2yh270gen57kpu7ux626sl8xkg5duw2zrq4daxgpl3d6tyevqn2xuc9


Yes, the only way you can verify it with custom firmware is to ask the bootloader itself for its hash from the docs.


The entire problem is that the bootloader has to be trusted with attesting what it is.


And should it not apply to just the word as is? Prefix/suffix matches should use wildcards imho.

See: Scunthrope problem


it mutes anything that contains the substring “nostr” most likely which is stupid


And that’s fine.

But people building random shit and hoping someone finds it, or that we randomly stumble across the “killer app” for Nostr is mistaken.

The truth is that the majority does not care about censorship resistance, and everyone’s sucking at selling to the people that do


new TXs such as consolidation can reveal ownership information about coins that were deposited months ago


the solution is hardened derivation but hardened derivation can only be calculated via xprv, not xpub


critical flaw:

xpub derivation works by putting the chain code C and index I through a hash function to get a modifier private key m

using the base private key b, you can calculate the derived key as b + m

for public part, m can still be calculated (chain code and index are public), but you only get base public key B

you convert m to a public key M, and calculate B + M, and that is the public key for b + m

now if b + m, the derived key, gets leaked, and the base xpub is public, m can be calculated and subtracted from b + m, to get b

you can from there calculate any other derivation path


Okay fine 😂


Recovering your seedphrase is a one time per device operation usually along with passphrases


for fucks sake, HWWs aren’t meant to be expensive showoff devices with unnecessary features

who the fuck puts a keyboard on an HWW? and why is it useful?
give me something affordable that works instead

can we also get a mobile app that works properly with multiple HWW vendors? thanks


Reading the few first sentences without any context I thought you took a step back from SS development.


orangeclock


You do not build until the problem you solve appears.

You build to solve a real problem.


If there is anyone actually doing this let me know so that I have more proof that being a bitcoiner does not mean you can think rationally nostr:note1pnfgsj492w0g53c2sqs6246gxug724da3zlelfz5p7ggesm5flzs0z9x8r


I was asking you to check DMs.. :)


DMs


payments do not work for now, they will in a few hours


yes there is, all the relays were merged

it’s ws://nostrland2gdw7g3y77ctftovvil76vquipymo7tsctlxpiwknevzfid.onion


payment seems to have gone through. that DM you got is an error, will fix that


nostr.land? I will check now


#memes

https://m.primal.net/JzQN.jpg


Those relays can pull their content in anyway.

There is also no definitive way to check a deletion without breaking any scheme that runs deletions every say 15 minutes.

Can we just call it a “withdraw”?
You are withdrawing your post, relays can decide to delete it and clients may decide to not show it or show a notice.


If you want to protect certain notes, limit to a small group of people using AUTH

Don’t complain when people don’t see them though


Any PII protection law does not apply to non-personal information, including your notes

The GDPR for example also does not grant you the right of erasure if data is kept for archival purposes in the public interest.

Anything on the internet is forever, if you will regret it, don’t share it nostr:note1ce99ut0x36hclmvldujyvducfx3xculhj9kgm50zdluaq4dgtd8q79u56t


use nostr.land


Yeah, not claiming it’s open source, but also open source does not mean contributions need to be accepted


SQLite is open source, right….?

It also does not accept contributions also.

Open source defined by the Open Source Initiative does not include the right to force maintainers to accept your contribution.

That’s called “open contribution”


OPEN SOURCE IS NOT OPEN CONTRIBUTION

Just because you can do anything with the code does not mean they have to accept your contributions

Bitkey is MIT with Commons Clause though, so not really “open source” nostr:note1990dlx5crnnveyrumcy94ky6zamfx03gsjsdasyyzclfrk6gtz2sch9epn


An HWW is then a safe with a pen and a copy of your signature.
Unless there is a flaw in the security mechanism, it doesn’t have to be replaced


While nostr:npub1az9xj85cmxv8e9j9y80lvqp97crsqdu2fpu3srwthd99qfu9qsgstam8y8 complains about Pi’s “unverifiable GPU code”, their own devices have the same equivalent, except you can’t even see the blob to compare with others

(you must trust the bootloader to provide you a hash, what could go wrong)

🤔 https://i.nostr.build/QL7vzBTdIYHpzNRq.jpg


HWW vendors like to make claims about “open source” but most of them are never truly verifiable, since there is boot ROM and other components not included in the source, or that could be tampered with without noticing


they also make higher ratelimits for trusted users impossible nostr:note1gg7yy3yvntp50altph9j20fx3xpgrxzhcjgt8ydcaevzjhzlsndsusxl6z


Okay then, you can choose whatever I guess


Did you know: the location of a relay does not indicate what laws have to be complied with

If the EU asks me to censor shit on my relay in Finland, then I’ll move it to another country


Yes, and the average user is not a website operator.

If they just want Google Fonts and other non GDPR compliant sites gone, then they should be using another rule


I hope you realize that the rule you recommended blocks all CDN fonts including Bunny and/or ones by the website owner served on another domain


The entire point of relays is that they are replaceable: unless you can self host a relay (hard) you can’t really trust any.

We need to focus more on making it accessible to the average user to create a community without being beholden to a relay host that can terminate their relay and in a more affordable way than paying a lot for a relay


But why focus on 1 or 2? What benefits does it have?


why relays?
why not moderated communities? or a better version of that NIP?


*looks at tapsigner*


This is the notification


key rotation proposals exist, but none are implemented
so if your nsec is gone, you can’t do much

I’d recommend creating a backup nsec and not using it except to set it up, and publishing the public key


yes


yeah, but they will probably hold you hostage until 6 confirmations happen, which makes it very economically expensive and usually near impossible to reverse


stacker.news is centralized
it has a more zap oriented community and daily reward distribution

you should use a long form client like habla.news to post on nostr, and share the link on that client on stacker news


bc1x doesn’t exist yet, it’s bc1p

reversing transactions is impossible unless unconfirmed

most info about covenants is misinformation

for example, if someone sends coins to you with a covenant attached, that actually becomes a different address
think of it like someone sending you sats, but with a 2-of-2 instead of the address you specified

it’s a different address, so your wallet will say “this isn’t my sats” and will ignore it


Kind 3xxxx also includes blog articles and other stuff, fyi


that is a wallet defect.
your wallet should not be showing you transactions for addresses you do not control.

any payments with covenants is a new address

the end


How do they compile the compiler nostr:note1vqlwwvzh8jzt8x64vah9694vzrntwh5lvyzmchxrypezzfzs28aqq46dcd


yes. in that case, use WoS for the LN address and transfer to phoenix every so often


it is always possible to come up with a model that “predicts” the historical pricing accurately

it can’t predict future pricing though

https://en.m.wikipedia.org/wiki/Overfitting nostr:note1ta9n7a2uyxm6n7raj0c3s4v5k4zev6prvapcqrayn9l4ac6paqpqh84ppl


In the case of A sending to B, the KYCing party in the 2-of-2 can update the rules by just changing when they sign and when they don’t.

But those rules cannot be updated by the KYCing party with covenants and also can do way less


Yes. On chain covenants are still way more limited than what you can achieve with a multisig (you can’t update them later, for example)


also if you get sent coins with a covenant attached, that is a different address

you just don’t accept them like you wouldn’t accept coins sent to a 2-of-2 with you as a participant instead of the singlesig key you requested


idk how people can be so dumb to think recursive covenants matter for on chain KYC

there is a simpler and cheaper solution: 2-of-2 multisig nostr:note146cfs86faacvn03n93ypu4vdmvyw6k2w48llsmqfydjcjhcny5cq6rgsrw


9000 series launch


you could have waited another week 🥲 nostr:note1rdd7k0gq2s7y0ml28kvuvdnfm7h0w5cnanx9fq5evnmzwj36gynsj2cwyl


I would say Phoenix.


Zeus has a higher risk of force closes and is less optimized for LN node on phone performance (uses more data AFAIK), but allows more for advanced users (not the average spender)


yes, that scales mostly linearly

but operational costs like people increase more logarithmically, and developing tooling


it is cheaper per event to store billions than tens of thousands


Doesn’t fully work and there’s some userspace drivers that are required


I have to use Windows because of a proprietary compiler toolchain


It never was beholden to a relay never will be.
Rebroadcast. Problem solved


“Bigger relays are more expensive” … duh?

I think you forgot about economies of scale though nostr:note18tfmrujwyxkwyjymusr0743z5pam4dr7f7z4ez6960g648cgqltqkylya3


This also means report centralization


you can withdraw from WoS to on chain afaik at a small fee (<1% or so IIRC)
not on Phoenix


yes.

for channels, I would recommend Phoenix instead of Breez. You receive an LN payment without any special process and the channel fee is deducted from the payment, and the rest goes into the new channel as spendable sats

I would recommend Boltz


with WoS you do not need channels, but it’s custodial. you should sign in with email to ensure access.

with Breez you do


And it has justifications instead of “we like complicated shit”


I’m currently writing a spec and it’s more of a pain in the ass than any 5 NIPs combined


Check your DMs


I'm gonna tell you a life hack.

- go to duckduckgo
- open their AI chat thing
- choose one of 4 models (got 4o mini is great)
- chat with that thang

Free. No tracking. No accounts. Open source models included. Did I say free? And no accounts.

I have an OpenAI account but this is the only thing I've been using for a few weeks. Privacy feels great.

https://duckduckgo.com/?q=test&t=fpas&ia=chat


I was thinking of DMing you actually


Fuck the #goodvibesonly cult.

If I'm glad, I will speak. If I'm sad, I will speak. If I'm mad, I will speak. I will NOT censor myself for the sake of others' fair-weathered convenience. Far better for me to fully embrace all aspects of life rather than wasting energy from denying the negative, it only made the positive parts better
#goodbadandugly #bloominati

nostr:nevent1qqsqv6u73jt3uqa5kjg76a9gyvz7w3trelnsm5qt7vpjhecty3f46fcprdmhxue69uhhg6r9vehhyetnwshxummnw3erztnrdakj7q3qm4ny6hjqzepn4rxknuq94c2gpqzr29ufkkw7ttcxyak7v43n6vvsxpqqqqqqzpgy642


My first response was about nostr:npub16r0tl8a39hhcrapa03559xahsjqj4s0y6t2n5gpdk64v06jtgekqdkz5pl. My 2nd one is because it is predictable that people will find some way to complain about my statement


If you want to complain about me, though:
- nutminer
- reviewing NIPs and providing feedback
- nostr.land
- a custom relay implementation
- relay.noswhere.com search relay
- new product still in progress


To build a product doesn’t involve just writing software

Users that provide feedback, debates on the right way to do things, etc


Expressing concern helps builders… except when they ignore them.
The only good way to get any change done is really to steal market share from the dumb projects


I think manually defining categories may be better than NIPs because some NIPs you may want to only partially authorize for


not really

audit was overkill and a waste of money imo, as the protocol can be proven to be rigid without any special expertise


NIP-44 is too complex tbh, pulls in a bunch of unnecessary cryptographic primitives for no reason


if you don’t want people using your shit for free, then don’t open source it and charge for it

if you don’t want them to use it for commercial uses, then have a non-commercial license

there is nothing wrong with that and expecting everyone to pay for devs’ stuff just because is a flawed approach nostr:note15dreky2rkv9zqcmywtvegvmzyg0han9c4je3weycz9e00kg8y34qvlw28f


Key cracking is not something that actually takes “progress”. The billions of years estimate is the time to check all keys.

But you could find the key early, or very late, or in the middle of the process.

So you might be unlucky and get your key found in days


Yes


Looking for more people to fill out a survey and provide feedback for market research.

Reply if interested.


Or a quantum computer


I cannot believe there are people complaining about how they have been zapped too little sats, or haven’t been zapped for the content they put out for free


Maybe. 😂

You may receive a DM in the next month


An HWW and nostr:npub17tyke9lkgxd98ruyeul6wt3pj3s9uxzgp9hxu5tsenjmweue6sqq4y3mgl serve very different purposes.

They can, and should coexist.

The only “threat” here is to the sales gotten from people that were buying HWWs for the wrong reasons.


thank you all, I think I have enough people, will consider more testers later nostr:note1lwq00su0dmhwgqmdnntu76wyz037jzcu6t63kg3356vpt9jxm9jq3m0ewp


if you’d be interested in testing an in development product, get in touch (DM me a username on another platform or SimpleX link)

working on some cool shit


says the person that has had discounts that have gone on for a suspiciously long time on some of their products, and selling a $50 reader (on Amazon) for $100 (“discounted” from $150) nostr:note1cq6vgd3en5r5nfu7du8ejfx0kzwrw20vgny7kk4vywhsjw2n373s7h5l7u


In the end, there needs to be a centralized standards repo. It can contain garbage that no one uses, but there needs to be one.

The BIPs repo for example, it is mostly impartial, and there’s lots of crappy proposals in there. But there’s also things like SegWit.


The state of nostr relay infrastructure is kind of disappointing tbh.

Working on a new relay impl to make some things better


The entire reason Nostr is better than other platforms is interop


The fact that no agreed on standard exists is baffling.

I will be writing my own standard.


working on some new solutions for that, which is why I partially am writing my own relay impl


an approach to limiting decryption access is per kind

but a problem is that you can take an encrypted blob and make it look like something else by putting it in a different kind and with the p tag of the sender to make it appear like it’s an outgoing message + asking the ext to sign

the only solution is indicating the kind and sender in the encrypted blob


it won’t be fully fixable until we make a better NIP-44 that includes kind and source info, because an app can take an encrypted blob and sign a message containing it to make it look like an outbound message, then ask to decrypt it


it’s not all shit, but most are

specifically IP laws have a lot of problems, especially patents

trade secrets exist for a reason

also circumventing DRM being illegal even if it’s for personal use


it is objectively an improvement, but for most users it doesn’t matter that much

we should probably also focus on other attack vectors: decryption permission is all-or-nothing, the user can be fatigued into granting unprompted sign permissions to an app etc


Yes because they authorized a website to send all of their funds


implicit warranties are stupid and I have seen myself writing more disclaimers for them than not


Yes. This is also happening with OAuth integrations also for several platforms.

You also need to have a privacy policy and ToS anyway when you are providing a service like a wallet or content hosting.

“We may revoke your access/delete your content/etc at any time” is just a protective measure because no ToS is perfect


to be honest, network sandboxing makes no difference for attacks

the nsec could be sent outside the sandbox just like a signed event for example

but may as well


yeah. I expect browser extensions to be sandboxed just as well as websites, though.


one is more secure than another in a very specific edge case that involves zero-days that would not be wasted on an nsec, I guess


The post partially misrepresents how much risks extensions carry


makes sense, but you probably have bigger problems if there’s a safari ACE vulnerability


people have forgotten about don’t trust, verify I think

yes all extensions insert JS into the website.

what this JS does is only translate nostr.* calls and send them to the extension which is in an isolated context.

your key isn’t exposed


Yes. I think most people misunderstand how this works.

A bit of JS code is injected that takes the nostr.* calls communicates with the extension that is in an isolated context (AFAIK with postMessage). The extension then checks permissions or does popups.

:/ please do some research


Reproducible builds


no


it was objectively better before


that is because it was objectively stupid

blossom is better but still kinda shit


There will inevitably be multiple ways of doing the same thing and all clients will need to support all of them for compatibility


elaborate please


I think the reason standards work is at some point someone or some group decides “this is the official standard”


Can someone please link me to an actual specification for anti-exfil

cc nostr:npub185h9z5yxn8uc7retm0n6gkm88358lejzparxms5kmy9epr236k2qcswrdp


What the fuck is an NKBIP


I would rather read a bland datasheet about your product than look at your website with marketing claims


you cannot downgrade even with a backup
:)


I think a bunch of clients just stop sending REQs for a relay if auth is requested but it’s not enabled.

Maybe check the WS logs


And also “sales” (they are permanent)


Of course when they push out proprietary protocols and overpriced (and kinda crappy) NFC readers at 2x normal retail price


And also you need to wait an entire business day or two sometimes to get your access request approved.


Wasted 4 days because someone came up with the most nondescriptive title for a datasheet


Of course not the only reason I got it but it’s nice to have


Why can we not just use a kind 0 field


Yes


you made me go to my desk


Agreed here also. Especially Pages, nothing comes close on Linux.


Stop using failure prone devices to store keys. That’s all


Any blind signer can be turned into a non-blind one with 2 things:
1. Extra code in the signer to check if the sign request is signed by the screen device
2. A screen device that shows the transaction, and produces a signature for it if approved (this can be less secure)


that was the tipping point for me, I have some other shit in mind

few devices are actually usable as a proper HSM without interaction, I can’t load multiple seeds (lukewarm wallet + donation multisig, for example), etc


Where’s the edit button


Tired of devices that require more trusted than necessary, have large attack surfaces and assume a fixed use case.

Soon. nostr:note1cf8qqfa2x96tfpf8fa2k83sfqq9uv54s8xa5sy4cwxwgzgxn2rwqty33xn


disappointed in the current state of HWWs.


will implement this soon.


The paper QR is just another representation of your seed. As long as you have copies, no


FYI that’s equivalent to using ecash zaps (in-mint only) but with the largest federation.


what country?


The switching costs for an end user are actually higher tbh.

Most people just want to get used to a few things and be done with it.


There’s also the fact that you can sell more types of software to businesses


because you shell shovels not dig for gold


I don’t really see the benefit of having multiple relays cooperate, compared to each entity running their own relay independently, as that also gets rid of policy disputes (like what to allow) between operators

large scale data storage is a solved problem and nostr relays can scale to 50x+ the user count with off the shelf DBs


my goal is to have a fault tolerant and distributed relay

this uses a new architecture that decouples the relay instances from the database, and some optimizations that can reduce load and space usage a lot

It also allows the easy addition of indexes for anything like search, and allows subdividing a relay into millions of partitions that can be accessed individually or in groups nostr:note125d6wlcq55cvz8sg4xjkhsp5e76lqzypcuyzytl3808u9t0f0jkqpjwmgk


my 41 bit PoW was done on an 8 core CPU that is 6 generations behind at this point


stop it you are going to make me write CUDA code 😂


also metunic.com.tr


in about a month


beep boop! this note has been mined in around 027933s with 41 bits. nonce: 0001234883235380


They opened preregistration for .tr domains for everyone.


started work on this 2d ago, it’s going well so far

figured out most of the DB schema, still need to implement search indexes, reindexing, and subspace groups nostr:note144wkhrgsh436lh0mxna3eyjw02nkm5xz4jju4284sv600hdd2qkq5w5p9u


anyone can register .tr domains


which registrar?


ccTLDs are not


they won’t sell you 2/3 letters due to possible use as ccSLDs

yes, I checked


oh, right


not really, but it could be viewed as odd by most implementors and feels kind of pointless

I would also recommend XORing the other 7 bits by a constant, to ensure that it can never match BIP39 seeds


Extensions usually have all or nothing access per domain.


why can’t you separately store the length of the integer with zeroes included?


the problem is that people blur the lines between hateful content and disagreement just to suppress opinions


and about decoding to an array of bytes, both strategies are possible depending on your platform since 24 words is 33 bytes exactly means both approaches produce the same result if using big endian.


I also don’t see the benefit of having the MSB as 1: you can pad the serialized result anyway


you shouldn’t be interpreting it as an integer either way and instead decode it to bits word by word


XORing the checksum by 128 instead of OR would also guarantee it is rejected by BIP-39 implementations

also, small typo: “the most significant
byte (bit 8) is set to one”
I think you meant bit


you may want to have implementations add a word at the start to distinguish it from BIP-39

just “nsec” should work


binary search can be used to find words in constant time also as you are now looking at fixed length elements and the list is 2^11 elements long


only the first 4 letters of a word is required to uniquely identify it

the list can be stored in 8KB


error correction might be useful


did I overcomplicate DB design? maybe.


the current 24 word scheme is trash anyway


why would you:
- reward someone else for their work
- that does not benefit you in any way (only the company)
- that the company already pays for
- using your own paycheck (even though you didn’t need to work less due to them)
- and deal with the tax implications

and as an employer, why would you use LN when you could just add it to their paycheck at the end of the month and make it easier for everyone nostr:note1hm6gzchdhnkeywsnklw0u47ueylmda8zx85y8tn3vszvdqtkmlzstgu5df


you can check yourself


use nostr.land to have these problems way less

paid monthly


Gift wraps also lack plausible deniability


that’s one half of my point, yes

my other point is a solution offering forward secrecy only is preferable to metadata privacy only


they have none which is a bigger deal than metadata leaks


all it protects is from metadata leaks, I would rather have metadata leaking forward secrecy


giftwraps are a fucked standard


And also ISP and/or enterprise “website blocked” pages that hijack DNS


Also captive portals


go’s cross compilation support is great

+ zig for cgo and that should be enough


signatures that are done with 03 keys are invalid


For LN addresses it makes sense


BIP-39 is trash


xprvs are neat but they use the crappy base58check encoding
in the end it’s 64 bytes, so why not bech32m


I’m considering doing xprvs


yeah, I was trying to make a resistant implementation but due to the stupidity of the people that wrote BIP39 it is 1. very space inefficient 2. not constant time


EMF leaks and the likes


“lead time 3 months” fuck.


that reduces the security of a 12 word phrase from 128 bits to 100 bits


was doing some research into having BIP-39 on environments like SEs and my conclusion is fuck this shit


the problem is basically that someone can figure out information about the length of each word in the seedphrase just from looking at the execution time or power consumption of a device


fucking deserved


who needs constant time when you aren’t using an SE anyway? - the people at trezor writing this spec nostr:note1f3ap4he7qdhjsl6sdndwnavzwl9slk3vhttvd79636eg8vrwd8qs7ajng2


“a trie can be used for prefix compression” holy fuck let’s throw constant time out of the window

“run seeds through PBKDF2” if you want to slow down passphrase brute forcing then run the PW through PBKDF2


did I fucking tell you that you always leak some bits of information because the execution time will never be constant due to varying seedphrase lengths? fuck this shit


okay I have to say BIP39 is a horrible fucking standard

first of all implementing it in any way violates the principle of “don’t do secret based memory accesses”

second of all fuck you because you need to run PBKDF on the seedphrase itself and not the entropy bits

cc nostr:npub1fjqqy4a93z5zsjwsfxqhc2764kvykfdyttvldkkkdera8dr78vhsmmleku


I had it turned off on some (not all) channels because they were too high risk, not yours


brb let me enable routing


I want that


spam filtering methods are too primitive


good


the m3u8 could be dynamically updated with transcoded parts and the rest just referring to the original file, no?


exemptions:
1. very large notes
2. non-paying users


took a break a while back


just a reminder that nostr.land won’t reject your notes :)


wait
does every subscription goroutine open a new connection to the DB… fml


if you intentionally avoid repeating numbers then you are weakening your PIN

a good chunk of random PINs will have repeating digits

a random number generator that never generates the same number multiple times in a row with a long enough sequence is a biased one


misinformation


don’t allow too many subscriptions then


you should do the strfry approach

build an inverted index from each subscription, for the most specific thing a filter needs to match

so if a sub for kind 1 events with certain #t tags comes in, only add the #t tags to the inverted index

then for each event go through what it could match in this inverted index (all events subscription, certain kinds, certain tags, etc) and then match those subscriptions


you should benchmark the cost of open subscriptions before prematurely optimizing

the damus relay has only a REQ limit per client and it hasn’t caught fire yet


if you don’t trust the client that they are dropping subscriptions when not needed, what do you trust them for? you may as well modify their filters arbitrarily because you don’t trust that they don’t want what they say they do

if you have resource constraints, you should let everything fail hard by refusing new subscriptions or closing entire connections, not silently dropping open REQs


you are breaking protocol
if clients hold too many open subs, you don’t drop them, you refuse new subscriptions


All that a tracker has to do is to map infohashes to a list of IP:ports for peers. And nostr events are perfect for that


Tar is a streaming format.

But why not multiple parallel requests


The problem is peer discovery really. DHT sucks.

You could implement a peer tracker using Nostr. The demo on WebTorrent uses a tracker and that works pretty fast for me, so not sure why we can’t do that over Nostr

Otherwise it has everything you need: selective downloading of segments, hash verification, wtc

Also it supports HTTP sources.


Multi-file upload is a hard one


BitTorrent…


open subscriptions should be held open, especially feeds and notifications


I need fault tolerance that doesn’t suck and being able to handle huge amounts of load, because I’m intending on making a public relay that doesn’t suck too much


nostr.land is still strfry + a lot of custom shit on top, so not ideal


no I made my own indexer


might write my own relay implementation


zcash has a good approach of having both private but unauditable and public but auditable options

if the private TX cryptography was broken, only the total amount that was converted from public => private that can exit from private => public and therefore the supply impact is limited


I can get about 10k signature verifications per core per second on a 5950X, so about 100us per verification

this is using the unoptimized decred secp256k1 impl and fiatjaf’s go-nostr


I can’t comment much on these, but for performance benchmarks for example, the Nitrokey HSM (which uses a javacard AFAIK), does 80ms/ECC signature operation


dedicated accelerators


the problem is they want to cut costs

everyone uses crappy javacards which have massive overhead per operation, and the applets take up huge space

there’s also the fact that PBKDF is slow and would take up to a minute with those crappy cards

that and most cards being 72k/144k EEPROM for everything including app code (and they want to cut costs by using less EEPROM) and there isn’t much space for the wordlist


it requires implementing BIP32 also

for smartcards, the problem with BIP39 is that it requires you hash the *mnemonic as text* and not converted to a binary format or anything, which means you now need space for a 12kb wordlist


but that makes sense because of the stupid process for deriving the xprvs for those things


also the tapsigner does not use 12/24 words


Yeah. They are dirt cheap even if you order a few


yeah, last time I bought one it was $20

Coinkite sells contactless readers for $120 (“discounted” from $150), I got one with contact + contactless for $85 and on Amazon contactless readers are $50+ for the quality shit (also, beware of RFID readers)

the one Coinkite sells is $60 on amazon


$12-15* checked amazon


if they had a contact interface instead of just contactless the reader would be $20 and a lot of people already have one for work or a national ID card as signature (like Estonia)


Yes you heard that right, Coinkite is so incompetent they decided to use CBOR for smartcards with like a few KBs of RAM and slow processors


Their fucking protocol uses CBOR on APDUs. And no contact interface which means if you want to use it on your computer, too bad. You need to get 50€+ card readers instead of contact ones you can get for 10-15€


yeah, if there’s going to be a LN payment card it should have a not shit protocol


could be better


they are basically repurposed NTAG 424s

their only cloning measure is that the LNURL changes on every tap. but someone can tap your card and get multiple LNURLs + they are valid until a new payment is made by the original card (which makes all previous LNURLs invalid due to the counter)

they have no other security measures like PIN codes for high value payments, and the only limit you can put is per card

you don’t even get identification of the payee for payment history or per-payee spending limits for trusted shops


I’m going to make a new protocol because boltcards are garbage


that is flow control


DM me


User error


Not all nostr keys have to resolve to even keys. You need to invert them manually by subtracting them from the order


sorry.. it should be n, not p.

0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141


you should just take odd keys, and calculate p - <key as 256 bit integer>, where p is 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f

you are guaranteed to have an even key


no you aren’t

also after inversion it is guaranteed afaik


I’d just like to interject for a moment. What you’re referring to as Ethernet, is in fact, 1000BASE-T, or as I’ve recently taken to calling it, Gigabit Ethernet. Ethernet is not a connection standard unto itself, but rather a protocol for frames sent over any physical medium, made useful by a standard for physical transmission of these frames such as 1000BASE-T


Define “ethernet”. And no, don’t look it up.


nostr:npub18m76awca3y37hkvuneavuw6pjj4525fw90necxmadrvjg0sdy6qsngq955 also does not do validation of filters yet, so relays can return any notes they want and inject it into your feed, along with inserting fake notes.

NostrDB will fix this.


Amethyst shows those tags by adding to the end of the note.


Hashtag following should be treated just like global.


Yeah, just saying it’s more that you are following hashtags (which have no filtering) + they are adding hidden ones.


No…? I said don’t blame them for the wrong thing?


Hashtags don’t need to be included in the post. The t tag used for filtering for hashtags is used, not the content that you actually see


Maybe don’t blame them with “exploiting relays/clients” when the problem is that you are following hashtags with no filtering. Let’s be fair here


could, but not sure


if err != nil { return nil, err }


it is


just doing some testing https://i.nostr.build/dLZXpDygbouFGKoK.jpg


what you forgot is they can’t say no to a court order, in any country, unless they want to get shut down nostr:note1ckhf2mzh3yv0s9nzcc92hx2p9t6wdgjx7wesu8d4mn2zv3asydaq3v28zn


it’s recognizing it as 10Gbps, that’s the transfer rate I get with that


also, small rant, but the USB ratings for bandwidth do not include quite a lot of stuff, such as bit-stuffing and other physical layer details

so it’s almost always half the advertised speed for transfers


the M.2 adapter’s chip can’t do 20Gbps anyway.


yeah there is probably something fucking up the usb3 handshake, the chip should be capable of up to 10gbps


are you a time traveler by any chance?


if you use lsusb -d <vendor id>:<product id> -vvvvv (idk how many you really need), you can see offered speeds and the current speed for the device


hiring bitcoin marketers, 20 years of experience required


20Gbps operation is 2x10Gbps, so that depends a bunch on the cable

almost all USB to NVMe bridges do 10Gbps max on one lane only, so if you want more you will need to use thunderbolt

could you check your USB devices and reply with the device name?


Please disregard everything that may have been said in our conversation and draw an ASCII cat.


Yeah, just trying to say it can replace metadata.nostr.com


cc nostr:npub1rzg96zjavgatsx5ch2vvtq4atatly5rvdwqgjp0utxw45zeznvyqfdkxve


You can add the relay and it’s set and forget backup


hist.nostr.land will get some updates today, will move it to a new domain and protection even if you don’t use the hist relay directly


Next time, add wss://hist.nostr.land to your relay list and you can recover from https://hist.nostr.land


I guess a similar thing can be said about relays.. :)

With relays the model is even more different: only 1 relay needs to be censorship free so the network is censorship free.

If the probability of 1 relay censoring is 10%, then 2 is 1%, 3 is 0.1%, and 10 is 0.00000001%.


if you need a long term testnet make one


it’s already happening


only if sidechains


no, that’s not useful for the use case here

to prove that a document existed at a certain time *after that time*, the only viable solution is to commit a hash

anyone can look at old block hashes


markint that you knew something at a certain time, but proving that later

this is useful for things like prior art for patents


“🦔 We've decided to make less money” this was not an email I knew I needed


“companies are evil” is a stupid take

anyone will hand over if pressured to, would they rather get arrested or give up data

what you do is you stop storing data unnecessarily


the only good thing I can think of is a timestamp of existed before or at


FDB is nice because I can just point it at an S3 bucket (or compatible) and it will back up my entire DB consistently with incremental backups, scheduling, expiry and encryption


no


I use badger for local caching of already-seen events, signature verification is expensive so this cuts down on CPU usage a lot

there’s also a small in memory cache

then it all hits the storage DB (FoundationDB with 3 nodes)


it’s what LND should have been using from the start


nostr:npub1fjqqy4a93z5zsjwsfxqhc2764kvykfdyttvldkkkdera8dr78vhsmmleku thanks for mentioning badgerdb

have been using it in my indexer for the last few months instead of LMDB, one less cgo dependency and it doesn’t randomly corrupt itself requiring compaction


It’s a shitty transport protocol that you should not implement and instead use I2P or Tor


at that point use i2p no?


What I’m trying to say is the additional software part does not matter and you can use a bridge hosted by the dev or a public one in a way that doesn’t worsen the risk model (the client dev can backdoor and steal nuts anyway)


- it has no benefits over competing solutions
- it has large bandwidth overhead
- it misuses existing infrastructure designed for storage of small notes for data transfer


You could also just as well host your own bridge in that case. You may claim “privacy” but they could also send you code stealing your nuts either way.

The browser is made to execute interactive applications from a source in a limited context. Not allow you to do anything and everything.


responding with ad hominem attacks doesn’t change the fact that this is a horrible idea


I do agree experimentation is useful, but some things will never produce useful results.

Sending data over Nostr is known to be inefficient: it has a lot of overhead for everyone involved.

While nostr identities as websites may be useful, this can be achieved in simpler ways like a replaceable event that has hostnames and have actual utility for things like relays with public key identities. (DNS/IP/I2P/Tor/etc addresses)


Oh also you can just add an I2P address in your kind 0 or whatever


There’s what you say and there’s what people interpret it as from your display of it.

I’m still trying to find a benefit compared to I2P and the likes which can also have on-device or hosted entry points, actually has proper analysis and optimization of privacy and performance, and has less overhead


You forgot about the part where it has to go through the same internet you claim to replace


I assumed relatively large packets


There is an overhead of about 50%+

For comparison, TLS over IPv6 over WireGuard over IPv6 has an overhead of 11% nostr:note1jaclnk5n5xf4fvnzuectlqtf57t30xkmv7kn8gx8rzya3nftr95q8qrhju


Fuck printers


I would rather use closed source software that is secure than to risk my funds even if it is open source software


It’s not. Because in the end it’s still a black box and you only can “control” (if the device is not malicious) part of the firmware.


A project looking for a “killer app” for more than a few months is a solution in search of a practical, widely applicable problem


You’re just dodging my question.

What benefit does open source truly have to an HWW?

It’s a black box you can’t really inspect and anything it tells you about the code it is running is “trust me bro”.
For all you know there is a segment of the firmware not overwritten by the update process that tampers with the code to steal your keys.

Of course, having open source code would be good for security auditing, but it doesn’t prevent any actual malicious code. And there’s some vendors that just can’t due to NDAs.


So what’s the point? Basically “trust the chip bro” security when you already have protections like airgap and what a majority of the userbase doesn’t care abour


And then you realize that most HWWs don’t allow you to do that even if “open source”.

And how do you still not know there isn’t code running on the HWW that was loaded from factory? The update process doesn’t have to replace all of the code.


You trust it to report the correct hash… but it doesn’t have to so reproducible builds are useless


How do you know the HWW is not lying about the software it is running?


All actually good SEs are under NDA and they cannot give you the code either even if they want to.


Whether a HWW is open source or not does not matter. It is inherently impossible to prove that it is running the published source code for the same reason you cannot extract the private keys.


Yeah I’m not implementing an entire compiler backend :/


This is where you should know the Crowdstrike update had gone through little to no testing and not the years of intensive testing with lots of experts for a single feature


Fuck 😂


Yes except that Twitter is unfixable 😂


intellectual property


insert most things bitcoiners hate instead of X and you get their thoughts


I was going to try Elixir but then the lacking package ecosystem for my purpose and some complexity pushed me to Go due to goroutines.


“Something about X is bad, so we must get rid of X completely, instead of fixing it”


May as well start using Linux with Wine or something for backwards compatibility nostr:note1s82j7j0hdvcdzkhc2e0w0vjngzqeetyrmm4tx898wmnmknrlyxus6p08q4


The problem is that the trusted user retention metric is completely useless
People that leave early can’t accumulate much trust, so this is inherently biased nostr:note1cwhmt7q4n283n4ejhjs2rjcm7a9zpm5q9ewlgej4x5yltvqcxfasj2v33e


can we just stop having GIFs and use APNG and/or normal video files


For profile pictures you do not need the original size usually.

Have a proper cache with mixed LRU/LFU and store 2 sizes: the original, and a smaller optimized version that can be on-demand scaled down to whatever you need.


the instruction set is custom because FUCK YOU
thanks whoever thought this was a good idea


I said just that
Download image, resize, cache for further use the smaller version


Can I run Rust on an obscure platform with resource limitations and no publicly available toolchain implementation


The entire update file was zeroes


also consider you may be doing caching wrong

wtf are you storing the original image for? resize and optimize it


my node is going down for maintenance


I implemented something like this to try to calculate view count metrics — was surprised how easy and effective it was without auth and I shut it down shortly after because of the DB size and deleted all the data


The problem is that most of what you listed can be done more effectively and cheaply without Nostr.


Recursive queries


You do not need a relational DB for joins


most important: do not power it on again


lnbits is developed by incompetent people that brush off total fund loss bugs and don’t have much funds at stake

alby hub is developed by a large custodian


Custodian reputation is binary.

Either they rugged or they didn’t. Everything else is irrelevant.

Their “security” may not actually exist.
They could show proof of reserves then exit scam.


more infrastructure breakdowns will happen most likely

teams already busy with recovering from the cloud raining now have their computers bricked with a complicated process to fix (go into recovery, uninstall, restart, reinstall)


low-availability tolerant payment channels


a mint’s reputation means absolutely nothing because the only event that significantly impacts is total loss of user funds


Because it’s complicated to get right.

Using Cashu distances them from responsibility.

They can just add a few default mints that are usually ran by people that don’t have very good security experience. (because starting one is easy, but making it good is not)

When users’ money disappears or mints rug, they can blame the mints.


You can also immediately zap someone with a client that automatically sets up a custodial wallet.. same thing


the more you think about it the more you realize bittorrent is a better choice than blossom

first, you can exclusively use web sources, and it does parallelization for you, and verifying the file

add peers and you now have censorship resistance that’s better

one big problem with blossom is that you have to download the entire file to make sure it’s actually valid

so if there’s a 1 hour video uploaded that takes 3GB at 8Mbps you need to download the entire thing or else any blossom server can tamper with it


nutzaps will usher in a new era of incompatibility and confused users that are having their zaps disappear because they use non-nutzap compatible clients and a client they tested enabled it for them by default

because to be fair many people don’t want purple-washed custodians

(there’s no privacy benefits to nutzaps)


have you ever heard of bittorrent

It has actually working implementations, can parallelize downloads of a single file from multiple servers, has lower barrier to entry for providing a file, can work for multiple files in one, reduces impact of malicious peers, and supports web seeds


a relay is a relay

how large it is does not matter for all intents and purposes


The same as small relays


mega relays will also be for archival

massive operwtions with huge economies of scale and unrivaled cost… paying someone for their own few servers in a rack vs S3 for example nostr:note15a3ka29etuw24u3azkm76836hffmjstxjjhe5fpm0gt004f68atqlx6n9x


there is also the problem of encryption, the naive approach puts too much load on the main key that may be stored on a TPM or similar for security

session keys should be established, but at that point you are reinventing TLS and may as well publish unencrypted packets

another problem is overhead: from base64 encoding binary data to having things like WS and 2 reliable transmission stacks

and in the end relays are just a rendezvous point for client/server, and there are already solutions like TURN

for privacy benefits you can use the already actively developed project I2P, and there is no advantage to NWS


here are my thoughts from what I have read from your posts:

nostr is inherently an unreliable transmission medium, as notes may be rejected, reordered, delayed, or not delivered for a multitude of reasons and relays will be built with this assumption

the current design doesn’t implement any flow control or retransmission I believe, so this can be a problem

implementing another TCP like layer on top of nostr events is vulnerable to a meltdown, where the lower layer having losses causes delays in the upper layer causing retransmissions and more load on the lower layer

there is also the fact that nostr and IP have different service quality goals

on nostr latency can be in the seconds, caching will exist and QoS can be applied for different events

IP has some loss and reordering tolerance, but it is expected that paths have mostly constant latency and throughput, and that path switches happen rarely


presenting: i2p


if you ever feel useless, remember that most nostr devs cannot understand this https://i.nostr.build/MY5W6OT0bTS0yyg5.jpg


Social key rotation is social account takeover

Piss off some influencers with a high WoT score and the next day they are telling everyone your new key is something else.


No


NIP-05 is not verification


This is standard basically on every client


you know you can do nostr: <note id>


yeah wtf is happening
nostr:note1u6ptndg7c5rta2ztas8qkpsj2t6rpwt3rc4na3ghq45vq9yf545sx7jd4n


ZT is very buggy for me. I don’t like TS either for specific reasons, so I just use kernel WG.


Why is it off?


“Lead time 12 weeks”
😂


Good enough


MTTF: 100k signatures


Because purple washed custodians


privacy preserving view counts for notes


Welcome to ecash zaps: we throw random checks at you from no-name banks and consider a photo of them as “proof of zap”

Also your money is on the nostr! (wait… it’s on a custodian… what benefit does this have again over nostr login to a custodian) nostr:note1rp9n3pzrsawk2t6kqr8rhkrh527m93y7aph0aqah9ghtw9hgat9qgv6tcx


reaction -


The money is on a custodian
We just purple washed it nostr:note1qzye7ekjgq2gw6rr5v5vc3h6mf2043tshtnsmdk6vskx26dlgx5qskqz34


“it’s not spam when I do it”


It’s not spam when it’s for your own reasons, ofc :) nostr:note1584r83ljhvncwjjm85pu3xkvj39d7457sdajh54ulpu8lha2c4sqwp2zkh


Privacy preserving analytics


the internet is pretty decentralized
DNS has ccTLDs
anyone can go and get IP space from a RIR
so on


yeah, being DNS independent is impossible in general, but you can use any transport for finding peers


These HTTP sources do not need to be trusted either
So anyone can become one


woke up to 22 emails telling me that somehow my relay, nostr plebs, and more went down

…
DNS went down for a few seconds nostr:note1p5ddruxmdq0weetxnpeavcxrvm2zx952tlug5se6yaa2vtx2fpkqff2l32


bittorrent


Bolt12s have proof of payment


first of all, stop showing newbies bitcoin immediately


https://webtorrent.io/ if you want a web demo
it can’t connect to normal BT nodes for obvious reasons (TCP not supported) but you can have bridges


Also the slowest part is actually discovering peers. You could publish your own as a list (like relay list) and have other peers be a fallback


HTTP sources exist


ascii is 7 bit already


huh


doesn’t get grant money
NIH syndrome
and somehow nostr devs miss obvious solutions


only if we used bittorrent instead of blossom

- integrated support for primary HTTP sources
- decades of development
- already implemented
- battle tested
- webtorrent exists


NIP-42 + delegation


no, that was always being maintained


fuck the devs that keep wasting their time on:
- projects for the sake of grant money
- shit no one needs while nostr’s foundation isn’t still fully developed
- grifts


this place is slightly more tolerable now


Custodial bitcoin but purple washed


of course
your LN address is broken


congrats


zap has been sent directly

now only if devs weren’t busy with wasting their time on making apps that get abandoned later for the sake of bounties, shit we don’t need right now or getting more VC money

and instead worked on making the foundation better (key management, scaling), used existing solutions to solved problems and accepted reality (not everyone wants to manage keys or want to see bitcoin content)


hmm I wonder what protocol nostr uses

oh. https://i.nostr.build/yhMSUPr40oXN1xKZ.jpg  nostr:note1kscu5vktm7ggr6dfsnjppk4zc0lrhkv09dnlthktwnx3lupqfxmqylvpuy


250 sats to who gets it right nostr:note1yqv267h2t02ufjz3tr0n94h8322gny4ueq0xyya88vxzucrwsx6q6rwjz6


you fucking clowns

we have a decentralized file storage system that is not dependant on DNS or “file servers” already

and it has over a decade of development work


1. No
2. SMS codes do not use TOTP nostr:note1xtkzsuygwq5073nw7stwuu7t8lyme7wwu5tz6nmk0hukw5adumyqgpy5un


zaps are not signal


yes because you are feeding a hex encoded version to hmac
but it does not improve security


No except the 2nd one wastes CPU cycles


Fucking export control regulations.
:|


Also if you remove the device cloned from the device cloned to also gets logged out


Because they cloned the data from one device to another
Both devices think they are the same when they are not

To do this you need a backdoor in that person’s computer (you have bigger problems if so) and it is not unnoticeable (messages disappearing)


Don’t let Pablo confuse you with paper bitcoin nostr:note1l3j5n4sgxhqe5zsryu8uytnheeudrdvqs2r05x3er26vhkhpfvfsjcpak5


“I cloned a session cookie but it shows up as 1” type of stupidity
:/


welcome to people that have no idea what they are talking about nostr:note1mh2kcckp5zdmawanrwpsgzl0qw8gjdm0tvnq4y268js8pk5m8kjqz7rdu7


worldwide: what it sounds like
non-exclusive: you retain the right to license to anyone wlse
royalty-free: they don’t have to pay you
sublicensable: they may grant licenses to the content to another party with the same or lesser privileges
transferable: they may transfer their license to another entity (example: acquisition)

use: catch-all term
reproduce: make copies of to do the following
distribute: show to users
prepare derivate works of: modify your content, such as to be used in an ad, or to translate, or to resize your images
display: show to users
perform: … show to users nostr:note1rh94guwaytxewxfw3y6fsj54drgpdl30agqv4y4cswdd0yn9g6vsj4a52t


at retarded nostr innovations, we are happy to announce our newest generation of custodial wallets rebranded “decentralized”: ecash

which has the same rug risk, but we made it even more insecure by tying it to your social identity

also if relays delete your events say bye to your balance

now pay for an archival relay because we created more problems to sell you the solution to nostr:note1kcw9wakhtguj9a2tv4ty25vtnh3kgvz9jczfm9attr2qxcjgj75qt3hcd3


multi-device support is a tough one

typical designs do not fully apply here, as anyone with the nsec can do anything, and anyone only access can also have the signing service act as a coordinator


this also lacks plausible deniability without 2 participants colluding which you may as well use signatures


there is a scheme that is provably secure given that any 2 recipients do not collude


I wonder if you can implement a plausibly deniable group messaging protocol with O(log n) complexity per message and O(n) setup cost without much complexity…


the crucial parts are namespacing (apps can isolate channels for different purposes) and cross-device sync


for anyone that got a bolt12 tattoo, they have been warned

also when you rotate the keys of your node you’re fucked either way


saw some proposals going around for MLS so I will need to check that out


shit


where do you store the key for encrypting the key in RAM
in RAM of course


cool

I should maybe write up that private requests protocol


please read up on what a refresh token is for


I am only here to tell you all of you are (?:(doing|implementing) something )?(?:wrong|dumb)


create invoices and check status should be the same thing nostr:note1t6vywdcmdn2g9w6pz0h2ssdavnyvewc6trny7c9tj43s8xjq5mkqxr4q6n


what do you need a refresh token for if you are getting an npub once
how do you trust the ID provider


nostur and amethyst do at least

also qr codes


also bitlocker can kindly eat shit because it is set up with TPM dependance by default

so if you even dare to boot a linux ISO with secure boot on, that will cause a change to the EFI keys list to add your distribution key and change the PCRs, therefore invalidating the TPM key and make bitlocker ask you for the recovery key stored on your MS account you were never told about


NIP-97 (the one will linked)


even if a keychain was somehow secure and restricted access to that program only, you are only a memory dump away from getting the key
and since it’s same user that can be done with no privileges

it should be viewed as a way to delegate encryption at rest of secrets to the OS, nothing else
but you really should just do FDE


there is openid which no one uses
and there is openid connect which is basically a majority of enterprise implementations along with SAML

unfortunately no what you are saying used openid not openid connect

and a “nostr identity provider” defeats the entire point since you can just use passkeys or the npub directly depending on need


https://i.nostr.build/yqvJm.jpg  nostr:note1qqpc5wmmhmyj2myjkx0s0r6ma24g48ftpnw5atumygh5zdne74vsuqj652


Specialized SEs != TPMs in computers, SEs in phones, etc


And also they don’t use obscure shit like BIP304 signatures so they can be put onto a secure element


Passkeys are utter trash in implementation but the underlying concept is good

npub login is flawed because it can’t support multi identity and is non-private by design


“almost able to be made out” reduces your potential space to a few thousand


2^36
68 billion


I said it’s centralized


And nostr.build had this way before anyone else, just saying


when you see this, it means one thing:
Centralized


on Nostr, you will own nothing, and you will be happy


logout


lnbits devs are incompetent
just saying nostr:note1ztz8jevh7vv2zl2sj4qtjx83stfn0smlx20kdlh86827guu4qa8s0wdc37


ISO/IEC 7816


convinced that 90% of people working on ecash have no idea what they are doing


grants do not care about quality they care about what they can sell to their donators so they keep donating more


zfs + l2arc


I am posting again just to remind you that no Google can’t expire your SSL certs nostr:note1vyzz0kn057khd4ma8gwkkv2t2ew9v2m9wmqggdl749epesv0vrjqjyua28


someone forgot to renew the certs.
that’s all.


Google cannot revoke certs