feat(frontend): implement pow worker and service layer

src/frontend/src/env/pow.env.ts

@@ -1,3 +1,5 @@
 import { parseBoolEnvVar } from '$lib/utils/env.utils';
 
 export const POW_FEATURE_ENABLED = parseBoolEnvVar(import.meta.env.VITE_POW_FEATURE_ENABLED);
+
+export const POW_CHALLENGE_INTERVAL_MILLIS = 120000;

src/frontend/src/icp/schedulers/pow-protection.scheduler.ts

@@ -0,0 +1,109 @@
+import type { CreateChallengeResponse } from '$declarations/backend/backend.did';
+import { POW_CHALLENGE_INTERVAL_MILLIS } from '$env/pow.env';
+import { allowSigning, createPowChallenge } from '$lib/api/backend.api';
+import { SchedulerTimer, type Scheduler, type SchedulerJobData } from '$lib/schedulers/scheduler';
+import type { PostMessageDataRequest } from '$lib/types/post-message';
+import { hashText } from '@dfinity/utils';
+
+// TODO: add tests for POW worker/scheduler
+export class PowProtectionScheduler implements Scheduler<PostMessageDataRequest> {
+	private timer = new SchedulerTimer('syncPowProtectionStatus');
+
+	stop() {
+		this.timer.stop();
+	}
+
+	async start(data: PostMessageDataRequest | undefined) {
+		await this.timer.start<PostMessageDataRequest>({
+			interval: POW_CHALLENGE_INTERVAL_MILLIS,
+			job: this.requestSignerCycles,
+			data
+		});
+	}
+
+	async trigger(data: PostMessageDataRequest | undefined) {
+		await this.timer.trigger<PostMessageDataRequest>({
+			job: this.requestSignerCycles,
+			data
+		});
+	}
+
+	/**
+	 * Solves a Proof-of-Work (PoW) challenge by finding a `nonce` that satisfies the given difficulty level
+	 *
+	 * @param timestamp - A unique `bigint` value for the challenge.
+	 * @param difficulty - A positive number influencing the challenge's complexity.
+	 * @returns The `nonce` that solves the challenge as a `bigint`.
+	 * @throws An error if `difficulty` is not greater than zero.
+	 */
+	private solvePowChallenge = async ({
+		timestamp,
+		difficulty
+	}: {
+		timestamp: bigint;
+		difficulty: number;
+	}): Promise<bigint> => {
+		if (difficulty <= 0) {
+			throw new Error('Difficulty must be greater than zero');
+		}
+
+		// This is the value we need to find to solve the challenge (changed to bigint)
+		let nonce = 0n;
+
+		// Target is proportional to 1/difficulty (converted target to bigint)
+		const target = BigInt(Math.floor(0xffffffff / difficulty));
+
+		// Continuously try different nonce values until the challenge is solved
+		// TODO: Check if it is worth introducing a max number of iterations
+		while (true) {
+			// Concatenate the timestamp and nonce as the challenge string
+			const challengeStr = `${timestamp}.${nonce}`;
+
+			// Hash the string into a hex representation
+			const hashHex = await hashText(challengeStr);
+
+			// Extract the first 4 bytes of the hash as a number (prefix converted to bigint)
+			const prefix = BigInt(parseInt(hashHex.slice(0, 8), 16));
+
+			// If the prefix satisfies the difficulty target, stop the loop
+			if (prefix <= target) {
+				break;
+			}
+
+			// Otherwise, increment the nonce (bigint increment) and try again
+			nonce++;
+		}
+
+		// Return the nonce that solves the challenge (bigint type)
+		return nonce;
+	};
+
+	/**
+	 * Initiates the Proof-of-Work (PoW) and signing request cycles.
+	 *
+	 * This method:
+	 * 1. Creates a PoW challenge using the given identity.
+	 * 2. Solves the challenge to find a valid `nonce`.
+	 * 3. Uses the solved `nonce` to request signing permission.
+	 *
+	 * @param identity - The user's identity for the operation.
+	 * @throws Errors if any step in the sequence fails.
+	 */
+	private requestSignerCycles = async ({ identity }: SchedulerJobData<PostMessageDataRequest>) => {
+		// Step 1: Request creation of the Proof-of-Work (PoW) challenge (throws when unsuccessful).
+		const { start_timestamp_ms: timestamp, difficulty }: CreateChallengeResponse =
+			await createPowChallenge({ identity });
+
+		// Step 2: Solve the PoW challenge.
+		const nonce = await this.solvePowChallenge({
+			timestamp,
+			difficulty
+		});
+
+		// Step 3: Request allowance for signing operations with solved nonce.
+		await allowSigning({
+			identity,
+			request: { nonce }
+		});
+	};
+}

src/frontend/src/icp/services/worker.pow-protection.services.ts

