<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[Leo Dahlgren]]></title><description><![CDATA[Leo Dahlgren]]></description><link>https://leodahlgren.hashnode.dev</link><generator>RSS for Node</generator><lastBuildDate>Wed, 18 Nov 2026 14:02:02 GMT</lastBuildDate><atom:link href="https://leodahlgren.hashnode.dev/rss.xml" rel="self" type="application/rss+xml"/><language><![CDATA[en]]></language><ttl>60</ttl><item><title><![CDATA[Kontrollera en bitcoinadress innan du skickar: Bech32, Bech32m och Base58Check på under 100 rader Python]]></title><description><![CDATA[Av Leo Dahlgren Den här texten är skriven med hjälp av ett AI-baserat skrivverktyg. Koden har jag kört själv mot testvektorerna i BIP 173 och BIP 350 den…]]></description><link>https://leodahlgren.hashnode.dev/kontrollera-en-bitcoinadress-innan-du-skickar-bech32-bech32m-och-base58check-p-under-100-rader-python</link><guid isPermaLink="true">https://leodahlgren.hashnode.dev/kontrollera-en-bitcoinadress-innan-du-skickar-bech32-bech32m-och-base58check-p-under-100-rader-python</guid><category><![CDATA[Python]]></category><category><![CDATA[Bitcoin]]></category><category><![CDATA[Cryptography]]></category><category><![CDATA[Security]]></category><category><![CDATA[bech32]]></category><dc:creator><![CDATA[Leo Dahlgren]]></dc:creator><pubDate>Wed, 18 Nov 2026 07:04:21 GMT</pubDate><content:encoded><![CDATA[<p><em>Av Leo Dahlgren</em></p>
<p>Den här texten är skriven med hjälp av ett AI-baserat skrivverktyg. Koden har jag kört själv mot testvektorerna i BIP 173 och BIP 350 den 16 november 2026; utskrifterna nedan är från den körningen.</p>
<p>Nästan alla som flyttar bitcoin gör samma kontroll: tittar på början av adressen. Börjar den med <code>bc1q</code>, <code>bc1p</code>, <code>1</code> eller <code>3</code> ser den rätt ut. Men en adress är mer än ett prefix. Varje bitcoinadress bär en egen kontrollsumma, och den går att räkna ut lokalt, utan internet och utan att lita på en webbtjänst. Här är ett litet skript som gör det, vad det faktiskt fångar – och den viktiga saken det inte kan säga något om.</p>
<h2>Tre format, två sorters kontrollsumma</h2>
<table>
<thead>
<tr>
<th>Början</th>
<th>Kodning</th>
<th>Kontrollsumma</th>
<th>Specifikation</th>
</tr>
</thead>
<tbody><tr>
<td><code>1…</code> och <code>3…</code></td>
<td>Base58</td>
<td>de fyra första byten av dubbel SHA-256</td>
<td>Base58Check</td>
</tr>
<tr>
<td><code>bc1q…</code></td>
<td>Bech32</td>
<td>BCH-kod, konstant <code>1</code></td>
<td>BIP 173</td>
</tr>
<tr>
<td><code>bc1p…</code></td>
<td>Bech32m</td>
<td>samma BCH-kod, konstant <code>0x2bc830a3</code></td>
<td>BIP 350</td>
</tr>
</tbody></table>
<p>Skillnaden mellan de två senare är en enda konstant. BIP 350 förklarar varför den byttes: i Bech32 kan man, när sista tecknet är <code>p</code>, lägga till eller ta bort <code>q</code> precis före det utan att kontrollsumman slår larm. För segwit version 0 spelar det ingen roll eftersom de adresserna bara får ha två bestämda längder, men för taproot (version 1) och senare behövdes en ny konstant.</p>
<h2>Skriptet</h2>
<p>Bara standardbiblioteket. Spara som <code>adresskoll.py</code> och kör <code>python3 adresskoll.py &lt;adress&gt;</code>.</p>
<pre><code class="language-python">#!/usr/bin/env python3
"""adresskoll.py - kontrollera en bitcoinadress lokalt (BIP 173, BIP 350, Base58Check).
Endast standardbiblioteket. Säger om strängen är en välformad mainnet-adress, inte vem som äger den."""
import hashlib

CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
BECH32, BECH32M = 1, 0x2BC830A3
B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

def _polymod(values):
    gen = [0x3B6A57B2, 0x26508E6D, 0x1EA119FA, 0x3D4233DD, 0x2A1462B3]
    chk = 1
    for v in values:
        top = chk &gt;&gt; 25
        chk = (chk &amp; 0x1FFFFFF) &lt;&lt; 5 ^ v
        for i in range(5):
            chk ^= gen[i] if (top &gt;&gt; i) &amp; 1 else 0
    return chk

def _hrp_expand(hrp):
    return [ord(c) &gt;&gt; 5 for c in hrp] + [0] + [ord(c) &amp; 31 for c in hrp]

def _convertbits(data, frombits, tobits):
    acc = bits = 0
    out = []
    for v in data:
        acc = (acc &lt;&lt; frombits) | v
        bits += frombits
        while bits &gt;= tobits:
            bits -= tobits
            out.append((acc &gt;&gt; bits) &amp; ((1 &lt;&lt; tobits) - 1))
    if bits &gt;= frombits or ((acc &lt;&lt; (tobits - bits)) &amp; ((1 &lt;&lt; tobits) - 1)):
        return None  # mer än 4 bitars utfyllnad eller utfyllnad som inte är noll
    return out

def check_segwit(addr, hrp="bc"):
    if addr.lower() != addr and addr.upper() != addr:
        return "fel: blandade versaler och gemener"
    a = addr.lower()
    pos = a.rfind("1")
    if pos &lt; 1 or pos + 7 &gt; len(a) or len(a) &gt; 90:
        return "fel: saknar avskiljare eller fel längd"
    if a[:pos] != hrp:
        return f"fel: prefixet är '{a[:pos]}', inte '{hrp}' (fel nät?)"
    if any(c not in CHARSET for c in a[pos + 1:]):
        return "fel: otillåtet tecken (b, i, o och 1 används inte efter avskiljaren)"
    data = [CHARSET.find(c) for c in a[pos + 1:]]
    const = _polymod(_hrp_expand(hrp) + data)
    if const not in (BECH32, BECH32M):
        return "fel: kontrollsumman stämmer inte (felskrivet tecken?)"
    ver, prog = data[0], _convertbits(data[1:-6], 5, 8)
    if prog is None or not 2 &lt;= len(prog) &lt;= 40 or ver &gt; 16:
        return "fel: ogiltig längd på adressens innehåll"
    if ver == 0 and len(prog) not in (20, 32):
        return "fel: segwit v0 måste vara 20 eller 32 byte"
    if (ver == 0) != (const == BECH32):
        return "fel: version och kontrollsummetyp matchar inte (bech32 vs bech32m)"
    kind = {(0, 20): "P2WPKH (bc1q)", (0, 32): "P2WSH (bc1q)", (1, 32): "taproot (bc1p)"}
    if (ver, len(prog)) in kind:
        return "ok: " + kind[(ver, len(prog))]
    return f"varning: välformad enligt BIP 350 men segwit v{ver} med {len(prog)} byte är ingen adresstyp som plånböcker delar ut i dag - skicka inte"

