import { LitElement, html, css } from 'lit';
import { customElement, state, property } from 'lit/decorators.js';
import { classMap } from 'lit/directives/class-map.js';
import { mdiFileUpload } from '@mdi/js';
import { sha3_256 } from '@noble/hashes/sha3';
import { bytesToHex } from '@noble/hashes/utils';
import type { PyodideInterface } from 'pyodide';
import { FirmwareIcons } from './const';
import type { Manifest } from './const';
import './usf-file-upload';
import './usf-icon';
import '@material/mwc-dialog';
import '@material/mwc-button';
import '@material/mwc-formfield';
import '@material/mwc-radio';
import '@material/mwc-circular-progress';
type GBLImage = any;
const CUSTOM_UPLOAD_INDEX = 9999;
async function readFile(file: Blob): Promise {
return new Promise((resolve, reject) => {
const reader = new FileReader();
reader.onload = () => resolve(reader.result! as ArrayBuffer);
reader.onerror = e => reject(e);
reader.readAsArrayBuffer(file);
});
}
export function validateFirmwareChecksum(
buffer: ArrayBuffer,
expectedChecksum: string
): void {
const [algorithm, expectedHash] = expectedChecksum.split(':');
let actualHash: string;
if (algorithm === 'sha3-256') {
actualHash = bytesToHex(sha3_256(new Uint8Array(buffer)));
} else {
throw new Error(`Unsupported checksum algorithm: ${algorithm}`);
}
if (actualHash !== expectedHash) {
throw new Error(
`Firmware checksum mismatch: expected ${expectedHash}, got ${actualHash}`
);
}
}
export async function parseFirmwareBuffer(
pyodide: PyodideInterface,
buffer: ArrayBuffer
): Promise {
const { GBLImage } = pyodide.pyimport('universal_silabs_flasher.firmware');
return await GBLImage.from_bytes.callKwargs(pyodide.toPy(buffer), {});
}
@customElement('firmware-selector')
export class FirmwareSelector extends LitElement {
@property()
public pyodide!: PyodideInterface;
@property()
public manifest!: Manifest;
@state()
private firmwareUploadIndex = 0;
private firmwareLoaded(firmware?: GBLImage) {
this.dispatchEvent(
new CustomEvent('firmwareLoaded', {
detail: { firmware },
bubbles: true,
composed: true,
})
);
}
firstUpdated() {
this.renderRoot
.querySelector('mwc-radio')!
.dispatchEvent(new Event('change'));
}
private async firmwareUploadTypeChanged(event: Event) {
this.firmwareUploadIndex = parseInt(
(event!.target! as HTMLInputElement).value!,
10
);
// The GBL file upload element will be rendered empty
if (this.firmwareUploadIndex === CUSTOM_UPLOAD_INDEX) {
this.firmwareLoaded(undefined);
return;
}
// Download the firmware
const firmware = this.manifest.firmwares[this.firmwareUploadIndex];
const response = await fetch(firmware.url);
if (!response.ok) {
alert(`Failed to download firmware: ${response}`);
return;
}
const firmwareData = await response.arrayBuffer();
if (firmware.checksum) {
validateFirmwareChecksum(firmwareData, firmware.checksum);
}
await this.loadFirmware(firmwareData);
}
private async customFirmwareChosen(event: Event) {
const file = (event.target! as HTMLInputElement).files![0];
const firmwareData = await readFile(file);
await this.loadFirmware(firmwareData);
}
private async loadFirmware(buffer: ArrayBuffer) {
let firmware: GBLImage;
try {
firmware = await parseFirmwareBuffer(this.pyodide, buffer);
} catch (e) {
firmware = undefined;
alert(`Failed to parse firmware: ${e}`);
}
this.firmwareLoaded(firmware);
}
public render() {
return html`
${this.manifest.firmwares.map(
(fw, index) =>
html`
`
)}
${this.manifest.allow_custom_firmware_upload
? html`
Upload
`
: ''}
`;
}
static styles = css`
.hidden {
display: none;
}
mwc-formfield {
display: block;
}
usf-icon {
margin-right: 1em;
}
`;
}
declare global {
interface HTMLElementTagNameMap {
'firmware-selector': FirmwareSelector;
}
}