@@ -0,0 +1,32 @@
+import type {
+	PowProtectorWorker,
+	PowProtectorWorkerInitResult
+} from '$icp/types/pow-protector-listener';
+import type { PostMessage, PostMessageDataResponse } from '$lib/types/post-message';
+
+// TODO: add tests for POW worker/scheduler
+export const initPowProtectorWorker: PowProtectorWorker =
+	async (): Promise<PowProtectorWorkerInitResult> => {
+		const PowWorker = await import('$lib/workers/workers?worker');
+		const worker: Worker = new PowWorker.default();
+
+		worker.onmessage = ({ data: _data }: MessageEvent<PostMessage<PostMessageDataResponse>>) => {};
+
+		return {
+			start: () => {
+				worker.postMessage({
+					msg: 'startPowProtectionTimer'
+				});
+			},
+			stop: () => {
+				worker.postMessage({
+					msg: 'stopPowProtectionTimer'
+				});
+			},
+			trigger: () => {
+				worker.postMessage({
+					msg: 'triggerPowProtectionTimer'
+				});
+			}
+		};
+	};

src/frontend/src/icp/types/pow-protector-listener.ts

@@ -0,0 +1,7 @@
+export interface PowProtectorWorkerInitResult {
+	start: () => void;
+	stop: () => void;
+	trigger: () => void;
+}
+
+export type PowProtectorWorker = () => Promise<PowProtectorWorkerInitResult>;

src/frontend/src/icp/workers/pow-protection.worker.ts

@@ -0,0 +1,22 @@
+import { PowProtectionScheduler } from '$icp/schedulers/pow-protection.scheduler';
+import type { PostMessage, PostMessageDataRequest } from '$lib/types/post-message';
+
+const scheduler = new PowProtectionScheduler();
+
+export const onPowProtectionMessage = async ({
+	data: dataMsg
+}: MessageEvent<PostMessage<PostMessageDataRequest>>) => {
+	const { msg, data } = dataMsg;
+
+	switch (msg) {
+		case 'stopPowProtectionTimer':
+			scheduler.stop();
+			return;
+		case 'startPowProtectionTimer':
+			await scheduler.start(data);
+			return;
+		case 'triggerPowProtectionTimer':
+			await scheduler.trigger(data);
+			return;
+	}
+};

src/frontend/src/lib/schema/post-message.schema.ts

@@ -27,6 +27,9 @@ export const PostMessageRequestSchema = z.enum([
 	'stopCodeTimer',
 	'startExchangeTimer',
 	'stopExchangeTimer',
+	'startPowProtectionTimer',
+	'triggerPowProtectionTimer',
+	'stopPowProtectionTimer',
 	'stopIcpWalletTimer',
 	'startIcpWalletTimer',
 	'triggerIcpWalletTimer',
@@ -104,7 +107,8 @@ export const PostMessageResponseStatusSchema = z.enum([
 	'syncSolWalletStatus',
 	'syncBtcStatusesStatus',
 	'syncCkMinterInfoStatus',
-	'syncCkBTCUpdateBalanceStatus'
+	'syncCkBTCUpdateBalanceStatus',
+	'syncPowProtectionStatus'
 ]);
 
 export const PostMessageResponseSchema = z.enum([
@@ -129,6 +133,7 @@ export const PostMessageResponseSchema = z.enum([
 	'syncBtcPendingUtxos',
 	'syncCkBTCUpdateOk',
 	'syncBtcAddress',
+	'syncPowProtection',
 	...PostMessageResponseStatusSchema.options
 ]);
 

src/frontend/src/lib/workers/workers.ts

@@ -5,6 +5,7 @@ import { onCkBtcUpdateBalanceMessage } from '$icp/workers/ckbtc-update-balance.w
 import { onCkEthMinterInfoMessage } from '$icp/workers/cketh-minter-info.worker';
 import { onIcpWalletMessage } from '$icp/workers/icp-wallet.worker';
 import { onIcrcWalletMessage } from '$icp/workers/icrc-wallet.worker';
+import { onPowProtectionMessage } from '$icp/workers/pow-protection.worker';
 import type { PostMessage, PostMessageDataRequest } from '$lib/types/post-message';
 import { onAuthMessage } from '$lib/workers/auth.worker';
 import { onExchangeMessage } from '$lib/workers/exchange.worker';
@@ -21,6 +22,7 @@ onmessage = async (msg: MessageEvent<PostMessage<PostMessageDataRequest>>) => {
 		onCkEthMinterInfoMessage(msg),
 		onIcpWalletMessage(msg),
 		onIcrcWalletMessage(msg),
-		onSolWalletMessage(msg)
+		onSolWalletMessage(msg),
+		onPowProtectionMessage(msg)
 	]);
 };