@pagopa/io-react-native-wallet 2.5.1 → 3.0.0

package/src/credential/issuance/v1.3.3/03-complete-user-authorization.ts

@@ -0,0 +1,249 @@
+import {
+  AuthorizationErrorShape,
+  AuthorizationResultShape,
+  type AuthorizationResult,
+} from "../../../utils/auth";
+import parseUrl from "parse-url";
+import type { DcqlQuery } from "dcql";
+import {
+  fetchAuthorizationRequest,
+  parseAuthorizeRequest,
+} from "@pagopa/io-wallet-oid4vp";
+import { sendAuthorizationResponseAndExtractCode } from "@pagopa/io-wallet-oid4vci";
+import { parseMrtdChallenge } from "@pagopa/io-wallet-oauth2";
+import { SignJWT, type CryptoContext } from "@pagopa/io-react-native-jwt";
+import { AuthorizationError, AuthorizationIdpError } from "../common/errors";
+import { LogLevel, Logger } from "../../../utils/logging";
+import { RemotePresentation as RemotePresentationFlow } from "../../presentation/v1.3.3";
+import { partialCallbacks } from "../../../utils/callbacks";
+import {
+  IoWalletError,
+  sdkUnexpectedStatusCodeToIssuerError,
+} from "../../../utils/errors";
+import type { IssuanceApi } from "../api";
+import { mapToRequestObject } from "./mappers";
+import type { RemotePresentation } from "../../presentation";
+
+export const continueUserAuthorizationWithMRTDPoPChallenge: IssuanceApi["continueUserAuthorizationWithMRTDPoPChallenge"] =
+  async (authRedirectUrl) => {
+    Logger.log(
+      LogLevel.DEBUG,
+      `The requested credential is a PersonIdentificationData and requires MRTD PoP, starting MRTD PoP validation from auth redirect`
+    );
+    try {
+      const parsedChallenge = parseMrtdChallenge({
+        redirectUrl: authRedirectUrl,
+      });
+      return { challenge_info: parsedChallenge.challengeJwt };
+    } catch (err) {
+      const errorMessage =
+        err instanceof Error ? err.message : "MRTD challenge parsing failed";
+      Logger.log(
+        LogLevel.ERROR,
+        `Error while parsing the authorization response: ${errorMessage}`
+      );
+      throw new AuthorizationError(errorMessage);
+    }
+  };
+
+export const buildAuthorizationUrl: IssuanceApi["buildAuthorizationUrl"] =
+  async (issuerRequestUri, clientId, issuerConf, idpHint) => {
+    const authzRequestEndpoint = issuerConf.authorization_endpoint;
+
+    const params = new URLSearchParams({
+      client_id: clientId,
+      request_uri: issuerRequestUri,
+    });
+
+    if (idpHint) {
+      params.append("idphint", idpHint);
+    }
+
+    const authUrl = `${authzRequestEndpoint}?${params}`;
+
+    return { authUrl };
+  };
+
+export const completeUserAuthorizationWithQueryMode: IssuanceApi["completeUserAuthorizationWithQueryMode"] =
+  async (authRedirectUrl) => {
+    Logger.log(
+      LogLevel.DEBUG,
+      `The requested credential is a PersonIdentificationData, completing the user authorization with query mode`
+    );
+    const query = parseUrl(authRedirectUrl).query;
+
+    return parseAuthorizationResponse(query);
+  };
+
+export const getRequestedCredentialToBePresented: IssuanceApi["getRequestedCredentialToBePresented"] =
+  async (issuerRequestUri, clientId, issuerConf, appFetch = fetch) => {
+    Logger.log(
+      LogLevel.DEBUG,
+      `The requeste credential is not a PersonIdentificationData, requesting the credential to be presented`
+    );
+
+    const authzRequestEndpoint = issuerConf.authorization_endpoint;
+    const params = new URLSearchParams({
+      client_id: clientId,
+      request_uri: issuerRequestUri,
+    });
+
+    Logger.log(
+      LogLevel.DEBUG,
+      `Requesting the request object to ${authzRequestEndpoint}?${params.toString()}`
+    );
+
+    const authRequest = await fetchAuthorizationRequest({
+      authorizeRequestUrl: `${authzRequestEndpoint}?${params.toString()}`,
+      callbacks: {
+        fetch: appFetch,
+      },
+    }).catch(sdkUnexpectedStatusCodeToIssuerError);
+
+    const parsedAuthRequest = await parseAuthorizeRequest({
+      requestObjectJwt: authRequest.requestObjectJwt,
+      callbacks: partialCallbacks,
+    });
+
+    return mapToRequestObject(parsedAuthRequest);
+  };
+
+export const completeUserAuthorizationWithFormPostJwtMode: IssuanceApi["completeUserAuthorizationWithFormPostJwtMode"] =
+  async (
+    requestObject,
+    issuerConfig,
+    pid,
+    { wiaCryptoContext, pidKeyTag, appFetch = fetch }
+  ) => {
+    Logger.log(
+      LogLevel.DEBUG,
+      `The requeste credential is not a PersonIdentificationData, completing the user authorization with form_post.jwt mode`
+    );
+
+    const dcqlQueryResult = await RemotePresentationFlow.evaluateDcqlQuery(
+      requestObject.dcql_query as DcqlQuery,
+      [[pidKeyTag, pid]]
+    );
+
+    const authRequestObject = {
+      nonce: requestObject.nonce,
+      clientId: requestObject.client_id,
+      responseUri: requestObject.response_uri,
+    };
+
+    const remotePresentation =
+      await RemotePresentationFlow.prepareRemotePresentations(
+        dcqlQueryResult,
+        authRequestObject
+      );
+
+    const authzResponsePayload = await createAuthzResponsePayload({
+      state: requestObject.state,
+      remotePresentation,
+      wiaCryptoContext,
+    });
+
+    Logger.log(
+      LogLevel.DEBUG,
+      `Authz response payload: ${authzResponsePayload}`
+    );
+
+    const issuerSigKey = issuerConfig.keys.find((key) => key.use === "sig");
+    if (!issuerSigKey) {
+      const errorMessage = "No signature key found in Issuer Metadata JWKS";
+      Logger.log(LogLevel.ERROR, errorMessage);
+      throw new IoWalletError(errorMessage);
+    }
+
+    return sendAuthorizationResponseAndExtractCode({
+      authorizationResponseJarm: authzResponsePayload,
+      callbacks: {
+        ...partialCallbacks,
+        fetch: appFetch,
+      },
+      iss: requestObject.iss,
+      state: requestObject.state!,
+      presentationResponseUri: requestObject.response_uri,
+      signer: {
+        alg: "ES256",
+        method: "jwk",
+        publicJwk: issuerSigKey,
+      },
+    });
+  };
+
+/**
+ * Parse the authorization response and return the result which contains code, state and iss.
+ * @throws {AuthorizationError} if an error occurs during the parsing process
+ * @throws {AuthorizationIdpError} if an error occurs during the parsing process and the error is related to the IDP
+ * @param authRes the authorization response to be parsed
+ * @returns the authorization result which contains code, state and iss
+ */
+export const parseAuthorizationResponse = (
+  authRes: unknown
+): AuthorizationResult => {
+  const authResParsed = AuthorizationResultShape.safeParse(authRes);
+  if (!authResParsed.success) {
+    const authErr = AuthorizationErrorShape.safeParse(authRes);
+    if (!authErr.success) {
+      Logger.log(
+        LogLevel.ERROR,
+        `Error while parsing the authorization response: ${authResParsed.error.message}`
+      );
+      throw new AuthorizationError(authResParsed.error.message); // an error occured while parsing the result and the error
+    }
+    Logger.log(
+      LogLevel.ERROR,
+      `Error while authorizating with the idp: ${JSON.stringify(authErr)}`
+    );
+    throw new AuthorizationIdpError(
+      authErr.data.error,
+      authErr.data.error_description
+    );
+  }
+  return authResParsed.data;
+};
+
+/**
+ * Creates the authorization response payload to be sent.
+ * This payload includes the state and the VP tokens for the presented credentials.
+ * The payload is encoded in Base64.
+ * @param state - The state parameter from the request object (optional).
+ * @param remotePresentation The presentations to send, each with their VP token
+ * @returns The Base64 encoded authorization response payload.
+ */
+const createAuthzResponsePayload = async ({
+  state,
+  remotePresentation,
+  wiaCryptoContext,
+}: {
+  state?: string;
+  remotePresentation: RemotePresentation;
+  wiaCryptoContext: CryptoContext;
+}): Promise<string> => {
+  const { kid } = await wiaCryptoContext.getPublicKey();
+
+  return new SignJWT(wiaCryptoContext)
+    .setProtectedHeader({
+      typ: "jwt",
+      kid,
+    })
+    .setPayload({
+      /**
+       * TODO [SIW-2264]: `state` coming from `requestObject` is marked as `optional`
+       * At the moment, it is not entirely clear whether this value can indeed be omitted
+       * and, if so, what the consequences of its absence might be.
+       */
+      ...(state ? { state } : {}),
+      vp_token: remotePresentation.presentations.reduce(
+        (vp_token, { credentialId, vpToken }) => ({
+          ...vp_token,
+          [credentialId]: [vpToken],
+        }),
+        {}
+      ),
+    })
+    .setIssuedAt()
+    .setExpirationTime("1h")
+    .sign();
+};

