Fixes for API endpoints

demos/provider-mock/src/api.ts

@@ -30,14 +30,14 @@ export function prosopoRouter(): Router {
      * @param {string} userAccount - Dapp User id
      * @param {string} commitmentId - The captcha solution to look up
      */
-    router.post(ApiPaths.VerifyCaptchaSolutionDapp, async (req, res, next) => {
+    router.post(ApiPaths.VerifyImageCaptchaSolutionDapp, async (req, res, next) => {
         let body: VerifySolutionBodyTypeOutput
         try {
             body = VerifySolutionBody.parse(req.body)
         } catch (err) {
             return next(
                 new ProsopoApiError('CAPTCHA.PARSE_ERROR', {
-                    context: { error: err, errorCode: 400 },
+                    context: { error: err, code: 400 },
                     logLevel: 'info',
                 })
             )
@@ -69,7 +69,7 @@ export function prosopoRouter(): Router {
                 verified: false,
             })
         } catch (err) {
-            return next(new ProsopoApiError('API.UNKNOWN', { context: { error: err, errorCode: 500 } }))
+            return next(new ProsopoApiError('API.UNKNOWN', { context: { error: err, code: 500 } }))
         }
     })
 

packages/api/src/api/ProviderApi.ts

@@ -52,9 +52,9 @@ export default class ProviderApi extends HttpClientBase implements ProviderApi {
     public getCaptchaChallenge(userAccount: AccountId, randomProvider: RandomProvider): Promise<CaptchaResponseBody> {
         const { provider, blockNumber } = randomProvider
         const dappAccount = this.account
-        const url = `${ApiPaths.GetCaptchaChallenge}/${provider.datasetId}/${userAccount}/${dappAccount}/${blockNumber
-            .toString()
-            .replace(/,/g, '')}`
+        const url = `${ApiPaths.GetImageCaptchaChallenge}/${
+            provider.datasetId
+        }/${userAccount}/${dappAccount}/${blockNumber.toString().replace(/,/g, '')}`
         return this.fetch(url)
     }
 
@@ -73,7 +73,7 @@ export default class ProviderApi extends HttpClientBase implements ProviderApi {
             salt,
             signature,
         })
-        return this.post(ApiPaths.SubmitCaptchaSolution, captchaSolutionBody)
+        return this.post(ApiPaths.SubmitImageCaptchaSolution, captchaSolutionBody)
     }
 
     public verifyDappUser(
@@ -89,7 +89,7 @@ export default class ProviderApi extends HttpClientBase implements ProviderApi {
             payload[ApiParams.maxVerifiedTime] = maxVerifiedTime
         }
 
-        return this.post(ApiPaths.VerifyCaptchaSolutionDapp, payload)
+        return this.post(ApiPaths.VerifyImageCaptchaSolutionDapp, payload)
     }
 
     public verifyUser(
@@ -103,7 +103,7 @@ export default class ProviderApi extends HttpClientBase implements ProviderApi {
             ...(maxVerifiedTime && { [ApiParams.maxVerifiedTime]: maxVerifiedTime }),
         }
 
-        return this.post(ApiPaths.VerifyCaptchaSolutionUser, payload)
+        return this.post(ApiPaths.VerifyImageCaptchaSolutionUser, payload)
     }
 
     public getPowCaptchaChallenge(user: AccountId, dapp: AccountId): Promise<GetPowCaptchaResponse> {
@@ -156,9 +156,9 @@ export default class ProviderApi extends HttpClientBase implements ProviderApi {
     ): Promise<VerificationResponse> {
         const body: ServerPowCaptchaVerifyRequestBodyType = {
             [ApiParams.token]: token,
-            [ApiParams.dappUserSignature]: signatureHex,
+            [ApiParams.dappSignature]: signatureHex,
             [ApiParams.verifiedTimeout]: recencyLimit,
         }
-        return this.post(ApiPaths.ServerPowCaptchaVerify, body)
+        return this.post(ApiPaths.VerifyPowCaptchaSolution, body)
     }
 }

packages/common/src/error.ts

@@ -128,9 +128,9 @@ export class ProsopoApiError extends ProsopoBaseError<ApiContextParams> {
 
     constructor(error: Error | TranslationKey, options?: BaseErrorOptions<ApiContextParams>) {
         const errorName = options?.name || 'ProsopoApiError'
-        const errorCode = options?.context?.code || 500
-        options = { ...options, name: errorName, context: { ...options?.context, errorCode } }
+        const code = options?.context?.code || 500
+        options = { ...options, name: errorName, context: { ...options?.context, code } }
         super(error, options)
-        this.code = errorCode
+        this.code = code
     }
 }

packages/contract/src/accounts/mnemonic.ts

@@ -34,7 +34,7 @@ export async function generateMnemonic(keyring?: Keyring, pairType?: KeypairType
  * @param keyring
  * @param pairType
  */
-export async function generateSecret(keyring?: Keyring, pairType?: KeypairType): Promise<[Uint8Array, string]> {
+export async function generateMiniSecret(keyring?: Keyring, pairType?: KeypairType): Promise<[Uint8Array, string]> {
     const [mnemonic, address] = await generateMnemonic(keyring, pairType)
     return [mnemonicToMiniSecret(mnemonic), address]
 }

packages/provider/src/api/captcha.ts

@@ -53,7 +53,7 @@ export function prosopoRouter(env: ProviderEnvironment): Router {
      * @return {Captcha} - The Captcha data
      */
     router.get(
-        `${ApiPaths.GetCaptchaChallenge}/:${ApiParams.datasetId}/:${ApiParams.user}/:${ApiParams.dapp}/:${ApiParams.blockNumber}`,
+        `${ApiPaths.GetImageCaptchaChallenge}/:${ApiParams.datasetId}/:${ApiParams.user}/:${ApiParams.dapp}/:${ApiParams.blockNumber}`,
         async (req, res, next) => {
             try {
                 const { blockNumber, datasetId, user, dapp } = CaptchaRequestBody.parse(req.params)
@@ -95,7 +95,7 @@ export function prosopoRouter(env: ProviderEnvironment): Router {
      * @param {Captcha[]} captchas - The Captcha solutions
      * @return {DappUserSolutionResult} - The Captcha solution result and proof
      */
-    router.post(ApiPaths.SubmitCaptchaSolution, async (req, res, next) => {
+    router.post(ApiPaths.SubmitImageCaptchaSolution, async (req, res, next) => {
         let parsed: CaptchaSolutionBodyType
         try {
             parsed = CaptchaSolutionBody.parse(req.body)

packages/provider/src/api/errorHandler.ts

@@ -27,11 +27,7 @@ export const handleErrors = (
     while (err instanceof ProsopoBaseError && err.context && err.context.error) {
         err = err.context.error
     }
-    let message = err.message
+    const message = err.message
 
-    if (typeof message !== 'string') {
-        message = JSON.stringify(message)
-    }
-
-    response.writeHead(code, message, { 'content-type': 'application/json' }).end()
+    response.writeHead(code, JSON.stringify(message), { 'content-type': 'application/json' }).end()
 }

packages/provider/src/api/verify.ts

@@ -46,7 +46,7 @@ export function prosopoVerifyRouter(env: ProviderEnvironment): Router {
      * @param {NextFunction} next - Express next function.
      * @param {boolean} isDapp - Indicates whether the verification is for a dapp (true) or user (false).
      */
-    async function verifySolution(res: Response, req: Request, next: NextFunction, isDapp: boolean) {
+    async function verifyImageSolution(res: Response, req: Request, next: NextFunction, isDapp: boolean) {
         const parsed = VerifySolutionBody.parse(req.body)
         try {
             const { dappUserSignature, token } = parsed
@@ -120,9 +120,9 @@ export function prosopoVerifyRouter(env: ProviderEnvironment): Router {
      * @param {string} commitmentId - The captcha solution to look up
      * @param {number} maxVerifiedTime - The maximum time in milliseconds since the blockNumber
      */
-    router.post(ApiPaths.VerifyCaptchaSolutionDapp, async (req, res, next) => {
+    router.post(ApiPaths.VerifyImageCaptchaSolutionDapp, async (req, res, next) => {
         try {
-            await verifySolution(res, req, next, true)
+            await verifyImageSolution(res, req, next, true)
         } catch (err) {
             return next(new ProsopoApiError('CAPTCHA.PARSE_ERROR', { context: { code: 400, error: err } }))
         }
@@ -138,9 +138,9 @@ export function prosopoVerifyRouter(env: ProviderEnvironment): Router {
      * @param {string} commitmentId - The captcha solution to look up
      * @param {number} maxVerifiedTime - The maximum time in milliseconds since the blockNumber
      */
-    router.post(ApiPaths.VerifyCaptchaSolutionUser, async (req, res, next) => {
+    router.post(ApiPaths.VerifyImageCaptchaSolutionUser, async (req, res, next) => {
         try {
-            await verifySolution(res, req, next, false)
+            await verifyImageSolution(res, req, next, false)
         } catch (err) {
             return next(new ProsopoApiError('CAPTCHA.PARSE_ERROR', { context: { code: 400, error: err } }))
         }
@@ -152,9 +152,9 @@ export function prosopoVerifyRouter(env: ProviderEnvironment): Router {
      * @param {string} dappAccount - Dapp User id
      * @param {string} challenge - The captcha solution to look up
      */
-    router.post(ApiPaths.ServerPowCaptchaVerify, async (req, res, next) => {
+    router.post(ApiPaths.VerifyPowCaptchaSolution, async (req, res, next) => {
         try {
-            const { token, dappUserSignature, verifiedTimeout } = ServerPowCaptchaVerifyRequestBody.parse(req.body)
+            const { token, dappSignature, verifiedTimeout } = ServerPowCaptchaVerifyRequestBody.parse(req.body)
 
             const { dapp, blockNumber, challenge } = decodeProcaptchaOutput(token)
 
@@ -170,10 +170,15 @@ export function prosopoVerifyRouter(env: ProviderEnvironment): Router {
             const dappPair = env.keyring.addFromAddress(dapp)
 
             // Will throw an error if the signature is invalid
-            verifySignature(dappUserSignature, blockNumber.toString(), dappPair)
-
+            verifySignature(dappSignature, blockNumber.toString(), dappPair)
+            console.log({
+                dapp,
+                blockNumber,
+                challenge,
+                verifiedTimeout,
+            })
             const approved = await tasks.serverVerifyPowCaptchaSolution(dapp, challenge, verifiedTimeout)
-
+            console.log('approved', approved)
             const verificationResponse: VerificationResponse = {
                 status: req.t(approved ? 'API.USER_VERIFIED' : 'API.USER_NOT_VERIFIED'),
                 [ApiParams.verified]: approved,

packages/types/src/api/params.ts

@@ -22,6 +22,7 @@ export enum ApiParams {
     captchas = 'captchas',
     commitmentId = 'commitmentId',
     proof = 'proof',
+    dappSignature = 'dappSignature',
     dappUserSignature = 'dappUserSignature',
     providerUrl = 'providerUrl',
     procaptchaResponse = 'procaptcha-response',

packages/types/src/provider/api.ts

@@ -19,13 +19,13 @@ import { ProcaptchaTokenSpec } from '../procaptcha/index.js'
 import { array, input, number, object, output, string, infer as zInfer } from 'zod'
 
 export enum ApiPaths {
-    GetCaptchaChallenge = '/v1/prosopo/provider/captcha',
+    GetImageCaptchaChallenge = '/v1/prosopo/provider/captcha/image',
     GetPowCaptchaChallenge = '/v1/prosopo/provider/captcha/pow',
-    SubmitCaptchaSolution = '/v1/prosopo/provider/solution',
+    SubmitImageCaptchaSolution = '/v1/prosopo/provider/solution',
     SubmitPowCaptchaSolution = '/v1/prosopo/provider/pow/solution',
-    ServerPowCaptchaVerify = '/v1/prosopo/provider/pow/server-verify',
-    VerifyCaptchaSolutionDapp = '/v1/prosopo/provider/dapp-verify',
-    VerifyCaptchaSolutionUser = '/v1/prosopo/provider/user-verify',
+    VerifyPowCaptchaSolution = '/v1/prosopo/provider/pow/verify',
+    VerifyImageCaptchaSolutionDapp = `/v1/prosopo/provider/image/${ApiParams.dapp}/verify`,
+    VerifyImageCaptchaSolutionUser = `/v1/prosopo/provider/image/${ApiParams.user}/verify`,
     GetProviderStatus = '/v1/prosopo/provider/status',
     GetProviderDetails = '/v1/prosopo/provider/details',
     SubmitUserEvents = '/v1/prosopo/provider/events',
@@ -133,7 +133,7 @@ export interface PowCaptchaSolutionResponse {
  */
 export const ServerPowCaptchaVerifyRequestBody = object({
     [ApiParams.token]: ProcaptchaTokenSpec,
-    [ApiParams.dappUserSignature]: string(),
+    [ApiParams.dappSignature]: string(),
     [ApiParams.verifiedTimeout]: number().optional().default(DEFAULT_POW_CAPTCHA_VERIFIED_TIMEOUT),
 })