function bufferFromBase64(base64) { const binaryString = atob(base64); const length = binaryString.length; const bytes = new Uint8Array(length); for (let i = 0; i < length; i++) { bytes[i] = binaryString.charCodeAt(i); } return bytes; } function fromString(str, encoding = "utf8") { if (encoding === "utf8") { return new TextEncoder().encode(str); } else if (encoding === "base16") { if (str.length % 2 !== 0) { throw new Error("Invalid hex string length."); } let bytes = new Uint8Array(str.length / 2); for (let i = 0; i < str.length; i += 2) { bytes[i / 2] = parseInt(str.substring(i, i + 2), 16); } return bytes; } else if (encoding === "base64url") { str = str.replace(/-/g, "+").replace(/_/g, "/"); while (str.length % 4) { str += "="; } return new Uint8Array(bufferFromBase64(str)); } else { throw new Error(`Unsupported encoding "${encoding}"`); } } /** * Convert a Uint8Array to a string with the given encoding. * * @param {Uint8Array} byteArray - The Uint8Array to convert. * @param {string} [encoding='utf8'] - The desired encoding ('utf8', 'base16', 'base64url'). * @returns {string} - The encoded string. * @throws {Error} - Throws an error if the encoding is unsupported. */ function toString(byteArray, encoding = "utf8") { switch (encoding) { case "utf8": return decodeUTF8(byteArray); case "base16": return toBase16(byteArray); case "base64url": return toBase64Url(byteArray); default: throw new Error(`Unsupported encoding "${encoding}"`); } } /** * Decode a Uint8Array as a UTF-8 string. * * @param {Uint8Array} byteArray * @returns {string} */ function decodeUTF8(byteArray) { return new TextDecoder().decode(byteArray); } /** * Convert a Uint8Array to a base16 (hex) encoded string. * * @param {Uint8Array} byteArray * @returns {string} */ function toBase16(byteArray) { return Array.from(byteArray) .map((byte) => byte.toString(16).padStart(2, "0")) .join(""); } /** * Convert a Uint8Array to a base64url encoded string. * * @param {Uint8Array} byteArray * @returns {string} */ function toBase64Url(byteArray) { let uint8Array = new Uint8Array(byteArray); let binaryString = ""; for (let i = 0; i < uint8Array.length; i++) { binaryString += String.fromCharCode(uint8Array[i]); } // Encode to base64 let base64 = btoa(binaryString); return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, ""); } const u8a = { toString, fromString }; function sha256(payload) { const data = typeof payload === "string" ? u8a.fromString(payload) : payload; return nobleHashes.sha256(data); } async function accessToken(identifier) { const did = identifier["did"]; const privateKeyHex = identifier["keys"][0]["privateKeyHex"]; const signer = await SimpleSigner(privateKeyHex); const nowEpoch = Math.floor(Date.now() / 1000); const endEpoch = nowEpoch + 60; // add one minute const tokenPayload = { exp: endEpoch, iat: nowEpoch, iss: did }; const alg = undefined; // defaults to 'ES256K', more standardized but harder to verify vs ES256K-R const jwt = await createJWT(tokenPayload, { alg, issuer: did, signer, }); console.error(jwt); return jwt; } async function createJWT(payload, options, header = {}) { const { issuer, signer, alg, expiresIn, canonicalize } = options; if (!signer) throw new Error( "missing_signer: No Signer functionality has been configured", ); if (!issuer) throw new Error("missing_issuer: No issuing DID has been configured"); if (!header.typ) header.typ = "JWT"; if (!header.alg) header.alg = alg; const timestamps = { iat: Math.floor(Date.now() / 1000), exp: undefined, }; if (expiresIn) { if (typeof expiresIn === "number") { timestamps.exp = (payload.nbf || timestamps.iat) + Math.floor(expiresIn); } else { throw new Error("invalid_argument: JWT expiresIn is not a number"); } } const fullPayload = { ...timestamps, ...payload, iss: issuer }; return createJWS(fullPayload, signer, header, { canonicalize }); } const defaultAlg = "ES256K"; async function createJWS(payload, signer, header = {}, options = {}) { if (!header.alg) header.alg = defaultAlg; const encodedPayload = typeof payload === "string" ? payload : encodeSection(payload, options.canonicalize); const signingInput = [ encodeSection(header, options.canonicalize), encodedPayload, ].join("."); const jwtSigner = ES256KSignerAlg(false); const signature = await jwtSigner(signingInput, signer); // JWS Compact Serialization // https://www.rfc-editor.org/rfc/rfc7515#section-7.1 return [signingInput, signature].join("."); } function canonicalizeData(object) { if (typeof object === "number" && isNaN(object)) { throw new Error("NaN is not allowed"); } if (typeof object === "number" && !isFinite(object)) { throw new Error("Infinity is not allowed"); } if (object === null || typeof object !== "object") { return JSON.stringify(object); } if (object.toJSON instanceof Function) { return serialize(object.toJSON()); } if (Array.isArray(object)) { const values = object.reduce((t, cv, ci) => { const comma = ci === 0 ? "" : ","; const value = cv === undefined || typeof cv === "symbol" ? null : cv; return `${t}${comma}${serialize(value)}`; }, ""); return `[${values}]`; } const values = Object.keys(object) .sort() .reduce((t, cv) => { if (object[cv] === undefined || typeof object[cv] === "symbol") { return t; } const comma = t.length === 0 ? "" : ","; return `${t}${comma}${serialize(cv)}:${serialize(object[cv])}`; }, ""); return `{${values}}`; } function encodeSection(data, shouldCanonicalize = false) { if (shouldCanonicalize) { return encodeBase64url(canonicalizeData(data)); } else { return encodeBase64url(JSON.stringify(data)); } } function encodeBase64url(s) { return bytesToBase64url(u8a.fromString(s)); } function instanceOfEcdsaSignature(object) { return typeof object === "object" && "r" in object && "s" in object; } function ES256KSignerAlg(recoverable) { return async function sign(payload, signer) { const signature = await signer(payload); if (instanceOfEcdsaSignature(signature)) { return toJose(signature, recoverable); } else { if ( recoverable && typeof fromJose(signature).recoveryParam === "undefined" ) { throw new Error( `not_supported: ES256K-R not supported when signer doesn't provide a recovery param`, ); } return signature; } }; } function leftpad(data, size = 64) { if (data.length === size) return data; return "0".repeat(size - data.length) + data; } async function SimpleSigner(hexPrivateKey) { const signer = await ES256KSigner(hexToBytes(hexPrivateKey), true); return async (data) => { const signature = await signer(data); return fromJose(signature); }; } function hexToBytes(s, minLength) { let input = s.startsWith("0x") ? s.substring(2) : s; if (input.length % 2 !== 0) { input = `0${input}`; } if (minLength) { const paddedLength = Math.max(input.length, minLength * 2); input = input.padStart(paddedLength, "00"); } return u8a.fromString(input.toLowerCase(), "base16"); } function ES256KSigner(privateKey, recoverable = false) { const privateKeyBytes = privateKey; if (privateKeyBytes.length !== 32) { throw new Error( `bad_key: Invalid private key format. Expecting 32 bytes, but got ${privateKeyBytes.length}`, ); } return async function (data) { const signature = nobleCurves.secp256k1.sign(sha256(data), privateKeyBytes); console.error(signature); return toJose( { r: leftpad(signature.r.toString(16)), s: leftpad(signature.s.toString(16)), recoveryParam: signature.recovery, }, recoverable, ); }; } function toJose(signature, recoverable) { const { r, s, recoveryParam } = signature; const jose = new Uint8Array(recoverable ? 65 : 64); jose.set(u8a.fromString(r, "base16"), 0); jose.set(u8a.fromString(s, "base16"), 32); if (recoverable) { if (typeof recoveryParam === "undefined") { throw new Error("Signer did not return a recoveryParam"); } jose[64] = recoveryParam; } return bytesToBase64url(jose); } function bytesToBase64url(b) { return u8a.toString(b, "base64url"); } function base64ToBytes(s) { const inputBase64Url = s .replace(/\+/g, "-") .replace(/\//g, "_") .replace(/=/g, ""); return u8a.fromString(inputBase64Url, "base64url"); } function bytesToHex(b) { return u8a.toString(b, "base16"); } function fromJose(signature) { const signatureBytes = base64ToBytes(signature); if (signatureBytes.length < 64 || signatureBytes.length > 65) { throw new TypeError( `Wrong size for signature. Expected 64 or 65 bytes, but got ${signatureBytes.length}`, ); } const r = bytesToHex(signatureBytes.slice(0, 32)); const s = bytesToHex(signatureBytes.slice(32, 64)); const recoveryParam = signatureBytes.length === 65 ? signatureBytes[64] : undefined; return { r, s, recoveryParam }; } function validateBase64(s) { if ( !/^(?:[A-Za-z0-9+\/]{2}[A-Za-z0-9+\/]{2})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$/.test( s, ) ) { throw new TypeError("invalid encoding"); } } function decodeBase64(s) { validateBase64(s); var i, d = atob(s), b = new Uint8Array(d.length); for (i = 0; i < d.length; i++) b[i] = d.charCodeAt(i); return b; } async function getSettingById(id) { return new Promise((resolve, reject) => { let openRequest = indexedDB.open("TimeSafari"); openRequest.onupgradeneeded = (event) => { // Handle database setup if necessary let db = event.target.result; if (!db.objectStoreNames.contains("settings")) { db.createObjectStore("settings", { keyPath: "id" }); } }; openRequest.onsuccess = (event) => { let db = event.target.result; let transaction = db.transaction("settings", "readonly"); let objectStore = transaction.objectStore("settings"); let getRequest = objectStore.get(id); getRequest.onsuccess = () => resolve(getRequest.result); getRequest.onerror = () => reject(getRequest.error); }; openRequest.onerror = () => reject(openRequest.error); }); } async function setMostRecentNotified(id) { return new Promise((resolve, reject) => { const dbName = "TimeSafari"; const storeName = "settings"; const key = 1; const propertyToUpdate = "lastNotifiedClaimId"; const newValue = id; let request = indexedDB.open(dbName); request.onerror = function(event) { console.error("Database error: " + event.target.errorCode); }; request.onsuccess = function(event) { let db = event.target.result; let transaction = db.transaction(storeName, "readwrite"); let store = transaction.objectStore(storeName); let getRequest = store.get(key); getRequest.onsuccess = function(event) { let data = event.target.result; // Only update if the object exists if (data) { // Update the specific property data[propertyToUpdate] = newValue; // Put the updated object back into the database let putRequest = store.put(data); putRequest.onsuccess = function() { console.error("Record updated successfully"); }; putRequest.onerror = function(event) { console.error("Error updating record: " + event.target.errorCode); }; } else { console.error("Record not found"); } }; getRequest.onerror = function(event) { console.error("Error fetching record: " + event.target.errorCode); }; transaction.oncomplete = function() { db.close(); }; }; request.onupgradeneeded = function(event) { let db = event.target.result; if (!db.objectStoreNames.contains(storeName)) { db.createObjectStore(storeName); } }; }); } async function fetchAllAccounts() { return new Promise((resolve, reject) => { let openRequest = indexedDB.open("TimeSafariAccounts"); openRequest.onupgradeneeded = function (event) { let db = event.target.result; if (!db.objectStoreNames.contains("accounts")) { db.createObjectStore("accounts", { keyPath: "id" }); } }; openRequest.onsuccess = function (event) { let db = event.target.result; let transaction = db.transaction("accounts", "readonly"); let objectStore = transaction.objectStore("accounts"); let getAllRequest = objectStore.getAll(); getAllRequest.onsuccess = function () { resolve(getAllRequest.result); }; getAllRequest.onerror = function () { reject(getAllRequest.error); }; }; openRequest.onerror = function () { reject(openRequest.error); }; }); } async function getNotificationCount() { let secret = null; let accounts = []; let result = null; if ("secret" in self) { secret = self.secret; const secretUint8Array = self.decodeBase64(secret); const settings = await getSettingById(1); const activeDid = settings["activeDid"]; accounts = await fetchAllAccounts(); let did = null; for (var i = 0; i < accounts.length; i++) { let account = accounts[i]; let did = account["did"]; if (did == activeDid) { let publicKeyHex = account["publicKeyHex"]; let identity = account["identity"]; const messageWithNonceAsUint8Array = self.decodeBase64(identity); const nonce = messageWithNonceAsUint8Array.slice(0, 24); const message = messageWithNonceAsUint8Array.slice(24, identity.length); const decoder = new TextDecoder("utf-8"); const decrypted = self.secretbox.open(message, nonce, secretUint8Array); const msg = decoder.decode(decrypted); const identifier = JSON.parse(JSON.parse(msg)); console.log(identifier); const headers = { "Content-Type": "application/json", }; headers["Authorization"] = "Bearer " + (await accessToken(identifier)); let response = await fetch( "https://test-api.endorser.ch/api/v2/report/claims", { method: "GET", headers: headers, }, ); console.error(did, response.status); const claims = await response.json(); // formulate a message back for notifications let lastNotifiedClaimId = null; if ('lastNotifiedClaimId' in settings) { lastNotifiedClaimId = settings['lastNotifiedClaimId']; } let newClaims = 0; // search for id recent notified -- if it exists if not return everything count for (var i=0; i< response.json()['data'].length; i++) { let claim = response.json()['data']; if (claim['id'] == lastNotifiedClaimId) { break; } newClaims++; } // make the notification message here // first claim is the most recent (?) const most_recent_notified = claims[0]['id']; await setMostRecentNotified(most_recent_notified); break; } } return result; } } self.getNotificationCount = getNotificationCount; self.decodeBase64 = decodeBase64;