package/src/credential/issuance/v1.3.3/04-authorize-access.ts

@@ -0,0 +1,84 @@
+import { SignJWT } from "@pagopa/io-react-native-jwt";
+import { createTokenDPoP, fetchTokenResponse } from "@pagopa/io-wallet-oauth2";
+import { v4 as uuidv4 } from "uuid";
+import { createPopToken } from "../../../utils/pop";
+import * as WalletInstanceAttestation from "../../../wallet-instance-attestation/v1.0.0/utils";
+import { partialCallbacks } from "../../../utils/callbacks";
+import { IoWalletError } from "../../../utils/errors";
+import type { IssuanceApi, TokenResponse } from "../api";
+
+export const authorizeAccess: IssuanceApi["authorizeAccess"] = async (
+  issuerConf,
+  code,
+  redirectUri,
+  codeVerifier,
+  context
+) => {
+  const {
+    appFetch = fetch,
+    walletInstanceAttestation,
+    wiaCryptoContext,
+    dPopCryptoContext,
+  } = context;
+
+  const dPopSignerJwk = await dPopCryptoContext.getPublicKey();
+  const tokenDPoP = await createTokenDPoP({
+    callbacks: {
+      ...partialCallbacks,
+      signJwt: async (_, payload) => ({
+        jwt: await new SignJWT(wiaCryptoContext).setPayload(payload).sign(),
+        signerJwk: dPopSignerJwk,
+      }),
+    },
+    signer: {
+      alg: "ES256",
+      method: "jwk",
+      publicJwk: dPopSignerJwk,
+    },
+    tokenRequest: {
+      method: "POST",
+      url: issuerConf.token_endpoint,
+    },
+  });
+
+  const iss = WalletInstanceAttestation.decode(walletInstanceAttestation)
+    .payload.cnf.jwk.kid;
+
+  const signedWiaPoP = await createPopToken(
+    {
+      jti: uuidv4(),
+      aud: issuerConf.credential_issuer,
+      iss,
+    },
+    wiaCryptoContext
+  );
+
+  const tokenResponse = await fetchTokenResponse({
+    accessTokenEndpoint: issuerConf.token_endpoint,
+    callbacks: {
+      ...partialCallbacks,
+      fetch: appFetch,
+    },
+    walletAttestation: walletInstanceAttestation,
+    dPoP: tokenDPoP.jwt,
+    clientAttestationDPoP: signedWiaPoP,
+    accessTokenRequest: {
+      code,
+      grant_type: "authorization_code",
+      code_verifier: codeVerifier,
+      redirect_uri: redirectUri,
+    },
+  });
+
+  // `authorization_details` might be undefined if the PAR used `scope`.
+  // We currently do not support `scope` only.
+  if (!tokenResponse.authorization_details) {
+    throw new IoWalletError(
+      "Access token without authorization_details is not supported"
+    );
+  }
+
+  return {
+    accessToken: tokenResponse as TokenResponse,
+  };
+};