def check_base58(addr):
    n = 0
    for c in addr:
        if c not in B58:
            return f"fel: otillåtet tecken '{c}' (0, O, I och l finns inte i Base58)"
        n = n * 58 + B58.index(c)
    raw = n.to_bytes((n.bit_length() + 7) // 8, "big")
    raw = b"\x00" * (len(addr) - len(addr.lstrip("1"))) + raw
    if len(raw) != 25:
        return "fel: fel längd"
    body, chk = raw[:-4], raw[-4:]
    if hashlib.sha256(hashlib.sha256(body).digest()).digest()[:4] != chk:
        return "fel: kontrollsumman stämmer inte (felskrivet tecken?)"
    return {0x00: "ok: P2PKH (1…)", 0x05: "ok: P2SH (3…)"}.get(body[0], f"fel: versionsbyte {body[0]} är inte mainnet")

def check(addr):
    addr = addr.strip()
    if addr.lower().startswith("lnbc"):
        return "fel: det här är en Lightning-faktura, inte en on-chain-adress"
    if addr.startswith("0x"):
        return "fel: 0x-adress hör till Ethereum eller en annan EVM-kedja"
    if addr[:1] in ("1", "3"):
        return check_base58(addr)
    return check_segwit(addr)  # bech32-prefix börjar aldrig med en siffra

if __name__ == "__main__":
    import sys
    for a in sys.argv[1:]:
        print(f"{a}\n  -&gt; {check(a)}")
</code></pre>
<p>Tre saker i koden är lätta att missa om man skriver en egen variant:</p>
<ol>
<li><strong>Version och konstant hör ihop.</strong> En <code>bc1q</code>-adress (version 0) måste ha Bech32-kontrollsumma, en <code>bc1p</code> (version 1) Bech32m. Godtar man båda för båda, släpper man igenom adresser som BIP 350 uttryckligen listar som ogiltiga.</li>
<li><strong>Utfyllnaden räknas.</strong> När 5-bitarsgrupperna packas om till byte får det bli högst fyra bitar över, och de måste vara noll.</li>
<li><strong>Blandade versaler är fel.</strong> <code>BC1Q…</code> är giltigt, <code>bc1q…</code> också, men inte en blandning. (Versaler finns för att QR-koder blir mindre.)</li>
</ol>
<h2>Körning mot de officiella testvektorerna</h2>
<p><code>test_adresskoll.py</code> läser testvektorerna direkt ur BIP 350-dokumentet. Jag körde 19 ogiltiga vektorer: de 15 ogiltiga segwit-adresserna och fyra av de ogiltiga Bech32m-strängarna. Alla 19 avvisades. Strängar med ett annat prefix än <code>bc</code> stoppas redan på prefixet; resten fångas av kontrollerna för kontrollsumma, längd och utfyllnad, version och skiftläge. Ett urval:</p>
<pre><code>bc1p0xlxvlhemja6c4dqv2… [Invalid checksum (Bech32 instead of Bech32m)] -&gt; fel: version och kontrollsummetyp matchar inte (bech32 vs bech32m)
BC1QR508D6QEJXTDG4Y5R3… [Invalid program length for witness version 0 (per BIP141)] -&gt; fel: segwit v0 måste vara 20 eller 32 byte
tb1p0xlxvlhemja6c4dqv2… [Mixed case] -&gt; fel: blandade versaler och gemener
bc1gmk9yu… [Empty data section] -&gt; fel: ogiltig längd på adressens innehåll
ogiltiga som felaktigt släpptes igenom: 0
</code></pre>
<p>Bland de <em>giltiga</em> vektorerna finns tre som är formellt korrekta men som ingen plånbok delar ut i dag: segwit version 1 med 40 byte, version 2 och version 16. Dem flaggar skriptet som en varning i stället för ett ok. En adress kan alltså vara välformad enligt specifikationen och ändå inte vara något du ska skicka pengar till. Testnätsadresser (<code>tb1…</code>) avvisas eftersom skriptet kontrollerar huvudnätet <code>bc</code>.</p>
<p>För de äldre formaten konstruerade jag två adresser från samma 20-byteshash som BIP 173 använder i sitt första exempel:</p>
<pre><code>1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH -&gt; ok: P2PKH (1…)
3CNHUhP3uyB9EUtRLsmvFUmvGdjGdkTxJw -&gt; ok: P2SH (3…)
1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMJ -&gt; fel: kontrollsumman stämmer inte (felskrivet tecken?)
1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMl -&gt; fel: otillåtet tecken 'l' (0, O, I och l finns inte i Base58)
</code></pre>
<p>(Adressen som börjar med 3 är bara en formatdemo; ingen känd skriptkod ligger bakom den. Skicka ingenting till någon av exempeladresserna.)</p>
<h2>Hur bra är kontrollsumman på att hitta skrivfel?</h2>
<p>Jag tog BIP 173:s exempeladress <code>bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4</code>, bytte ut 1 till 5 slumpvis valda tecken efter <code>bc1</code> mot andra giltiga tecken, 20 000 gånger per nivå, och lät skriptet bedöma resultatet:</p>
<pre><code>1 felskrivna tecken: 20000 försök, 0 släpptes igenom
2 felskrivna tecken: 20000 försök, 0 släpptes igenom
3 felskrivna tecken: 20000 försök, 0 släpptes igenom
4 felskrivna tecken: 20000 försök, 0 släpptes igenom
5 felskrivna tecken: 20000 försök, 0 släpptes igenom
bytt plats på två intilliggande tecken (alla positioner): 0 släpptes igenom
</code></pre>
<p>Upp till fyra utbytta tecken är ingen tur: BIP 173 beskriver att koden är konstruerad för att garantera att sådana fel upptäcks. Vid fler fel finns ingen garanti, bara en mycket liten sannolikhet att ett fel slinker igenom – att noll av 20 000 gick igenom vid fem fel visar inte att det är omöjligt.</p>
<h2>Det kontrollsumman inte kan säga</h2>
<p>Här är poängen som är lätt att glömma när skriptet säger <code>ok</code>: <strong>kontrollsumman visar att strängen är en korrekt skriven adress, inte att det är rätt adress.</strong> Den skyddar mot felskrivning och mot att en bit av adressen kapats av vid kopiering. Den skyddar inte mot:</p>
<ul>
<li><strong>Urklippsbyte.</strong> Skadeprogram som byter ut en kopierad adress mot angriparens lägger in en <em>giltig</em> adress. Kontrollsumman blir grön.</li>
<li><strong>Fel nätverk på börsen.</strong> En korrekt <code>bc1q</code>-adress säger inget om huruvida börsen skickar via Bitcoin-nätverket eller som en inslagen token på en annan kedja.</li>
<li><strong>Fel mottagare.</strong> En giltig adress från ett chattmeddelande är fortfarande någon annans adress.</li>
</ul>
<p>Därför används skriptet bäst som ett första filter innan du ens klistrar in adressen i börsens uttagsformulär – och sedan jämför du ändå början och slutet mot plånbokens egen skärm och skickar ett litet testbelopp.</p>
<h2>Läs vidare</h2>
<p>Hela rutinen runt själva adresskontrollen – nätverksval, börsens uttagsavgift och minimibelopp, testbelopp och bekräftelser – finns som en checklista på svenska hos <a href="https://kryptoflytt.se/artiklar/checklista-skicka-bitcoin-on-chain-adressformat-avgift-minimum/?utm_source=hashnode&amp;utm_medium=referral&amp;utm_campaign=se-parasite-2026-11-16-01&amp;utm_content=read-more-checklista-bitcoin-on-chain">Kryptoflytt: skicka bitcoin on-chain från en börs till en egen plånbok</a>. Den drivs av mig; länken går till en webbplats utanför Hashnode.</p>
<h2>Källor</h2>
<ul>
<li><a href="https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki">BIP 173: Base32 address format for native v0-16 witness outputs</a> (läst 2026-11-16)</li>
<li><a href="https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki">BIP 350: Bech32m format for v1+ witness addresses</a>, inklusive testvektorerna som används ovan (läst 2026-11-16)</li>
</ul>
<p><em>Koden är fri att använda. Den är ett hjälpmedel för att upptäcka skrivfel, inte en garanti för att en överföring hamnar rätt.</em></p>
]]></content:encoded></item><item><title><![CDATA[Il codice LEI nel registro MiCA dell'ESMA: 17 righe su 407 non passano un controllo automatico]]></title><description><![CDATA[Leo Dahlgren Se state costruendo uno script che incrocia il file dei prestatori di servizi per le cripto-attività (CASP) pubblicato dall'ESMA con il…]]></description><link>https://leodahlgren.hashnode.dev/il-codice-lei-nel-registro-mica-dell-esma-17-righe-su-407-non-passano-un-controllo-automatico</link><guid isPermaLink="true">https://leodahlgren.hashnode.dev/il-codice-lei-nel-registro-mica-dell-esma-17-righe-su-407-non-passano-un-controllo-automatico</guid><category><![CDATA[Python]]></category><category><![CDATA[MICA ]]></category><category><![CDATA[data-quality]]></category><category><![CDATA[fintech]]></category><category><![CDATA[open data]]></category><dc:creator><![CDATA[Leo Dahlgren]]></dc:creator><pubDate>Mon, 16 Nov 2026 06:38:16 GMT</pubDate><content:encoded><![CDATA[<p><em>Leo Dahlgren</em></p>
<p>Se state costruendo uno script che incrocia il file dei prestatori di servizi per le cripto-attività (CASP) pubblicato dall'ESMA con il database GLEIF, prima o poi una ricerca vi restituirà un 404. Non è (sempre) colpa del vostro codice. Ho controllato il file <code>CASPS.csv</code> scaricato il 16 novembre 2026 (intestazione HTTP <code>Last-Modified: 11 Nov 2026 13:55 GMT</code>, 407 righe di dati, SHA-256 <code>e0a73cab…</code>) e il campo <code>ae_lei</code> contiene diverse sorprese.</p>
<p>Il risultato, in breve:</p>
<table>
<thead>
<tr>
<th>Problema nel campo <code>ae_lei</code></th>
<th>Righe</th>
<th>Si risolve con un <code>strip()</code>?</th>
</tr>
</thead>
<tbody><tr>
<td>Spazi, tabulazioni o spazio unificatore (<code>\xa0</code>, non-breaking space) prima o dopo il codice</td>
<td>7</td>
<td>Sì: dopo la pulizia tutti e 7 i codici esistono su GLEIF</td>
</tr>
<tr>
<td>Lunghezza diversa da 20 caratteri (19 o 21)</td>
<td>3</td>
<td>No</td>
</tr>
<tr>
<td>20 caratteri, ma cifre di controllo errate (ISO 17442, modulo 97)</td>
<td>7</td>
<td>No</td>
</tr>
</tbody></table>
<p>In totale 17 righe su 407 richiedono attenzione, e 10 non trovano alcun record GLEIF così come sono scritte. Cinque di queste dieci riguardano soggetti che nel file elencano anche l'Italia (<code>IT</code>) tra i paesi in cui intendono prestare servizi (<code>ac_serviceCode_cou</code>).</p>
<h2>Perché un LEI si può verificare offline</h2>
<p>Il LEI (Legal Entity Identifier, standard ISO 17442) ha una struttura fissa: 20 caratteri alfanumerici, gli ultimi due sono cifre di controllo. La verifica è la stessa dell'IBAN: si convertono le lettere in numeri (A=10 … Z=35), si legge tutta la stringa come un unico intero e il resto della divisione per 97 deve essere 1. La struttura e lo schema delle cifre di controllo (ISO/IEC 7064, MOD 97-10) sono descritti dal Regulatory Oversight Committee del sistema LEI: <a href="https://www.leiroc.org/lei.htm">https://www.leiroc.org/lei.htm</a>.</p>
<p>Questo controllo dice soltanto se il codice è <em>ben formato</em>. Non dice se esiste, se è attivo, né tantomeno se il soggetto è autorizzato ai sensi di MiCA. È però un filtro gratuito che conviene eseguire prima di fare chiamate di rete.</p>
<h2>Lo script</h2>
<pre><code class="language-python">import csv, re, urllib.request, urllib.error

