feat(frontend): wire frontend to backend pow API

src/frontend/src/lib/api/backend.api.ts

@@ -1,5 +1,6 @@
 import type {
 	AllowSigningResponse,
+	CreateChallengeResponse,
 	CustomToken,
 	PendingTransaction,
 	SelectedUtxosFeeResponse,
@@ -13,11 +14,9 @@ import type {
 	AddUserCredentialResponse,
 	AddUserHiddenDappIdParams,
 	AllowSigningParams,
-	AllowSigningResult,
 	BtcAddPendingTransactionParams,
 	BtcGetPendingTransactionParams,
 	BtcSelectUserUtxosFeeParams,
-	CreateChallengeResult,
 	GetUserProfileResponse,
 	SaveUserNetworksSettings,
 	SetUserShowTestnetsParams
@@ -143,9 +142,9 @@ export const selectUserUtxosFee = async ({
 
 export const createPowChallenge = async ({
 	identity
-}: CanisterApiFunctionParams): Promise<CreateChallengeResult> => {
-	const { createPowChallengeResult } = await backendCanister({ identity });
-	return createPowChallengeResult();
+}: CanisterApiFunctionParams): Promise<CreateChallengeResponse> => {
+	const { createPowChallenge } = await backendCanister({ identity });
+	return createPowChallenge();
 };
 
 export const allowSigning = async ({
@@ -154,17 +153,7 @@ export const allowSigning = async ({
 }: CanisterApiFunctionParams<AllowSigningParams>): Promise<AllowSigningResponse> => {
 	const { allowSigning } = await backendCanister({ identity });
 
-	return allowSigning(params);
-};
-
-export const allowSigningResult = async ({
-	identity,
-	...params
-}: CanisterApiFunctionParams<AllowSigningParams>): Promise<AllowSigningResult> => {
-	const { allowSigningResult } = await backendCanister({ identity });
-
-	// Conditionally call allowSigning with request or provide default logic
-	return allowSigningResult(params);
+	return allowSigning(params.nonce);
 };
 
 export const addUserHiddenDappId = async ({

src/frontend/src/lib/canisters/backend.canister.ts

@@ -1,6 +1,7 @@
 import type {
 	AllowSigningResponse,
 	_SERVICE as BackendService,
+	CreateChallengeResponse,
 	CustomToken,
 	PendingTransaction,
 	SelectedUtxosFeeResponse,
@@ -13,18 +14,16 @@ import { getAgent } from '$lib/actors/agents.ic';
 import {
 	mapAllowSigningError,
 	mapBtcPendingTransactionError,
-	mapBtcSelectUserUtxosFeeError
+	mapBtcSelectUserUtxosFeeError,
+	mapCreateChallengeError
 } from '$lib/canisters/backend.errors';
 import type {
 	AddUserCredentialParams,
 	AddUserCredentialResponse,
 	AddUserHiddenDappIdParams,
-	AllowSigningParams,
-	AllowSigningResult,
 	BtcAddPendingTransactionParams,
 	BtcGetPendingTransactionParams,
 	BtcSelectUserUtxosFeeParams,
-	CreateChallengeResult,
 	GetUserProfileResponse,
 	SaveUserNetworksSettings,
 	SetUserShowTestnetsParams
@@ -177,27 +176,29 @@ export class BackendCanister extends Canister<BackendService> {
 		throw mapBtcSelectUserUtxosFeeError(response.Err);
 	};
 
-	// directly returning result and not the response
-	// TODO: check if this one is really needed because it may cause duplication of code with `allowSigningResult`
-	allowSigningResult = async ({ request }: AllowSigningParams): Promise<AllowSigningResult> => {
+	allowSigning = async (nonce?: bigint): Promise<AllowSigningResponse> => {
 		const { allow_signing } = this.caller({ certified: true });
-		return await allow_signing(toNullable(request));
-	};
 
-	allowSigning = async ({ request }: AllowSigningParams): Promise<AllowSigningResponse> => {
-		const response = await this.allowSigningResult({ request });
+		const result = await allow_signing(nonce !== undefined ? [{ nonce }] : []);
 
-		if ('Ok' in response) {
-			const { Ok } = response;
+		if ('Ok' in result) {
+			const { Ok } = result;
 			return Ok;
 		}
 
-		throw mapAllowSigningError(response.Err);
+		throw mapAllowSigningError(result.Err);
 	};
 
-	createPowChallengeResult = (): Promise<CreateChallengeResult> => {
+	createPowChallenge = async (): Promise<CreateChallengeResponse> => {
 		const { create_pow_challenge } = this.caller({ certified: true });
-		return create_pow_challenge();
+
+		const result = await create_pow_challenge();
+		if ('Ok' in result) {
+			const { Ok } = result;
+			return Ok;
+		}
+
+		throw mapCreateChallengeError(result.Err);
 	};
 
 	addUserHiddenDappId = async ({

src/frontend/src/lib/canisters/backend.errors.ts

@@ -2,6 +2,7 @@ import type {
 	AllowSigningError,
 	BtcAddPendingTransactionError,
 	ChallengeCompletionError,
+	CreateChallengeError,
 	SelectedUtxosFeeError
 } from '$declarations/backend/backend.did';
 import { CanisterInternalError } from '$lib/canisters/errors';
@@ -54,3 +55,23 @@ export const mapAllowSigningError = (
 
 	return new CanisterInternalError('Unknown AllowSigningError');
 };
+
+export const mapCreateChallengeError = (err: CreateChallengeError): CanisterInternalError => {
+	if ('ChallengeInProgress' in err) {
+		return new CanisterInternalError('Challenge is already in progress.');
+	}
+
+	if ('MissingUserProfile' in err) {
+		return new CanisterInternalError('User profile is missing.');
+	}
+
+	if ('RandomnessError' in err) {
+		return new CanisterInternalError(err.RandomnessError);
+	}
+
+	if ('Other' in err) {
+		return new CanisterInternalError(err.Other);
+	}
+
+	return new CanisterInternalError('Unknown CreateChallengeError');
+};

src/frontend/src/lib/types/api.ts

@@ -1,11 +1,6 @@
 import type {
 	AddUserCredentialError,
-	AllowSigningError,
-	AllowSigningRequest,
-	AllowSigningResponse,
 	BitcoinNetwork,
-	CreateChallengeError,
-	CreateChallengeResponse,
 	CredentialSpec,
 	GetUserProfileError,
 	UserProfile,
@@ -34,9 +29,9 @@ export type AddUserCredentialResponse = { Ok: null } | { Err: AddUserCredentialE
 
 export type GetUserProfileResponse = { Ok: UserProfile } | { Err: GetUserProfileError };
 
-export type AllowSigningResult = { Ok: AllowSigningResponse } | { Err: AllowSigningError };
-
-export type CreateChallengeResult = { Ok: CreateChallengeResponse } | { Err: CreateChallengeError };
+export interface AllowSigningParams {
+	nonce?: bigint;
+}
 
 export interface BtcSelectUserUtxosFeeParams {
 	network: BitcoinNetwork;
@@ -101,7 +96,3 @@ export interface KongSwapParams {
 	sourceToken: Token;
 	payTransactionId?: TxId;
 }
-
-export interface AllowSigningParams {
-	request?: AllowSigningRequest;
-}

src/frontend/src/tests/lib/canisters/backend.canister.spec.ts

@@ -1,6 +1,5 @@
 import type {
 	_SERVICE as BackendService,
-	CreateChallengeResponse,
 	CustomToken,
 	IcrcToken,
 	Result_2,
@@ -625,7 +624,7 @@ describe('backend.canister', () => {
 				serviceOverride: service
 			});
 
-			const res = await allowSigning({});
+			const res = await allowSigning();
 
 			expect(service.allow_signing).toHaveBeenCalledTimes(1);
 			expect(res).toBeDefined();
@@ -641,7 +640,7 @@ describe('backend.canister', () => {
 				serviceOverride: service
 			});
 
-			const res = allowSigning({});
+			const res = allowSigning();
 
 			await expect(res).rejects.toThrow(mockResponseError);
 		});
@@ -659,9 +658,7 @@ describe('backend.canister', () => {
 				serviceOverride: service
 			});
 
-			await expect(allowSigning({})).rejects.toThrow(
-				mapIcrc2ApproveError(response.Err.ApproveError)
-			);
+			await expect(allowSigning()).rejects.toThrow(mapIcrc2ApproveError(response.Err.ApproveError));
 		});
 
 		it('should throw a CanisterInternalError if FailedToContactCyclesLedger error is returned', async () => {
@@ -673,7 +670,7 @@ describe('backend.canister', () => {
 				serviceOverride: service
 			});
 
-			await expect(allowSigning({})).rejects.toThrow(
+			await expect(allowSigning()).rejects.toThrow(
 				new CanisterInternalError('The Cycles Ledger cannot be contacted.')
 			);
 		});
@@ -688,7 +685,7 @@ describe('backend.canister', () => {
 				serviceOverride: service
 			});
 
-			await expect(allowSigning({})).rejects.toThrow(new CanisterInternalError(errorMsg));
+			await expect(allowSigning()).rejects.toThrow(new CanisterInternalError(errorMsg));
 		});
 
 		it('should throw an unknown AllowSigningError if unrecognized error is returned', async () => {
@@ -700,120 +697,80 @@ describe('backend.canister', () => {
 				serviceOverride: service
 			});
 
-			await expect(allowSigning({})).rejects.toThrow(
+			await expect(allowSigning()).rejects.toThrow(
 				new CanisterInternalError('Unknown AllowSigningError')
 			);
 		});
 	});
 
 	describe('createPowChallenge', () => {
-		const mockPowChallengeSuccess: CreateChallengeResponse = {
+		const mockPowChallengeSuccess = {
 			start_timestamp_ms: 1_644_001_000_000n,
 			expiry_timestamp_ms: 1_644_001_001_200n,
 			difficulty: 1_000_000
 		};
 
+		let backendCanister: BackendCanister;
+
+		beforeEach(async () => {
+			backendCanister = await createBackendCanister({ serviceOverride: service });
+		});
+
 		it('should successfully create a PoW challenge (Ok case)', async () => {
 			service.create_pow_challenge.mockResolvedValue({ Ok: mockPowChallengeSuccess });
 
-			const backendCanister = await createBackendCanister({ serviceOverride: service });
-
-			const result = await backendCanister.createPowChallengeResult();
+			const result = await backendCanister.createPowChallenge();
 
 			expect(service.create_pow_challenge).toHaveBeenCalled();
-
-			if ('Ok' in result) {
-				expect(result.Ok).toEqual(mockPowChallengeSuccess);
-			} else {
-				throw new Error(`Unexpected error: ${JSON.stringify(result.Err)}`);
-			}
+			expect(result).toEqual(mockPowChallengeSuccess);
 		});
 
-		test('should handle challenge already in progress error', async () => {
+		it('should handle challenge already in progress error', async () => {
 			service.create_pow_challenge.mockResolvedValue({
 				Err: { ChallengeInProgress: null }
 			});
 
-			const backendCanister = await createBackendCanister({ serviceOverride: service });
-
-			const result = await backendCanister.createPowChallengeResult();
+			await expect(backendCanister.createPowChallenge()).rejects.toThrowError(
+				'Challenge is already in progress.'
+			);
 
-			expect(result).toEqual({ Err: { ChallengeInProgress: null } });
+			expect(service.create_pow_challenge).toHaveBeenCalled();
 		});
 
-		test('should handle randomness generation error', async () => {
+		it('should handle randomness generation error', async () => {
 			service.create_pow_challenge.mockResolvedValue({
 				Err: { RandomnessError: 'Failed to generate randomness' }
 			});
 
-			const backendCanister = await createBackendCanister({ serviceOverride: service });
-
-			const result = await backendCanister.createPowChallengeResult();
+			await expect(backendCanister.createPowChallenge()).rejects.toThrowError(
+				'Failed to generate randomness'
+			);
 
-			expect(result).toEqual({
-				Err: { RandomnessError: 'Failed to generate randomness' }
-			});
+			expect(service.create_pow_challenge).toHaveBeenCalled();
 		});
 
 		it('should handle missing user profile error', async () => {
-			service.create_pow_challenge.mockResolvedValue({ Err: { MissingUserProfile: null } });
-
-			const backendCanister = await createBackendCanister({ serviceOverride: service });
-
-			const result = await backendCanister.createPowChallengeResult();
-
-			expect(result).toEqual({ Err: { MissingUserProfile: null } });
-
-			expect(service.create_pow_challenge).toHaveBeenCalledTimes(1);
-		});
-
-		it('should handle unexpected errors in result', async () => {
 			service.create_pow_challenge.mockResolvedValue({
-				Err: { Other: 'Unexpected error occurred.' }
+				Err: { MissingUserProfile: null }
 			});
 
-			const backendCanister = await createBackendCanister({ serviceOverride: service });
-
-			const result = await backendCanister.createPowChallengeResult();
-
-			expect(result).toEqual({ Err: { Other: 'Unexpected error occurred.' } });
-
-			expect(service.create_pow_challenge).toHaveBeenCalledTimes(1);
-		});
-	});
-
-	describe('addUserHiddenDappId', () => {
-		it('should add user hidden dapp id', async () => {
-			const response = { Ok: null };
-
-			service.add_user_hidden_dapp_id.mockResolvedValue(response);
-
-			const { addUserHiddenDappId } = await createBackendCanister({
-				serviceOverride: service
-			});
-
-			const res = await addUserHiddenDappId({ dappId: 'test-dapp-id' });
+			await expect(backendCanister.createPowChallenge()).rejects.toThrowError(
+				'User profile is missing.'
+			);
 
-			expect(service.add_user_hidden_dapp_id).toHaveBeenCalledWith({
-				dapp_id: 'test-dapp-id',
-				current_user_version: []
-			});
-			expect(res).toBeUndefined();
+			expect(service.create_pow_challenge).toHaveBeenCalled();
 		});
 
-		it('should throw an error if add_user_hidden_dapp_id throws', async () => {
-			service.add_user_hidden_dapp_id.mockImplementation(async () => {
-				await Promise.resolve();
-				throw mockResponseError;
-			});
-
-			const { addUserHiddenDappId } = await createBackendCanister({
-				serviceOverride: service
+		it('should handle other unexpected errors', async () => {
+			service.create_pow_challenge.mockResolvedValue({
+				Err: { Other: 'Unexpected error occurred.' }
 			});
 
-			const res = addUserHiddenDappId({ dappId: 'test-dapp-id' });
+			await expect(backendCanister.createPowChallenge()).rejects.toThrowError(
+				'Unexpected error occurred.'
+			);
 
-			await expect(res).rejects.toThrow(mockResponseError);
+			expect(service.create_pow_challenge).toHaveBeenCalled();
 		});
 	});