package/src/credential/issuance/v1.3.3/05-obtain-credential.ts

@@ -0,0 +1,188 @@
+import { type CryptoContext, SignJWT } from "@pagopa/io-react-native-jwt";
+import { createTokenDPoP } from "@pagopa/io-wallet-oauth2";
+import {
+  fetchCredentialResponse,
+  createCredentialRequest,
+  type CredentialRequestOptionsV1_3,
+} from "@pagopa/io-wallet-oid4vci";
+import { UnexpectedStatusCodeError as SdkUnexpectedStatusCodeError } from "@pagopa/io-wallet-utils";
+import { hasStatusOrThrow } from "../../../utils/misc";
+import {
+  IssuerResponseError,
+  IssuerResponseErrorCodes,
+  ResponseErrorBuilder,
+  ValidationFailed,
+} from "../../../utils/errors";
+import { LogLevel, Logger } from "../../../utils/logging";
+import { sdkConfigV1_3 } from "../../../utils/config";
+import { partialCallbacks } from "../../../utils/callbacks";
+import type { IssuanceApi } from "../api";
+import { NonceResponse } from "./types";
+
+export const createNonceProof = async (
+  nonce: string,
+  issuer: string,
+  audience: string,
+  ctx: CryptoContext
+): Promise<string> => {
+  const jwk = await ctx.getPublicKey();
+  return new SignJWT(ctx)
+    .setPayload({
+      nonce,
+    })
+    .setProtectedHeader({
+      typ: "openid4vci-proof+jwt",
+      jwk,
+    })
+    .setAudience(audience)
+    .setIssuer(issuer)
+    .setIssuedAt()
+    .setExpirationTime("5min")
+    .sign();
+};
+
+export const obtainCredential: IssuanceApi["obtainCredential"] = async (
+  issuerConf,
+  accessToken,
+  clientId,
+  credentialDefinition,
+  context
+) => {
+  const {
+    credentialCryptoContext,
+    appFetch = fetch,
+    dPopCryptoContext,
+  } = context;
+  const { credential_configuration_id, credential_identifier } =
+    credentialDefinition;
+
+  // Fetch the nonce from the Credential Issuer
+  const { c_nonce } = await appFetch(issuerConf.nonce_endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+  })
+    .then(hasStatusOrThrow(200))
+    .then((res) => res.json())
+    .then((body) => NonceResponse.parse(body));
+
+  // Validation of accessTokenResponse.authorization_details if contain credentialDefinition
+  const containsCredentialDefinition = accessToken.authorization_details.some(
+    (c) =>
+      c.credential_configuration_id === credential_configuration_id &&
+      (credential_identifier
+        ? c.credential_identifiers.includes(credential_identifier)
+        : true)
+  );
+
+  if (!containsCredentialDefinition) {
+    Logger.log(
+      LogLevel.ERROR,
+      `Credential definition not found in the access token response ${accessToken.authorization_details}`
+    );
+    throw new ValidationFailed({
+      message:
+        "The access token response does not contain the requested credential",
+    });
+  }
+
+  const signerJwk = await credentialCryptoContext.getPublicKey();
+
+  const credentialRequest = await createCredentialRequest({
+    config: sdkConfigV1_3 as CredentialRequestOptionsV1_3["config"],
+    callbacks: {
+      signJwt: async (_, payload) => ({
+        jwt: await new SignJWT(credentialCryptoContext)
+          .setPayload(payload)
+          .sign(),
+        signerJwk,
+      }),
+    },
+    clientId,
+    credential_identifier: credentialDefinition.credential_identifier!,
+    issuerIdentifier: issuerConf.credential_issuer,
+    nonce: c_nonce,
+    keyAttestation: "", // TODO
+    signer: {
+      alg: "ES256",
+      method: "jwk",
+      publicJwk: signerJwk,
+    },
+  });
+
+  const dPopSignerJwk = await dPopCryptoContext.getPublicKey();
+
+  const credentialDPoP = await createTokenDPoP({
+    callbacks: {
+      ...partialCallbacks,
+      signJwt: async (_, payload) => ({
+        jwt: await new SignJWT(dPopCryptoContext).setPayload(payload).sign(),
+        signerJwk,
+      }),
+    },
+    signer: {
+      method: "jwk",
+      alg: "ES256",
+      publicJwk: dPopSignerJwk,
+    },
+    tokenRequest: {
+      method: "POST",
+      url: issuerConf.credential_endpoint,
+    },
+    accessToken: accessToken.access_token,
+  });
+
+  // TODO: handle issuance errors
+  const credentialRes = await fetchCredentialResponse({
+    callbacks: {
+      fetch: appFetch,
+    },
+    credentialEndpoint: issuerConf.credential_endpoint,
+    credentialRequest: credentialRequest,
+    accessToken: accessToken.access_token,
+    dPoP: credentialDPoP.jwt,
+  }).catch(handleObtainCredentialError);
+
+  Logger.log(
+    LogLevel.DEBUG,
+    `Credential Response: ${JSON.stringify(credentialRes)}`
+  );
+
+  // Extract the format corresponding to the credential_configuration_id used
+  const issuerCredentialConfig =
+    issuerConf.credential_configurations_supported[credential_configuration_id];
+
+  // TODO: [SIW-2264] Handle multiple credentials
+  return {
+    credential: credentialRes.credentials!.at(0)!.credential,
+    format: issuerCredentialConfig!.format,
+  };
+};
+
+/**
+ * Handle the credential error by mapping it to a custom exception.
+ * If the error is not an instance of {@link SdkUnexpectedStatusCodeError}, it is thrown as is.
+ * @param e - The error to be handled
+ * @throws {IssuerResponseError} with a specific code for more context
+ */
+const handleObtainCredentialError = (e: unknown) => {
+  Logger.log(LogLevel.ERROR, `Error occurred while obtaining credential: ${e}`);
+
+  if (!(e instanceof SdkUnexpectedStatusCodeError)) {
+    throw e;
+  }
+
+  throw new ResponseErrorBuilder(IssuerResponseError)
+    .handle(403, {
+      code: IssuerResponseErrorCodes.CredentialInvalidStatus,
+      message: "Invalid status found for the given credential",
+    })
+    .handle(404, {
+      code: IssuerResponseErrorCodes.CredentialInvalidStatus,
+      message: "Invalid status found for the given credential",
+    })
+    .handle("*", {
+      code: IssuerResponseErrorCodes.CredentialRequestFailed,
+      message: "Unable to obtain the requested credential",
+    })
+    .buildFrom(e);
+};