URL = "https://www.esma.europa.eu/sites/default/files/2024-12/CASPS.csv"
LEI_RE = re.compile(r"[A-Z0-9]{18}[0-9]{2}")

def checksum_ok(lei: str) -&gt; bool:
    # A=10 ... Z=35, poi resto modulo 97 == 1 (ISO 17442 / ISO 7064)
    return int("".join(str(int(c, 36)) for c in lei)) % 97 == 1

def gleif_status(lei: str) -&gt; int:
    try:
        urllib.request.urlopen(f"https://api.gleif.org/api/v1/lei-records/{lei}", timeout=20)
        return 200
    except urllib.error.HTTPError as e:
        return e.code

with urllib.request.urlopen(URL, timeout=60) as r:
    rows = list(csv.DictReader(r.read().decode("utf-8-sig").splitlines()))

for row in rows:
    raw = row["ae_lei"]
    lei = raw.strip()            # str.strip() rimuove anche \t e \xa0
    if raw != lei:
        problema = "spazi"
    elif not LEI_RE.fullmatch(lei):
        problema = f"formato (len={len(lei)})"
    elif not checksum_ok(lei):
        problema = "checksum"
    else:
        continue
    if problema != "spazi" and not LEI_RE.fullmatch(lei):
        esito = "non verificabile"
    else:
        esito = gleif_status(lei)
    paesi = row["ac_serviceCode_cou"].split("|")
    print(problema, repr(raw), row["ae_lei_name"].strip(),
          "IT" if "IT" in paesi else "", esito)
