What changed, and why it matters
This commit adds a new translation system for the BitBox02 hardware wallet so that on-screen messages can appear in English or German. It does not fix a bug or change security behavior; it is a feature that reorganizes how text is stored and displayed. There is no indication this introduces a vulnerability.
No security action required. Review the build-time validation and runtime panic behavior of `format_pattern` during normal QA; ensure placeholder mismatches cannot be triggered by untrusted data.
Security signals we found
No strong security signals were identified.
Evidence from the diff
The change introduces a Rust crate bitbox-i18n plus English/German JSON catalogs. At build time the JSON is flattened, validated for matching keys and placeholder counts, hashed with FNV-1a64, and turned into a sorted static lookup table. Runtime code translates English source strings by hash, substitutes {}/{:?} placeholders, and provides German date formatting. The existing format_datetime function is preserved and delegates to a new locale-aware variant with English as the default. No cryptographic, memory-safety, or authorization logic is modified.
Changed components
src/rust/bitbox-i18nsrc/i18n/locales/en/firmware.jsonsrc/i18n/locales/de/firmware.jsonsrc/rust/util/src/datetime.rssrc/rust/bitbox-hal/src/memory.rsInspect captured patch +1163 / −16
### src/i18n/locales/de/firmware.json
@@ -0,0 +1,344 @@
+{
+ "cancel": {
+ "confirmCancel": "Wirklich\nabbrechen?"
+ },
+ "confirm": {
+ "size": "Größe"
+ },
+ "hww": {
+ "backup": {
+ "check": {
+ "id": "ID?",
+ "invalid": "Backup fehlt\noder ungültig",
+ "name": "Name?",
+ "valid": "Backup gültig"
+ },
+ "create": {
+ "confirm": "Backup erstellen?",
+ "fail": "Backup nicht\nerstellt ({})\nSupport kontaktieren",
+ "isToday": "Ist heute?",
+ "success": "Backup erstellt",
+ "unlock": "Gerät entsperren"
+ }
+ },
+ "bip85": {
+ "confirmAdvanced": {
+ "body": "Dies ist eine Funktion für Fortgeschrittene. Nur fortfahren, wenn du dich gut auskennst.",
+ "title": "BIP-85"
+ },
+ "confirmDerivation": {
+ "body": "BIP-39\nMnemonic ableiten?",
+ "title": "BIP-85"
+ },
+ "createLightning": "Lightning-Wallet\nauf Endgerät\nerstellen?",
+ "finished": "Fertig",
+ "howManyWords": "Wie viele Wörter?",
+ "index": {
+ "enter": "Index eingeben",
+ "invalid": "Ungültiger Index",
+ "more": "Mehr",
+ "select": "Index wählen",
+ "status": "Index: {}"
+ },
+ "keypath": "Pfad",
+ "wordCount": "{} Wörter"
+ },
+ "bitcoin": {
+ "atAccount": "{}\nKonto #{}",
+ "atPath": "{}\nauf\n{}",
+ "multisig": {
+ "cosigner": {
+ "other": "Cosigner {}/{}: {}",
+ "self": "Cosigner {}/{} (dieses Gerät): {}"
+ },
+ "scriptAtPath": "{}\nauf\n{}",
+ "threshold": "{}-von-{}\n{} Multisig"
+ },
+ "paymentRequest": {
+ "memo": "Memo",
+ "memoFrom": "Memo von: {}"
+ },
+ "policies": {
+ "info": "{}\nPolicy mit\n{} Schlüsseln",
+ "key": "Schlüssel {}/{}",
+ "name": "Name",
+ "provablyUnspendable": "Nachweislich nicht ausgebbar: {}",
+ "showDetails": "Policy-Details\nanzeigen?",
+ "thisDevice": "Dieses Gerät: {}",
+ "title": "Policy"
+ },
+ "receiveTo": "Empfangen an",
+ "registration": {
+ "enterAccountName": "Kontonamen eingeben",
+ "multisigRegistered": "Multisig-Setup\nregistriert",
+ "policyRegistered": "Policy\nregistriert",
+ "registerAccount": {
+ "body": "Bitte dieses\nKonto benennen",
+ "title": "Registrieren"
+ },
+ "title": "Registrieren"
+ },
+ "scriptConfigs": {
+ "thisBitBox": "Diese BitBox - {}",
+ "thisBitBoxAccount": "Diese BitBox (Konto #{})"
+ },
+ "signMessage": {
+ "address": "Adresse",
+ "coin": "Coin: {}",
+ "externalServiceKey": "Coin: {}\nSchlüssel für\nexternen Dienst",
+ "sign": "Signieren",
+ "signMessage": "Nachricht\nsignieren"
+ },
+ "signTx": {
+ "invalidPaymentRequest": "Ungültige\nZahlungsanfrage",
+ "loadingTx": "Transaktion lädt...",
+ "locktime": "Locktime bei Block:\n{}",
+ "locktimeUtc": "Locktime (UTC):\n{}\n{}:{}:{}",
+ "multipleChangeWarning": {
+ "body": "{} Outputs mit\nWechselgeld.\nFortfahren?",
+ "title": "Warnung"
+ },
+ "signingTx": "Transaktion\nwird signiert...",
+ "spendFrom": "Ausgeben von",
+ "thisBitBoxSame": "Diese BitBox (gleiches Konto)",
+ "txCanceled": "Transaktion\nabgebrochen",
+ "txConfirmed": "Transaktion\nbestätigt"
+ },
+ "unusualKeypathWarning": {
+ "body": "Warnung: ungewöhnlicher Keypath {}. Nur fortfahren, wenn du dich gut auskennst.",
+ "title": "xpub-Export"
+ }
+ },
+ "bluetooth": {
+ "confirmUpgrade": {
+ "body": "Firmware\naktualisieren?",
+ "title": "Bluetooth"
+ },
+ "disabled": "Bluetooth\ndeaktiviert",
+ "enabled": "Bluetooth\naktiviert",
+ "setDisable": "Bluetooth\ndeaktivieren?",
+ "setEnable": "Bluetooth aktivieren?",
+ "upgrade": {
+ "fail": "Aktualisierung\nfehlgeschlagen",
+ "progress": "Aktualisierung...",
+ "success": "Aktualisierung\nerfolgreich"
+ }
+ },
+ "changePassword": {
+ "confirm": "Passwort ändern\nfortsetzen?",
+ "error": "Fehler\n{}"
+ },
+ "cardano": {
+ "signTransaction": {
+ "alwaysAbstain": "Immer Enthaltung",
+ "alwaysNoConfidence": "Nie Vertrauen",
+ "amountAsset": "Betrag: {}. Asset: {}",
+ "canBeMinedFrom": "Gültig ab",
+ "canBeMinedUntil": "Gültig bis",
+ "cannotBeMined": "Transaktion\nkann nicht\ngemined werden",
+ "delegateStaking": "Staking für Konto #{} an Pool {} delegieren?",
+ "delegateVoting": "Voting für Konto #{} an Typ {} delegieren?",
+ "delegateVotingDrep": "Voting für Konto #{} an Typ {} und DRep {} delegieren?",
+ "fee": "Gebühr\n{}",
+ "keyHash": "Schlüssel-Hash",
+ "networkWarning": "Diese Transaktion enthält keine Angabe zum Cardano-Netzwerk und kann auch in einem anderen Cardano-Netzwerk gültig sein.",
+ "registerStakingKey": "Staking-Schlüssel für Konto #{} registrieren?",
+ "scriptHash": "Skript-Hash",
+ "sendToken": "Token senden",
+ "slotInEpoch": "{}\nSlot {} in\nEpoche {}",
+ "stopStakeDelegation": "Stake-Delegation für Konto #{} stoppen?",
+ "txCanceled": "Transaktion\nabgebrochen",
+ "txConfirmed": "Transaktion\nbestätigt",
+ "withdrawInStakingRewards": "{} Staking-Rewards für Konto #{} abheben?"
+ }
+ },
+ "ethereum": {
+ "loadingData": "Daten laden...",
+ "keypath": {
+ "unusualKeypath": "Warnung: ungewöhnlicher Keypath {}. Nur fortfahren, wenn du dich gut auskennst."
+ },
+ "network": {
+ "recognizeChainId": "Nur fortfahren, wenn\ndu diese Chain-ID\nerkennst.",
+ "unknownChainId": "Unbekanntes\nNetzwerk\nmit Chain-ID:\n{}"
+ },
+ "sign": {
+ "signOn": "Transaktion\nsignieren auf\n\n{}",
+ "tokenContract": "Token-\nContract",
+ "txCanceled": "Transaktion\nabgebrochen",
+ "txConfirmed": "Transaktion\nbestätigt",
+ "unknownAmount": "Unbekannter Betrag",
+ "unknownContract": {
+ "confirm": {
+ "body": "Die rohen\nTransaktionsdaten\nwerden angezeigt.",
+ "title": "Unbekannter\nContract"
+ },
+ "confirmAdvancedStreaming": "Nur fortfahren, wenn\ndu die Risiken ganz\nverstehst.",
+ "confirmAdvanced": "Nur fortfahren, wenn\ndu die Daten genau\nverstehst.",
+ "confirmStreaming": "Du signierst eine\nContract-Interaktion\nmit vielen Daten.",
+ "tooLarge": "Der nächste Wert ist\nzu gross für die\nvollständige Anzeige",
+ "transactionData": "Transaktions-\ndaten"
+ },
+ "unknownToken": "Unbekannter Token"
+ },
+ "signMsg": {
+ "sign": "Signieren",
+ "signMessage": "Nachricht\nsignieren"
+ },
+ "signTypedMsg": {
+ "Message": "Nachricht",
+ "domain": "Domain",
+ "empyList": "(leere Liste)",
+ "line": ", Zeile {}/{}",
+ "listWithElements": "Liste mit {} Elementen",
+ "messageType": "Nachrichtentyp",
+ "noChainIdWarning": "Die typisierten Daten enthalten keine Chain-ID. Die Nachricht ist auf jeder Chain gültig.",
+ "signData": "Daten signieren?",
+ "unknown": "Unbekannt"
+ }
+ },
+ "reset": {
+ "body": "In Werkszustand\nzurücksetzen?",
+ "status": "Zurückgesetzt",
+ "title": "Zurücksetzen"
+ },
+ "restore": {
+ "backupName": "Name: {}. ID: {}",
+ "confirmRestore": "Backup\nwiederherstellen?",
+ "error": "Backup nicht\nwiederhergestellt",
+ "invalidWords": "Recovery-Wörter\nungültig",
+ "isNow": "Ist jetzt?",
+ "passwordMismatch": "Passwörter\nnicht gleich.\nErneut versuchen?",
+ "validWords": "Recovery-Wörter\ngültig"
+ },
+ "setMnemonicPassphrase": {
+ "disable": "Deaktivieren",
+ "enable": "Aktivieren",
+ "optionalPassphrase": "Optionale\nPassphrase"
+ },
+ "setDeviceName": {
+ "title": "Name"
+ },
+ "setDeviceLanguage": {
+ "confirm": "Sprache ändern\nauf {}?",
+ "english": "Englisch",
+ "german": "Deutsch"
+ },
+ "setPassword": {
+ "repeat": "Erneut eingeben",
+ "set": "Passwort setzen"
+ },
+ "showMnemonic": {
+ "backupCreated": "Backup erstellt",
+ "doNotShareWarning": {
+ "body": "Teile deine\nRecovery-Wörter\nNIEMALS mit anderen!",
+ "title": "Warnung"
+ },
+ "unlockDevice": "Gerät entsperren",
+ "writeDown": {
+ "body": "Bitte schreibe die\nfolgenden Wörter auf",
+ "title": "Recovery-\nWörter"
+ }
+ },
+ "system": {
+ "reboot": "Neustart?",
+ "rebootToBootloader": "Gehe zu den\nStarteinstellungen?",
+ "upgrade": "Upgrade fortsetzen?"
+ }
+ },
+ "infoCentered": {
+ "skip": "Überspringen"
+ },
+ "lockscreen": "Siehe BitBoxApp",
+ "menu": {
+ "continue": "Weiter",
+ "select": "Wählen"
+ },
+ "mnemonic": {
+ "backToWords": "Zurück zu\nRecovery-Wörtern",
+ "cancelRestore": "Wiederherstellung\nabbrechen",
+ "choose": "Wählen",
+ "confirmCancel": {
+ "body": "Wiederherstellung\nabbrechen?",
+ "title": "Wieder-\nherstellen"
+ },
+ "confirmEachWord": "Bestätige\njedes Wort",
+ "editPrevious": "Letztes Wort\nbearbeiten",
+ "enterWords": "{} Wörter\neingeben",
+ "howManyWords": "Wie viele Wörter?",
+ "incorrectWord": "Falsches Wort\nErneut versuchen",
+ "invalidWord": "Ungültiges Wort\nErneut versuchen",
+ "invalidCheckRestart": "Ungültig. Recovery-\nWörter prüfen.\nNeu starten?",
+ "noneOfThem": "Keines davon",
+ "wordIndex": "{} von {}",
+ "wordsFollow": "{} Wörter folgen"
+ },
+ "orientation": "Seite antippen",
+ "pairing": {
+ "pairingCode": "Kopplungscode"
+ },
+ "password": {
+ "characterWarning": {
+ "body": "Dein Passwort\nhat weniger als\n4 Zeichen.\nFortfahren?",
+ "title": "Warnung"
+ },
+ "confirmCancel": "Wirklich\nabbrechen?",
+ "mismatch": "Passwörter\nnicht identisch",
+ "repeat": "Erneut eingeben",
+ "set": "Passwort setzen",
+ "success": "Erfolgreich"
+ },
+ "sdcard": {
+ "insertToContinue": "SD einstecken\nzum Fortfahren"
+ },
+ "transaction": {
+ "confirmSwap": {
+ "from": "{} von",
+ "to": "{} zu"
+ },
+ "confirmTransaction": {
+ "amount": "Betrag",
+ "fee": "Gebühr",
+ "recipient": "Empfänger",
+ "total": "Total"
+ },
+ "highFeeWarning": {
+ "body": "Gebühr: {}%\ndes Sendebetrags.\nFortfahren?",
+ "bodyTotalInputs": "Gebühr: {}%\naller Inputs.\nFortfahren?",
+ "title": "Hohe Gebühr"
+ }
+ },
+ "u2f": {
+ "auth": "U2F-Auth",
+ "initializeWithBitBoxApp": "Mit BitBoxApp\neinrichten, um U2F\nzu nutzen",
+ "refreshWebpage": "Webseite neu laden",
+ "register": "U2F einrichten",
+ "unknownSite": "Unbekannte Seite:",
+ "use": "U2F nutzen?"
+ },
+ "paymentRequest": {
+ "swap": "Swap"
+ },
+ "verifyMessage": {
+ "dataHex": "{}\nDaten (Hex)",
+ "pageTitle": "{}\n{}/{}"
+ },
+ "unlock": {
+ "enterPassword": "Passwort eingeben",
+ "keystoreUnlockFailed": "Entsperren fehlgeschlagen\n{}",
+ "passphrase": {
+ "confirm": "Bestätigen",
+ "confirmEmpty": "Leere Passphrase\nverwenden?",
+ "doubleCheck": "Bitte prüfe gleich\ndie angezeigte\nPassphrase erneut.",
+ "title": "Optionale Passphrase",
+ "tryAgain": "Bitte erneut\nversuchen"
+ },
+ "remainingAttempts": {
+ "last": "LETZTER Versuch.\nBei falschem\nPasswort wird das\nGerät zurückgesetzt.",
+ "other": "Du hast noch {}\nEingabeversuche.",
+ "title": "Warnung"
+ },
+ "wrongPassword": {
+ "base": "Passwort falsch"
+ }
+ }
+}
### src/i18n/locales/en/firmware.json
@@ -0,0 +1,344 @@
+{
+ "cancel": {
+ "confirmCancel": "Do you really\nwant to cancel?"
+ },
+ "confirm": {
+ "size": "Size"
+ },
+ "hww": {
+ "backup": {
+ "check": {
+ "id": "ID?",
+ "invalid": "Backup missing\nor invalid",
+ "name": "Name?",
+ "valid": "Backup valid"
+ },
+ "create": {
+ "confirm": "Create backup?",
+ "fail": "Backup not created\nPlease contact\nsupport ({})",
+ "isToday": "Is today?",
+ "success": "Backup created",
+ "unlock": "Unlock device"
+ }
+ },
+ "bip85": {
+ "confirmAdvanced": {
+ "body": "This is an advanced feature. Proceed only if you know what you are doing.",
+ "title": "BIP-85"
+ },
+ "confirmDerivation": {
+ "body": "Derive BIP-39\nmnemonic?",
+ "title": "BIP-85"
+ },
+ "createLightning": "Create\nLightning wallet\non host device?",
+ "finished": "Finished",
+ "howManyWords": "How many words?",
+ "index": {
+ "enter": "Enter index",
+ "invalid": "Invalid index",
+ "more": "More",
+ "select": "Select index",
+ "status": "Index: {}"
+ },
+ "keypath": "Keypath",
+ "wordCount": "{} words"
+ },
+ "bitcoin": {
+ "atAccount": "{}\naccount #{}",
+ "atPath": "{}\nat\n{}",
+ "multisig": {
+ "cosigner": {
+ "other": "Cosigner {}/{}: {}",
+ "self": "Cosigner {}/{} (this device): {}"
+ },
+ "scriptAtPath": "{}\nat\n{}",
+ "threshold": "{}-of-{}\n{} multisig"
+ },
+ "paymentRequest": {
+ "memo": "Memo",
+ "memoFrom": "Memo from: {}"
+ },
+ "policies": {
+ "info": "{}\npolicy with\n{} keys",
+ "key": "Key {}/{}",
+ "name": "Name",
+ "provablyUnspendable": "Provably unspendable: {}",
+ "showDetails": "Show policy\ndetails?",
+ "thisDevice": "This device: {}",
+ "title": "Policy"
+ },
+ "receiveTo": "Receive to",
+ "registration": {
+ "enterAccountName": "Enter account name",
+ "multisigRegistered": "Multisig account\nregistered",
+ "policyRegistered": "Policy\nregistered",
+ "registerAccount": {
+ "body": "Please name this\naccount",
+ "title": "Register"
+ },
+ "title": "Register"
+ },
+ "scriptConfigs": {
+ "thisBitBox": "This BitBox - {}",
+ "thisBitBoxAccount": "This BitBox (account #{})"
+ },
+ "signMessage": {
+ "address": "Address",
+ "coin": "Coin: {}",
+ "externalServiceKey": "Coin: {}\nExternal service key",
+ "sign": "Sign",
+ "signMessage": "Sign message"
+ },
+ "signTx": {
+ "invalidPaymentRequest": "Invalid\npayment request",
+ "loadingTx": "Loading transaction...",
+ "locktime": "Locktime on block:\n{}",
+ "locktimeUtc": "Locktime (UTC):\n{}\n{}:{}:{}",
+ "multipleChangeWarning": {
+ "body": "There are {}\nchange outputs.\nProceed?",
+ "title": "Warning"
+ },
+ "signingTx": "Signing transaction...",
+ "spendFrom": "Spend from",
+ "thisBitBoxSame": "This BitBox (same account)",
+ "txCanceled": "Transaction\ncanceled",
+ "txConfirmed": "Transaction\nconfirmed"
+ },
+ "unusualKeypathWarning": {
+ "body": "Warning: unusual keypath {}. Proceed only if you know what you are doing.",
+ "title": "Export xpub"
+ }
+ },
+ "bluetooth": {
+ "confirmUpgrade": {
+ "body": "Upgrade\nfirmware?",
+ "title": "Bluetooth"
+ },
+ "disabled": "Bluetooth\ndisabled",
+ "enabled": "Bluetooth\nenabled",
+ "setDisable": "Disable Bluetooth?",
+ "setEnable": "Enable Bluetooth?",
+ "upgrade": {
+ "fail": "Upgrade failed",
+ "progress": "Upgrading...",
+ "success": "Upgrade\nsuccessful"
+ }
+ },
+ "changePassword": {
+ "confirm": "Proceed to\nchange password?",
+ "error": "Error\n{}"
+ },
+ "cardano": {
+ "signTransaction": {
+ "alwaysAbstain": "Always Abstain",
+ "alwaysNoConfidence": "Always No Confidence",
+ "amountAsset": "Amount: {}. Asset: {}",
+ "canBeMinedFrom": "Can be mined from",
+ "canBeMinedUntil": "Can be mined until",
+ "cannotBeMined": "Transaction\ncannot be\nmined",
+ "delegateStaking": "Delegate staking for account #{} to pool {}?",
+ "delegateVoting": "Delegate voting for account #{} to type {}?",
+ "delegateVotingDrep": "Delegate voting for account #{} to type {} and drep {}?",
+ "fee": "Fee\n{}",
+ "keyHash": "Key Hash",
+ "networkWarning": "This transaction does not encode a Cardano network and may be valid on another Cardano network.",
+ "registerStakingKey": "Register staking key for account #{}?",
+ "scriptHash": "Script Hash",
+ "sendToken": "Send token",
+ "slotInEpoch": "{}\nslot {} in\nepoch {}",
+ "stopStakeDelegation": "Stop stake delegation for account #{}?",
+ "txCanceled": "Transaction\ncanceled",
+ "txConfirmed": "Transaction\nconfirmed",
+ "withdrawInStakingRewards": "Withdraw {} in staking rewards for account #{}?"
+ }
+ },
+ "ethereum": {
+ "loadingData": "Loading data...",
+ "keypath": {
+ "unusualKeypath": "Warning: unusual keypath {}. Proceed only if you know what you are doing."
+ },
+ "network": {
+ "recognizeChainId": "Only proceed if\nyou recognize\nthis chain ID.",
+ "unknownChainId": "Unknown network\nwith chain ID:\n{}"
+ },
+ "sign": {
+ "signOn": "Sign transaction on\n\n{}",
+ "tokenContract": "Token\ncontract",
+ "txCanceled": "Transaction\ncanceled",
+ "txConfirmed": "Transaction\nconfirmed",
+ "unknownAmount": "Unknown amount",
+ "unknownContract": {
+ "confirm": {
+ "body": "You will be shown\nthe raw\ntransaction data.",
+ "title": "Unknown\ncontract"
+ },
+ "confirmAdvancedStreaming": "Only proceed if you\nfully understand\nthe risks involved.",
+ "confirmAdvanced": "Only proceed if you\nunderstand exactly\nwhat the data means.",
+ "confirmStreaming": "You are signing a\ncontract interaction\nwith large data.",
+ "tooLarge": "The next value is\ntoo large to display\nin full",
+ "transactionData": "Transaction\ndata"
+ },
+ "unknownToken": "Unknown token"
+ },
+ "signMsg": {
+ "sign": "Sign",
+ "signMessage": "Sign message"
+ },
+ "signTypedMsg": {
+ "Message": "Message",
+ "domain": "Domain",
+ "empyList": "(empty list)",
+ "line": ", line {}/{}",
+ "listWithElements": "list with {} elements",
+ "messageType": "Message type",
+ "noChainIdWarning": "Typed data has no chain ID. Message is valid for every chain.",
+ "signData": "Sign data?",
+ "unknown": "Unknown"
+ }
+ },
+ "reset": {
+ "body": "Proceed to\nfactory reset?",
+ "status": "Device reset",
+ "title": "RESET"
+ },
+ "restore": {
+ "backupName": "Name: {}. ID: {}",
+ "confirmRestore": "Restore backup?",
+ "error": "Could not\nrestore backup",
+ "invalidWords": "Recovery words\ninvalid",
+ "isNow": "Is now?",
+ "passwordMismatch": "Passwords\ndo not match.\nTry again?",
+ "validWords": "Recovery words\nvalid"
+ },
+ "setMnemonicPassphrase": {
+ "disable": "Disable",
+ "enable": "Enable",
+ "optionalPassphrase": "Optional\npassphrase"
+ },
+ "setDeviceName": {
+ "title": "Name"
+ },
+ "setDeviceLanguage": {
+ "confirm": "Change language\nto {}?",
+ "english": "English",
+ "german": "German"
+ },
+ "setPassword": {
+ "repeat": "Repeat password",
+ "set": "Set password"
+ },
+ "showMnemonic": {
+ "backupCreated": "Backup created",
+ "doNotShareWarning": {
+ "body": "DO NOT share your\nrecovery words with\nanyone!",
+ "title": "Warning"
+ },
+ "unlockDevice": "Unlock device",
+ "writeDown": {
+ "body": "Please write down\nthe following words",
+ "title": "Recovery\nwords"
+ }
+ },
+ "system": {
+ "reboot": "Reboot?",
+ "rebootToBootloader": "Go to\nstartup settings?",
+ "upgrade": "Proceed to upgrade?"
+ }
+ },
+ "infoCentered": {
+ "skip": "Skip"
+ },
+ "lockscreen": "See the BitBoxApp",
+ "menu": {
+ "continue": "Continue",
+ "select": "Select"
+ },
+ "mnemonic": {
+ "backToWords": "Back to\nrecovery words",
+ "cancelRestore": "Cancel restore",
+ "choose": "Choose",
+ "confirmCancel": {
+ "body": "Cancel restore?",
+ "title": "Restore"
+ },
+ "confirmEachWord": "Please confirm\neach word",
+ "editPrevious": "Edit previous word",
+ "enterWords": "Enter {} words",
+ "howManyWords": "How many words?",
+ "incorrectWord": "Incorrect word\nTry again",
+ "invalidWord": "Invalid word\nTry again",
+ "invalidCheckRestart": "Invalid. Check\nrecovery words.\nRestart?",
+ "noneOfThem": "None of them",
+ "wordIndex": "{} of {}",
+ "wordsFollow": "{} words follow"
+ },
+ "orientation": "Tap this side",
+ "pairing": {
+ "pairingCode": "Pairing code"
+ },
+ "password": {
+ "characterWarning": {
+ "body": "Your password\n has fewer than\n 4 characters.\nContinue?",
+ "title": "WARNING"
+ },
+ "confirmCancel": "Do you really\nwant to cancel?",
+ "mismatch": "Passwords\ndo not match",
+ "repeat": "Repeat password",
+ "set": "Set password",
+ "success": "Success"
+ },
+ "sdcard": {
+ "insertToContinue": "Insert SD card\nto continue"
+ },
+ "transaction": {
+ "confirmSwap": {
+ "from": "{} from",
+ "to": "{} to"
+ },
+ "confirmTransaction": {
+ "amount": "Amount",
+ "fee": "Fee",
+ "recipient": "Recipient",
+ "total": "Total"
+ },
+ "highFeeWarning": {
+ "body": "Fee is {}%\nof the send amount.\nProceed?",
+ "bodyTotalInputs": "Fee is {}%\nof all inputs.\nProceed?",
+ "title": "High fee"
+ }
+ },
+ "u2f": {
+ "auth": "U2F auth",
+ "initializeWithBitBoxApp": "Initialize with BitBoxApp\nto use U2F",
+ "refreshWebpage": "Refresh webpage",
+ "register": "U2F register",
+ "unknownSite": "Unknown site:",
+ "use": "Use U2F?"
+ },
+ "paymentRequest": {
+ "swap": "Swap"
+ },
+ "verifyMessage": {
+ "dataHex": "{}\ndata (hex)",
+ "pageTitle": "{} {}/{}"
+ },
+ "unlock": {
+ "enterPassword": "Enter password",
+ "keystoreUnlockFailed": "keystore unlock failed\n{}",
+ "passphrase": {
+ "confirm": "Confirm",
+ "confirmEmpty": "Use empty\npassphrase?",
+ "doubleCheck": "You will be asked to\nvisually confirm your\npassphrase now.",
+ "title": "Optional passphrase",
+ "tryAgain": "Please try again"
+ },
+ "remainingAttempts": {
+ "last": "This is your LAST\npassword attempt.\nDevice will reset\nif password is wrong.",
+ "other": "You have {}\npassword attempts\nleft.",
+ "title": "WARNING"
+ },
+ "wrongPassword": {
+ "base": "Wrong password"
+ }
+ }
+}
### src/rust/Cargo.lock
@@ -210,6 +210,14 @@ dependencies = [
"zeroize",
]
+[[package]]
+name = "bitbox-i18n"
+version = "0.1.0"
+dependencies = [
+ "bitbox-hal",
+ "serde_json",
+]
+
[[package]]
name = "bitbox-lvgl"
version = "0.1.0"
### src/rust/Cargo.toml
@@ -20,6 +20,7 @@ members = [
"bitbox-executor",
"bitbox-framed-serial-link",
"bitbox-hal",
+ "bitbox-i18n",
"bitbox-lvgl",
"bitbox-lvgl-sys",
"bitbox-mcu-stm32u5",
### src/rust/bitbox-hal/src/memory.rs
@@ -36,6 +36,12 @@ pub enum Platform {
BitBox03,
}
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum Language {
+ English,
+ German,
+}
+
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum Error {
InvalidInput,
### src/rust/bitbox-i18n/Cargo.toml
@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "bitbox-i18n"
+version = "0.1.0"
+authors = ["Shift Crypto AG <support@bitbox.swiss>"]
+edition = "2024"
+license = "Apache-2.0"
+
+[dependencies]
+bitbox-hal = { path = "../bitbox-hal" }
+
+[build-dependencies]
+serde_json = { workspace = true }
### src/rust/bitbox-i18n/build.rs
@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: Apache-2.0
+
+use std::collections::BTreeMap;
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+const FNV1A64_OFFSET: u64 = 0xcbf29ce484222325;
+const FNV1A64_PRIME: u64 = 0x100000001b3;
+
+fn main() {
+ let locales_dir = locales_dir();
+ let en_path = locales_dir.join("en/firmware.json");
+ let de_path = locales_dir.join("de/firmware.json");
+
+ println!("cargo::rerun-if-changed={}", en_path.display());
+ println!("cargo::rerun-if-changed={}", de_path.display());
+
+ let english = read_flattened_json(&en_path);
+ let german = read_flattened_json(&de_path);
+ let german_entries = locale_entries(&english, &german, &de_path);
+
+ let mut generated = generated_table(&german_entries);
+ generated.push_str(&generated_valid_en_hashes(&english));
+
+ let out = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR not set")).join("i18n.rs");
+ fs::write(out, generated).expect("failed to write generated i18n table");
+}
+
+fn locales_dir() -> PathBuf {
+ Path::new(&env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR not set"))
+ .join("../../i18n/locales")
+}
+
+fn read_flattened_json(path: &Path) -> BTreeMap<String, String> {
+ let data = fs::read_to_string(path)
+ .unwrap_or_else(|err| panic!("failed to read locale file {}: {err}", path.display()));
+ let value: serde_json::Value = serde_json::from_str(&data)
+ .unwrap_or_else(|err| panic!("failed to parse locale file {}: {err}", path.display()));
+
+ let mut flattened = BTreeMap::new();
+ flatten_json("", &value, &mut flattened, path);
+ flattened
+}
+
+fn flatten_json(
+ prefix: &str,
+ value: &serde_json::Value,
+ out: &mut BTreeMap<String, String>,
+ path: &Path,
+) {
+ match value {
+ serde_json::Value::Object(map) => {
+ for (key, value) in map {
+ let key = if prefix.is_empty() {
+ key.to_owned()
+ } else {
+ format!("{prefix}.{key}")
+ };
+ flatten_json(&key, value, out, path);
+ }
+ }
+ serde_json::Value::String(value) => {
+ if out.insert(prefix.to_owned(), value.to_owned()).is_some() {
+ panic!("duplicate flattened key '{}' in {}", prefix, path.display());
+ }
+ }
+ _ => panic!(
+ "locale file {} contains a non-string leaf at key '{}'",
+ path.display(),
+ prefix
+ ),
+ }
+}
+
+fn locale_entries(
+ english: &BTreeMap<String, String>,
+ locale: &BTreeMap<String, String>,
+ locale_path: &Path,
+) -> Vec<(String, String)> {
+ let mut by_english = BTreeMap::<String, String>::new();
+ for key in locale.keys() {
+ if !english.contains_key(key) {
+ panic!(
+ "locale file {} contains key '{}' which does not exist in English",
+ locale_path.display(),
+ key
+ );
+ }
+ }
+ for (key, english) in english {
+ let translated = locale.get(key).unwrap_or_else(|| {
+ panic!(
+ "locale file {} is missing English key '{}'",
+ locale_path.display(),
+ key
+ )
+ });
+ if placeholder_count(english) != placeholder_count(translated) {
+ panic!(
+ "placeholder mismatch in {} at key '{}': {:?} vs {:?}",
+ locale_path.display(),
+ key,
+ english,
+ translated
+ );
+ }
+ match by_english.get(english) {
+ Some(existing) if existing != translated => {
+ panic!(
+ "locale file {} has conflicting translations for {:?}: {:?} and {:?}",
+ locale_path.display(),
+ english,
+ existing,
+ translated
+ );
+ }
+ Some(_) => {}
+ None => {
+ by_english.insert(english.to_owned(), translated.to_owned());
+ }
+ }
+ }
+ by_english.into_iter().collect()
+}
+
+fn placeholder_count(value: &str) -> usize {
+ value.matches("{}").count() + value.matches("{:?}").count()
+}
+
+fn generated_table(entries: &[(String, String)]) -> String {
+ let mut out = String::from("// @generated by build.rs\n\n");
+ out.push_str("pub(crate) const DE_TRANSLATIONS: &[(u64, &str)] = &[\n");
+ let mut by_key = BTreeMap::<u64, (&str, &str)>::new();
+ for (english, translated) in entries {
+ let key = translation_key(english);
+ if let Some((existing, _)) = by_key.insert(key, (english.as_str(), translated.as_str())) {
+ panic!("translation key collision between {existing:?} and {english:?}");
+ }
+ }
+ for (key, (_, translated)) in by_key {
+ out.push_str(&format!(" (0x{key:016x}, {translated:?}),\n"));
+ }
+ out.push_str("];\n");
+ out
+}
+
+fn generated_valid_en_hashes(english: &BTreeMap<String, String>) -> String {
+ let mut hashes: Vec<u64> = english
+ .values()
+ .map(|value| translation_key(value))
+ .collect();
+ hashes.sort_unstable();
+ hashes.dedup();
+
+ let mut out = String::from("\npub(crate) const VALID_EN_HASHES: &[u64] = &[\n");
+ for hash in hashes {
+ out.push_str(&format!(" 0x{hash:016x},\n"));
+ }
+ out.push_str("];\n");
+ out
+}
+
+fn translation_key(value: &str) -> u64 {
+ let mut hash = FNV1A64_OFFSET;
+ for byte in value.as_bytes() {
+ hash ^= u64::from(*byte);
+ hash = hash.wrapping_mul(FNV1A64_PRIME);
+ }
+ hash
+}
### src/rust/bitbox-i18n/src/lib.rs
@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#![no_std]
+
+extern crate alloc;
+
+use alloc::borrow::Cow;
+use alloc::string::String;
+use bitbox_hal::memory::Language;
+
+include!(concat!(env!("OUT_DIR"), "/i18n.rs"));
+
+const FNV1A64_OFFSET: u64 = 0xcbf29ce484222325;
+const FNV1A64_PRIME: u64 = 0x100000001b3;
+
+pub fn language_from_code(code: &str) -> Option<Language> {
+ let code = code.as_bytes();
+ if code.len() < 2 {
+ return None;
+ }
+ if code.len() > 2 && code[2] != b'-' && code[2] != b'_' {
+ return None;
+ }
+
+ match (code[0].to_ascii_lowercase(), code[1].to_ascii_lowercase()) {
+ (b'e', b'n') => Some(Language::English),
+ (b'd', b'e') => Some(Language::German),
+ _ => None,
+ }
+}
+
+pub fn language_code(language: Language) -> &'static str {
+ match language {
+ Language::English => "en",
+ Language::German => "de",
+ }
+}
+
+pub fn translate<'a>(language: Language, english: &'a str) -> Cow<'a, str> {
+ match language {
+ Language::English => Cow::Borrowed(english),
+ Language::German => translate_from_table(english, DE_TRANSLATIONS)
+ .map(Cow::Borrowed)
+ .unwrap_or(Cow::Borrowed(english)),
+ }
+}
+
+pub fn format(language: Language, english: &'static str, args: &[&str]) -> String {
+ let translated = translate(language, english);
+ format_pattern(&translated, args)
+}
+
+pub const fn is_translatable(english: &str) -> bool {
+ let key = translation_key(english);
+ let mut lo = 0;
+ let mut hi = VALID_EN_HASHES.len();
+ while lo < hi {
+ let mid = lo + (hi - lo) / 2;
+ let value = VALID_EN_HASHES[mid];
+ if value == key {
+ return true;
+ } else if value < key {
+ lo = mid + 1;
+ } else {
+ hi = mid;
+ }
+ }
+ false
+}
+
+fn translate_from_table<'a>(english: &str, table: &'a [(u64, &str)]) -> Option<&'a str> {
+ let key = translation_key(english);
+ table
+ .binary_search_by_key(&key, |(source_key, _)| *source_key)
+ .ok()
+ .map(|index| table[index].1)
+}
+
+const fn translation_key(value: &str) -> u64 {
+ let bytes = value.as_bytes();
+ let mut hash = FNV1A64_OFFSET;
+ let mut i = 0;
+ while i < bytes.len() {
+ hash ^= bytes[i] as u64;
+ hash = hash.wrapping_mul(FNV1A64_PRIME);
+ i += 1;
+ }
+ hash
+}
+
+fn format_pattern(pattern: &str, args: &[&str]) -> String {
+ let mut out =
+ String::with_capacity(pattern.len() + args.iter().map(|arg| arg.len()).sum::<usize>());
+ let mut rest = pattern;
+ let mut args = args.iter();
+
+ while let Some((start, len)) = next_placeholder(rest) {
+ out.push_str(&rest[..start]);
+ out.push_str(args.next().expect("not enough format arguments"));
+ rest = &rest[start + len..];
+ }
+ assert!(args.next().is_none(), "too many format arguments");
+ out.push_str(rest);
+ out
+}
+
+fn next_placeholder(value: &str) -> Option<(usize, usize)> {
+ match (value.find("{}"), value.find("{:?}")) {
+ (Some(a), Some(b)) if a <= b => Some((a, 2)),
+ (Some(_), Some(b)) => Some((b, 4)),
+ (Some(a), None) => Some((a, 2)),
+ (None, Some(b)) => Some((b, 4)),
+ (None, None) => None,
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_language_from_code() {
+ assert_eq!(language_from_code("en"), Some(Language::English));
+ assert_eq!(language_from_code("EN-us"), Some(Language::English));
+ assert_eq!(language_from_code("de"), Some(Language::German));
+ assert_eq!(language_from_code("de_CH"), Some(Language::German));
+ assert_eq!(language_from_code("dex"), None);
+ assert_eq!(language_from_code("it"), None);
+ }
+
+ #[test]
+ fn test_translate() {
+ assert_eq!(
+ translate(Language::English, "Proceed to upgrade?").as_ref(),
+ "Proceed to upgrade?"
+ );
+ assert_eq!(
+ translate(Language::German, "Proceed to upgrade?").as_ref(),
+ "Upgrade fortsetzen?"
+ );
+ assert_eq!(
+ translate(Language::German, "Not translated").as_ref(),
+ "Not translated"
+ );
+ }
+
+ #[test]
+ fn test_generated_table_sorted() {
+ assert!(DE_TRANSLATIONS.windows(2).all(|pair| pair[0].0 < pair[1].0));
+ }
+
+ #[test]
+ fn test_is_translatable() {
+ assert!(is_translatable("Proceed to upgrade?"));
+ assert!(!is_translatable("Proceed to upgrade"));
+ assert!(!is_translatable("definitely not a source string"));
+ }
+
+ #[test]
+ fn test_format() {
+ assert_eq!(
+ format(
+ Language::German,
+ "Fee is {}%\nof the send amount.\nProceed?",
+ &["17.0"],
+ ),
+ "Gebühr: 17.0%\ndes Sendebetrags.\nFortfahren?"
+ );
+ }
+
+ #[test]
+ fn test_format_pattern() {
+ assert_eq!(format_pattern("No arguments", &[]), "No arguments");
+ assert_eq!(
+ format_pattern("{} / {:?} / {}", &["first", "second", "third"]),
+ "first / second / third"
+ );
+ }
+
+ #[test]
+ #[should_panic(expected = "not enough format arguments")]
+ fn test_format_pattern_too_few_arguments() {
+ format_pattern("Fee is {}%", &[]);
+ }
+
+ #[test]
+ #[should_panic(expected = "too many format arguments")]
+ fn test_format_pattern_too_many_arguments() {
+ format_pattern("Fee is {}%", &["17.0", "unexpected"]);
+ }
+}
### src/rust/util/src/datetime.rs
@@ -3,34 +3,77 @@
use alloc::string::String;
use time::{OffsetDateTime, UtcOffset, Weekday};
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum DateLocale {
+ English,
+ German,
+}
+
pub struct Tm {
datetime: OffsetDateTime,
}
impl Tm {
/// Returns the weekday, one of "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
pub fn weekday(&self) -> String {
+ self.weekday_locale(DateLocale::English)
+ }
+
+ fn weekday_locale(&self, locale: DateLocale) -> String {
match self.datetime.weekday() {
- Weekday::Sunday => "Sun",
- Weekday::Monday => "Mon",
- Weekday::Tuesday => "Tue",
- Weekday::Wednesday => "Wed",
- Weekday::Thursday => "Thu",
- Weekday::Friday => "Fri",
- Weekday::Saturday => "Sat",
+ Weekday::Sunday => match locale {
+ DateLocale::English => "Sun",
+ DateLocale::German => "So",
+ },
+ Weekday::Monday => match locale {
+ DateLocale::English => "Mon",
+ DateLocale::German => "Mo",
+ },
+ Weekday::Tuesday => match locale {
+ DateLocale::English => "Tue",
+ DateLocale::German => "Di",
+ },
+ Weekday::Wednesday => match locale {
+ DateLocale::English => "Wed",
+ DateLocale::German => "Mi",
+ },
+ Weekday::Thursday => match locale {
+ DateLocale::English => "Thu",
+ DateLocale::German => "Do",
+ },
+ Weekday::Friday => match locale {
+ DateLocale::English => "Fri",
+ DateLocale::German => "Fr",
+ },
+ Weekday::Saturday => match locale {
+ DateLocale::English => "Sat",
+ DateLocale::German => "Sa",
+ },
}
.into()
}
/// Returns 'year-month-day', e.g. 2024-07-16, equivalent of '%Y-%m-%d' in strftime.
pub fn date(&self) -> String {
+ self.date_locale(DateLocale::English)
+ }
+
+ fn date_locale(&self, locale: DateLocale) -> String {
let date = self.datetime.date();
- format!(
- "{}-{:02}-{:02}",
- date.year(),
- date.month() as u8,
- date.day(),
- )
+ match locale {
+ DateLocale::English => format!(
+ "{}-{:02}-{:02}",
+ date.year(),
+ date.month() as u8,
+ date.day(),
+ ),
+ DateLocale::German => format!(
+ "{:02}.{:02}.{}",
+ date.day(),
+ date.month() as u8,
+ date.year(),
+ ),
+ }
}
/// Returns the zero-padded hour from 00-23, e.g. "07".
@@ -62,6 +105,15 @@ pub fn format_datetime(
timestamp: u32,
timezone_offset: i32,
date_only: bool,
+) -> Result<String, ()> {
+ format_datetime_locale(timestamp, timezone_offset, date_only, DateLocale::English)
+}
+
+pub fn format_datetime_locale(
+ timestamp: u32,
+ timezone_offset: i32,
+ date_only: bool,
+ locale: DateLocale,
) -> Result<String, ()> {
const MAX_EAST_UTC_OFFSET: i32 = 50400; // 14 hours in seconds
const MAX_WEST_UTC_OFFSET: i32 = -43200; // 12 hours in seconds
@@ -77,12 +129,12 @@ pub fn format_datetime(
.ok_or(())?;
let tm = Tm { datetime };
Ok(if date_only {
- format!("{} {}", tm.weekday(), tm.date())
+ format!("{} {}", tm.weekday_locale(locale), tm.date_locale(locale))
} else {
format!(
"{} {}\n{}:{}",
- tm.weekday(),
- tm.date(),
+ tm.weekday_locale(locale),
+ tm.date_locale(locale),
tm.hour(),
tm.minute()
)
@@ -115,4 +167,20 @@ mod tests {
assert!(format_datetime(1601281809, 50401, false).is_err());
assert!(format_datetime(1601281809, -43201, false).is_err());
}
+
+ #[test]
+ fn test_format_datetime_locale() {
+ assert_eq!(
+ format_datetime_locale(1779964200, 0, true, DateLocale::German),
+ Ok("Do 28.05.2026".into())
+ );
+ assert_eq!(
+ format_datetime_locale(1779964200, 0, false, DateLocale::German),
+ Ok("Do 28.05.2026\n10:30".into())
+ );
+ assert_eq!(
+ format_datetime_locale(1601281809, -32400, false, DateLocale::German),
+ Ok("So 27.09.2020\n23:30".into())
+ );
+ }
}Why this scored 15/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.