package/src/credential/issuance/v1.3.3/06-verify-and-parse-credential.ts

@@ -0,0 +1,46 @@
+import { IoWalletError } from "../../../utils/errors";
+import { Logger, LogLevel } from "../../../utils/logging";
+import type { IssuanceApi } from "../api";
+import { verifyAndParseCredentialMDoc } from "../common/06-verify-and-parse-credential.mdoc";
+import { verifyAndParseCredentialSdJwt } from "../common/06-verify-and-parse-credential.sdjwt";
+
+export const verifyAndParseCredential: IssuanceApi["verifyAndParseCredential"] =
+  async (
+    issuerConf,
+    credential,
+    credentialConfigurationId,
+    context,
+    x509CertRoot
+  ) => {
+    const format =
+      issuerConf.credential_configurations_supported[credentialConfigurationId]
+        ?.format;
+
+    switch (format) {
+      case "dc+sd-jwt": {
+        Logger.log(LogLevel.DEBUG, "Parsing credential in dc+sd-jwt format");
+        return verifyAndParseCredentialSdJwt(
+          issuerConf,
+          credential,
+          credentialConfigurationId,
+          context
+        );
+      }
+      case "mso_mdoc": {
+        Logger.log(LogLevel.DEBUG, "Parsing credential in mso_mdoc format");
+        return verifyAndParseCredentialMDoc(
+          issuerConf,
+          credential,
+          credentialConfigurationId,
+          context,
+          x509CertRoot
+        );
+      }
+
+      default: {
+        const message = `Unsupported credential format: ${format}`;
+        Logger.log(LogLevel.ERROR, message);
+        throw new IoWalletError(message);
+      }
+    }
+  };