</code></pre>
<p>Due dettagli che fanno perdere tempo:</p>
<ol>
<li><strong>Aprite il file con <code>utf-8-sig</code>.</strong> Altrimenti il primo nome di colonna può arrivare con un BOM davanti e <code>row["ae_competentAuthority"]</code> solleva <code>KeyError</code>.</li>
<li><strong>Non ripulite i codici "a occhio".</strong> <code>strip()</code> è sicuro, perché toglie solo i caratteri di spaziatura. Sostituire <code>O</code> con <code>0</code> (o il contrario) per far quadrare il checksum, invece, è un'ipotesi: va confermata su GLEIF cercando la denominazione legale, non indovinata.</li>
</ol>
<h2>Che cosa c'è dentro gli errori</h2>
<p>Per cinque delle righe non valide ho cercato la denominazione legale sull'API GLEIF (<code>filter[entity.legalName]</code>) e il record restituito spiega l'errore:</p>
<table>
<thead>
<tr>
<th>Soggetto (come nel file ESMA)</th>
<th>Valore in <code>ae_lei</code></th>
<th>LEI su GLEIF</th>
<th>Differenza</th>
</tr>
</thead>
<tbody><tr>
<td>OSL EU GmbH</td>
<td><code>8945001TKX2A5OJMNR45</code></td>
<td><code>8945001TKX2A5OJMNR95</code></td>
<td>una cifra (4 → 9)</td>
</tr>
<tr>
<td>Noemon Finance Ltd</td>
<td><code>25490004TC93R20KW073</code></td>
<td><code>25490004TC93R2OKW073</code></td>
<td>zero al posto della lettera O</td>
</tr>
<tr>
<td>Zap (Strike) Europe Limited</td>
<td><code>984500457TABOA3BZ224</code></td>
<td><code>984500457TAB0A3BZ224</code></td>
<td>lettera O al posto dello zero</td>
</tr>
<tr>
<td>PROSEGUR CUSTODIA DE ACTIVOS DIGITALES S.L.U.</td>
<td><code>59800G0P3PV13KLX615</code></td>
<td><code>959800G0P3PV13KLX615</code></td>
<td>manca il primo carattere</td>
</tr>
<tr>
<td>Ramp Swaps (Ireland) Limited</td>
<td><code>89450036UW3ID72T1M84.</code></td>
<td><code>89450036UW3ID72T1M84</code></td>
<td>punto finale</td>
</tr>
</tbody></table>
<p>Per le altre cinque righe il quadro è meno netto. Per Volksbank Sauerland eG ed EU Internet Ventures B.V. la ricerca per nome restituisce un solo record, con un LEI che differisce rispettivamente per una lettera (<code>X</code> al posto di <code>Y</code>) e per uno <code>0</code> in più nel file; per Raiffeisenbank Falkenstein-Wörth restituisce un record con un LEI completamente diverso, quindi non si tratta di un semplice refuso; per FINTECH PAYMENTS PSC S.L. e B2C2 Europe Sarl la ricerca esatta per nome non restituisce nulla. Non propongo correzioni per queste righe: una somiglianza nel nome non basta, e in un programma la cosa corretta da fare è segnalarle per una verifica manuale.</p>
<p>Nella maggior parte dei casi lo schema è compatibile con errori di trascrizione: <code>O</code>/<code>0</code>, un carattere sbagliato, un carattere perso o aggiunto. Il checksum modulo 97 intercetta quasi tutti questi errori, ed è proprio per questo che esiste.</p>
<h2>Che cosa significa (e che cosa no)</h2>
<ul>
<li><strong>Non significa che queste società non siano autorizzate.</strong> Il file ESMA fa parte del registro provvisorio (<em>interim register</em>) pubblicato dall'autorità europea sulla base delle informazioni trasmesse dalle autorità nazionali; un errore di battitura nel LEI non cambia lo stato dell'autorizzazione. Per lo stato di un singolo soggetto la fonte resta la pagina ESMA su MiCA (<a href="https://www.esma.europa.eu/esmas-activities/digital-finance-and-innovation/markets-crypto-assets-regulation-mica">https://www.esma.europa.eu/esmas-activities/digital-finance-and-innovation/markets-crypto-assets-regulation-mica</a>) e l'autorità nazionale competente indicata nella riga.</li>
<li><strong>Significa che una join "esatta" sul LEI perde righe.</strong> Se il vostro strumento collega ESMA e GLEIF solo per LEI, 10 soggetti su 407 spariscono silenziosamente, e 5 di questi dichiarano servizi in Italia.</li>
<li><strong>La denominazione legale nel file può avere spazi finali</strong> (per esempio <code>Unlimit Crypto Ltd </code>): normalizzate anche quella prima di confrontarla.</li>
</ul>
<p>Una pipeline prudente quindi fa tre passi: <code>strip()</code> su tutti i campi, controllo di formato e checksum, poi chiamata GLEIF solo per i codici validi. Le righe che falliscono il secondo passo vanno in una coda di revisione, non in un <code>except: pass</code>.</p>
<p>Se vi serve verificare un singolo codice senza scrivere codice, il controllo di formato e checksum è disponibile anche in una pagina di CriptoStato, un sito che curo io (il sito contiene link di affiliazione a exchange, questo articolo no): <a href="https://criptostato.it/strumenti/controlla-lei/?utm_source=hashnode&amp;utm_medium=referral&amp;utm_campaign=it-parasite-2026-11-16-01&amp;utm_content=tool-controlla-lei">controlla un codice LEI su CriptoStato</a>. Come lo script sopra, la pagina verifica solo struttura e cifre di controllo, non l'esistenza del soggetto né la sua autorizzazione.</p>
<hr />
<p><em>Metodo: file <code>CASPS.csv</code> scaricato dall'URL ESMA indicato sopra il 16 novembre 2026; controlli di formato e checksum eseguiti localmente; esistenza dei codici verificata con l'API pubblica GLEIF (<code>/api/v1/lei-records/{LEI}</code>) lo stesso giorno. Il file viene aggiornato dall'ESMA: rieseguite lo script prima di fidarvi di questi numeri.</em></p>
]]></content:encoded></item><item><title><![CDATA[Before you poll 50 markets every 5 seconds: the request, bandwidth and retry budget to write down first]]></title><description><![CDATA[Polling a REST endpoint is the first thing most of us build when we need market data. It's simple, stateless and easy to debug. It's also the design that…]]></description><link>https://leodahlgren.hashnode.dev/before-you-poll-50-markets-every-5-seconds-the-request-bandwidth-and-retry-budget-to-write-down-first</link><guid isPermaLink="true">https://leodahlgren.hashnode.dev/before-you-poll-50-markets-every-5-seconds-the-request-bandwidth-and-retry-budget-to-write-down-first</guid><category><![CDATA[APIs]]></category><category><![CDATA[websockets]]></category><category><![CDATA[backend]]></category><category><![CDATA[performance]]></category><dc:creator><![CDATA[Leo Dahlgren]]></dc:creator><pubDate>Fri, 13 Nov 2026 12:30:19 GMT</pubDate><content:encoded><![CDATA[<p>Polling a REST endpoint is the first thing most of us build when we need market data. It's simple, stateless and easy to debug. It's also the design that quietly breaks when the market list grows from five symbols to fifty, or when the first HTTP 429 arrives and the retry logic starts competing with the next poll. Here's the budget I write down before choosing between polling and a WebSocket stream. The numbers are my own examples, so plug in yours.</p>
<h2>1. Requests: the number that hits rate limits</h2>
<p>Requests = markets × hours × 3,600 ÷ seconds between polls.</p>
<p>Fifty markets, one request each, every 5 seconds, for 24 hours:</p>
<pre><code class="language-text">50 × 24 × 3600 ÷ 5 = 864,000 requests per day
</code></pre>
<p>That's 10 requests a second, sustained, before retries, before any order or account calls, and before a second instance of the service gets deployed by accident. Compare it to the venue's published limit for that endpoint and IP. If the limit is weighted (many exchanges charge some endpoints more than one unit), use the weight, not the call count.</p>
<p>If a batch endpoint returns all fifty tickers in one call, the same schedule is 17,280 requests a day. Check for a batch endpoint before anything else; it's the cheapest fix there is.</p>
<h2>2. Bandwidth: the number that hits your bill</h2>
<p>Payload bytes = requests × response bytes. MiB = bytes ÷ 1,048,576.</p>
<p>At an assumed 3,000 bytes per response:</p>
<pre><code class="language-text">864,000 × 3,000 = 2,592,000,000 bytes ≈ 2,471.92 MiB per day (payload only)
</code></pre>
<p>Slowing to a 15-second interval drops that to 288,000 requests and about 823.97 MiB. Real traffic is higher: this excludes HTTP and TLS overhead, headers and retries, and it ignores compression, which can cut it a lot. Measure one real response's size with the <code>Content-Length</code> header (<a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Length">MDN: Content-Length</a>) rather than guessing. TradeApiAtlas's <a href="https://tradeapiatlas.com/tools/polling-bandwidth/?utm_source=hashnode&amp;utm_medium=referral&amp;utm_campaign=en-platform-2026-11-13-03&amp;utm_content=tool-polling-bandwidth">polling bandwidth calculator</a> runs this with your inputs and shows the formula.</p>
<h2>3. Retries: the number that collides with your schedule</h2>
<p>Exponential backoff with a cap: wait before retry n = min(cap, base × 2^(n − 1)). If the server sends <code>Retry-After</code>, the first wait is at least that value.</p>
<p>With a 0.5-second base, a 20-second cap and six retries:</p>
<pre><code class="language-text">0.5, 1, 2, 4, 8, 16 → 31.5 seconds of waiting
</code></pre>
<p>With a 10-second cap instead: 0.5, 1, 2, 4, 8, 10, or 25.5 seconds.</p>
<p>Now put that next to a 5-second poll interval. One bad minute means a single market's retry chain spans five or six scheduled polls. If the scheduler keeps firing new polls while old ones are still backing off, you've built a request amplifier: the moment the server asks you to slow down, you speed up. Three rules fix most of it:</p>
<ul>
<li><strong>One in-flight request per market.</strong> Skip a scheduled poll if the last one hasn't finished or is backing off.</li>
<li><strong>Back off globally on 429</strong>, not per market. A rate limit is usually per key or per IP, so fifty independent backoff timers still add up to one hammer.</li>
<li><strong>Never blindly retry non-idempotent calls.</strong> Market data is safe to retry. An order submission isn't; reconcile order state first.</li>
</ul>
<p>The <a href="https://tradeapiatlas.com/tools/retry-backoff/?utm_source=hashnode&amp;utm_medium=referral&amp;utm_campaign=en-platform-2026-11-13-03&amp;utm_content=tool-retry-backoff">retry backoff planner</a> lays out the waits for your base, cap and retry count. Add jitter yourself; the planner deliberately doesn't.</p>
<h2>4. When the budget says "switch to a stream"</h2>
<p>A WebSocket connection (<a href="https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API">MDN: WebSocket API</a>) replaces repeated requests with one long-lived connection and pushed updates. It's not free either: you trade request counts for connection limits, subscription limits per connection, heartbeat handling, reconnect storms and sequence-gap recovery. My rough rule:</p>
<table>
<thead>
<tr>
<th>Signal</th>
<th>Lean towards</th>
</tr>
</thead>
<tbody><tr>
<td>Few markets, interval of 30 s or more, batch endpoint available</td>
<td>Polling</td>
</tr>
<tr>
<td>Requests per second within ~20% of the published limit</td>
<td>Stream, or batch first</td>
</tr>
<tr>
<td>You need every update, not a sample</td>
<td>Stream</td>
</tr>
<tr>
<td>Retry chains regularly span several poll intervals</td>
<td>Fix the scheduler, then reconsider a stream</td>
</tr>
<tr>
<td>Short-lived job or serverless runtime</td>
<td>Polling (connections don't survive)</td>
</tr>
</tbody></table>
<h2>The four lines I write in the design doc</h2>
<ol>
<li>Requests per second at peak, against the published (weighted) limit.</li>
<li>Payload MiB per day, measured from a real response.</li>
<li>Worst-case retry chain length, against the poll interval.</li>
<li>Which calls are safe to retry, and which need reconciliation first.</li>
</ol>
<p>If any of those four is uncomfortable, the design isn't done yet.</p>
<p><em>The calculators linked above are on TradeApiAtlas, which I run. They send no API requests and use only the numbers you type in.</em></p>
]]></content:encoded></item></channel></rss>