package/src/credential/issuance/v1.3.3/index.ts

@@ -0,0 +1,28 @@
+import type { IssuanceApi } from "../api";
+import { evaluateIssuerTrust } from "./01-evaluate-issuer-trust";
+import { startUserAuthorization } from "./02-start-user-authorization";
+import {
+  continueUserAuthorizationWithMRTDPoPChallenge,
+  completeUserAuthorizationWithQueryMode,
+  completeUserAuthorizationWithFormPostJwtMode,
+  buildAuthorizationUrl,
+  getRequestedCredentialToBePresented,
+} from "./03-complete-user-authorization";
+import { authorizeAccess } from "./04-authorize-access";
+import { obtainCredential } from "./05-obtain-credential";
+import { verifyAndParseCredential } from "./06-verify-and-parse-credential";
+import { MRTDPoP } from "../mrtd-pop";
+
+export const Issuance: IssuanceApi = {
+  evaluateIssuerTrust,
+  startUserAuthorization,
+  buildAuthorizationUrl,
+  completeUserAuthorizationWithQueryMode,
+  continueUserAuthorizationWithMRTDPoPChallenge,
+  getRequestedCredentialToBePresented,
+  completeUserAuthorizationWithFormPostJwtMode,
+  authorizeAccess,
+  obtainCredential,
+  verifyAndParseCredential,
+  MRTDPoP,
+};

package/src/credential/issuance/v1.3.3/mappers.ts

@@ -0,0 +1,87 @@
+import type { MetadataResponse } from "@pagopa/io-wallet-oid4vci";
+import type { ParsedAuthorizeRequestResult } from "@pagopa/io-wallet-oid4vp";
+import { assert } from "../../../utils/misc";
+import { createMapper } from "../../../utils/mappers";
+import type { JWK } from "../../../utils/jwk";
+import type { RequestObject } from "../../../credential/presentation";
+import { IssuerConfig } from "../api/IssuerConfig";
+
+type CredentialConfigurations =
+  IssuerConfig["credential_configurations_supported"];
+type OpenIdCredentialIssuer =
+  MetadataResponse["metadata"]["openid_credential_issuer"];
+
+const mapCredentialConfigurationsSupported = (
+  oidIssuer: OpenIdCredentialIssuer
+): CredentialConfigurations =>
+  Object.entries(oidIssuer!.credential_configurations_supported).reduce(
+    (acc, [key, config]) => {
+      acc[key] = {
+        ...(config.format === "dc+sd-jwt"
+          ? { format: config.format, vct: config.vct }
+          : { format: config.format, doctype: config.doctype }),
+        scope: config.scope,
+        display: config.credential_metadata.display!,
+        claims:
+          config.credential_metadata.claims?.map((claim) => ({
+            path: claim.path,
+            display: claim.display ?? [],
+          })) ?? [],
+      };
+      return acc;
+    },
+    {} as CredentialConfigurations
+  );
+
+export const mapToIssuerConfig = createMapper<MetadataResponse, IssuerConfig>(
+  (x) => {
+    const {
+      oauth_authorization_server,
+      openid_credential_issuer,
+      federation_entity,
+    } = x.metadata;
+
+    assert(
+      oauth_authorization_server,
+      "oauth_authorization_server is required in Issuer metadata"
+    );
+    assert(
+      openid_credential_issuer,
+      "openid_credential_issuer is required in Issuer metadata"
+    );
+
+    return {
+      authorization_endpoint: oauth_authorization_server.authorization_endpoint,
+      credential_endpoint: openid_credential_issuer.credential_endpoint,
+      credential_issuer: openid_credential_issuer.credential_issuer,
+      credential_configurations_supported: mapCredentialConfigurationsSupported(
+        openid_credential_issuer
+      ),
+      keys: openid_credential_issuer.jwks.keys as JWK[],
+      pushed_authorization_request_endpoint:
+        oauth_authorization_server.pushed_authorization_request_endpoint,
+      token_endpoint: oauth_authorization_server.token_endpoint,
+      status_assertion_endpoint:
+        openid_credential_issuer.status_attestation_endpoint,
+      nonce_endpoint: openid_credential_issuer.nonce_endpoint!,
+      federation_entity: federation_entity ?? {},
+      credential_issuance_batch_size:
+        openid_credential_issuer.batch_credential_issuance?.batch_size,
+    };
+  },
+  { outputSchema: IssuerConfig } // Output validation for extra-safety
+);
+
+export const mapToRequestObject = createMapper<
+  ParsedAuthorizeRequestResult,
+  RequestObject
+>(({ payload }) => ({
+  iss: payload.iss ?? "UNKNOWN_ISSUER",
+  client_id: payload.client_id,
+  dcql_query: payload.dcql_query!,
+  nonce: payload.nonce,
+  response_uri: payload.response_uri!,
+  state: payload.state,
+  response_mode: payload.response_mode,
+  response_type: payload.response_type,
+}));

package/src/credential/issuance/v1.3.3/types.ts

@@ -0,0 +1,6 @@
+import * as z from "zod";
+
+export type NonceResponse = z.infer<typeof NonceResponse>;
+export const NonceResponse = z.object({
+  c_nonce: z.string(),
+});