@cofhe/sdk 0.6.0 → 0.7.0

package/permits/validation.ts

@@ -1,327 +0,0 @@
-import { z } from 'zod';
-import { getAddress, isAddress, isHex, zeroAddress, type Hex } from 'viem';
-import type { Permit, ValidationResult } from './types.js';
-
-const SerializedSealingPair = z.object({
-  privateKey: z.string(),
-  publicKey: z.string(),
-});
-
-export const addressSchema = z
-  .string()
-  .refine((val) => isAddress(val), {
-    error: 'Invalid address',
-  })
-  .transform((val): Hex => getAddress(val));
-
-export const addressNotZeroSchema = addressSchema.refine((val) => val !== zeroAddress, {
-  error: 'Must not be zeroAddress',
-});
-
-export const bytesSchema = z.custom<Hex>(
-  (val) => {
-    return typeof val === 'string' && isHex(val);
-  },
-  {
-    message: 'Invalid hex value',
-  }
-);
-
-export const bytesNotEmptySchema = bytesSchema.refine((val) => val !== '0x', {
-  error: 'Must not be empty',
-});
-
-const DEFAULT_EXPIRATION_FN = () => Math.round(Date.now() / 1000) + 7 * 24 * 60 * 60; // 7 days from now
-
-const zPermitWithDefaults = z.object({
-  name: z.string().optional().default('Unnamed Permit'),
-  type: z.enum(['self', 'sharing', 'recipient']),
-  issuer: addressNotZeroSchema,
-  expiration: z.int().optional().default(DEFAULT_EXPIRATION_FN),
-  recipient: addressSchema.optional().default(zeroAddress),
-  validatorId: z.int().optional().default(0),
-  validatorContract: addressSchema.optional().default(zeroAddress),
-  issuerSignature: bytesSchema.optional().default('0x'),
-  recipientSignature: bytesSchema.optional().default('0x'),
-});
-
-const zPermitWithSealingPair = zPermitWithDefaults.extend({
-  sealingPair: SerializedSealingPair.optional(),
-});
-
-type zPermitType = z.infer<typeof zPermitWithDefaults>;
-
-/**
- * Permits allow a hook into an optional external validator contract,
- * this check ensures that IF an external validator is applied, that both `validatorId` and `validatorContract` are populated,
- * ELSE ensures that both `validatorId` and `validatorContract` are empty
- */
-const ExternalValidatorRefinement = [
-  (data: zPermitType) =>
-    (data.validatorId !== 0 && data.validatorContract !== zeroAddress) ||
-    (data.validatorId === 0 && data.validatorContract === zeroAddress),
-  {
-    error: 'Permit external validator :: validatorId and validatorContract must either both be set or both be unset.',
-    path: ['validatorId', 'validatorContract'] as string[],
-  },
-] as const;
-
-/**
- * Prevents sharable permit from having the same issuer and recipient
- */
-const RecipientRefinement = [
-  (data: zPermitType) => data.issuer !== data.recipient,
-  {
-    error: 'Sharing permit :: issuer and recipient must not be the same',
-    path: ['issuer', 'recipient'] as string[],
-  },
-] as const;
-
-// ============================================================================
-// SELF PERMIT VALIDATORS
-// ============================================================================
-
-/**
- * Validator for self permit creation options
- */
-export const SelfPermitOptionsValidator = z
-  .object({
-    type: z.literal('self').optional().default('self'),
-    issuer: addressNotZeroSchema,
-    name: z.string().optional().default('Unnamed Permit'),
-    expiration: z.int().optional().default(DEFAULT_EXPIRATION_FN),
-    recipient: addressSchema.optional().default(zeroAddress),
-    validatorId: z.int().optional().default(0),
-    validatorContract: addressSchema.optional().default(zeroAddress),
-    issuerSignature: bytesSchema.optional().default('0x'),
-    recipientSignature: bytesSchema.optional().default('0x'),
-  })
-  .refine(...ExternalValidatorRefinement);
-
-/**
- * Validator for fully formed self permits
- */
-export const SelfPermitValidator = zPermitWithSealingPair
-  .refine((data) => data.type === 'self', {
-    error: "Type must be 'self'",
-  })
-  .refine((data) => data.recipient === zeroAddress, {
-    error: 'Recipient must be zeroAddress',
-  })
-  .refine((data) => data.issuerSignature !== '0x', {
-    error: 'IssuerSignature must be populated',
-  })
-  .refine((data) => data.recipientSignature === '0x', {
-    error: 'RecipientSignature must be empty',
-  })
-  .refine(...ExternalValidatorRefinement);
-
-// ============================================================================
-// SHARING PERMIT VALIDATORS
-// ============================================================================
-
-/**
- * Validator for sharing permit creation options
- */
-export const SharingPermitOptionsValidator = z
-  .object({
-    type: z.literal('sharing').optional().default('sharing'),
-    issuer: addressNotZeroSchema,
-    recipient: addressNotZeroSchema,
-    name: z.string().optional().default('Unnamed Permit'),
-    expiration: z.int().optional().default(DEFAULT_EXPIRATION_FN),
-    validatorId: z.int().optional().default(0),
-    validatorContract: addressSchema.optional().default(zeroAddress),
-    issuerSignature: bytesSchema.optional().default('0x'),
-    recipientSignature: bytesSchema.optional().default('0x'),
-  })
-  .refine(...RecipientRefinement)
-  .refine(...ExternalValidatorRefinement);
-
-/**
- * Validator for fully formed sharing permits
- */
-export const SharingPermitValidator = zPermitWithSealingPair
-  .refine((data) => data.type === 'sharing', {
-    error: "Type must be 'sharing'",
-  })
-  .refine((data) => data.recipient !== zeroAddress, {
-    error: 'Recipient must not be zeroAddress',
-  })
-  .refine((data) => data.issuerSignature !== '0x', {
-    error: 'IssuerSignature must be populated',
-  })
-  .refine((data) => data.recipientSignature === '0x', {
-    error: 'RecipientSignature must be empty',
-  })
-  .refine(...ExternalValidatorRefinement);
-
-// ============================================================================
-// IMPORT/RECIPIENT PERMIT VALIDATORS
-// ============================================================================
-
-/**
- * Validator for import permit creation options (recipient receiving shared permit)
- */
-export const ImportPermitOptionsValidator = z
-  .object({
-    type: z.literal('recipient').optional().default('recipient'),
-    issuer: addressNotZeroSchema,
-    recipient: addressNotZeroSchema,
-    name: z.string().optional().default('Unnamed Permit'),
-    expiration: z.int(),
-    validatorId: z.int().optional().default(0),
-    validatorContract: addressSchema.optional().default(zeroAddress),
-    issuerSignature: bytesNotEmptySchema,
-    recipientSignature: bytesSchema.optional().default('0x'),
-  })
-  .refine(...ExternalValidatorRefinement);
-
-/**
- * Validator for fully formed import/recipient permits
- */
-export const ImportPermitValidator = zPermitWithSealingPair
-  .refine((data) => data.type === 'recipient', {
-    error: "Type must be 'recipient'",
-  })
-  .refine((data) => data.recipient !== zeroAddress, {
-    error: 'Recipient must not be zeroAddress',
-  })
-  .refine((data) => data.issuerSignature !== '0x', {
-    error: 'IssuerSignature must be populated',
-  })
-  .refine((data) => data.recipientSignature !== '0x', {
-    error: 'RecipientSignature must be populated',
-  })
-  .refine(...ExternalValidatorRefinement);
-
-// ============================================================================
-// VALIDATION FUNCTIONS
-// ============================================================================
-
-const safeParseAndThrowFormatted = <T extends z.ZodTypeAny>(schema: T, data: unknown, message: string): z.output<T> => {
-  const result = schema.safeParse(data);
-  if (!result.success) {
-    throw new Error(`${message}: ${z.prettifyError(result.error)}`, { cause: result.error });
-  }
-  return result.data;
-};
-
-/**
- * Validates self permit creation options
- */
-export const validateSelfPermitOptions = (options: any) => {
-  return safeParseAndThrowFormatted(SelfPermitOptionsValidator, options, 'Invalid self permit options');
-};
-/**
- * Validates sharing permit creation options
- */
-export const validateSharingPermitOptions = (options: any) => {
-  return safeParseAndThrowFormatted(SharingPermitOptionsValidator, options, 'Invalid sharing permit options');
-};
-
-/**
- * Validates import permit creation options
- */
-export const validateImportPermitOptions = (options: any) => {
-  return safeParseAndThrowFormatted(ImportPermitOptionsValidator, options, 'Invalid import permit options');
-};
-
-/**
- * Validates a fully formed self permit
- */
-export const validateSelfPermit = (permit: any) => {
-  return safeParseAndThrowFormatted(SelfPermitValidator, permit, 'Invalid self permit');
-};
-
-/**
- * Validates a fully formed sharing permit
- */
-export const validateSharingPermit = (permit: any) => {
-  return safeParseAndThrowFormatted(SharingPermitValidator, permit, 'Invalid sharing permit');
-};
-
-/**
- * Validates a fully formed import/recipient permit
- */
-export const validateImportPermit = (permit: any) => {
-  return safeParseAndThrowFormatted(ImportPermitValidator, permit, 'Invalid import permit');
-};
-
-/**
- * Simple validation functions for common checks
- */
-export const ValidationUtils = {
-  /**
-   * Check if permit is expired
-   */
-  isExpired: (permit: Permit): boolean => {
-    return permit.expiration < Math.floor(Date.now() / 1000);
-  },
-
-  /**
-   * Check if permit is signed by the active party
-   */
-  isSigned: (permit: Permit): boolean => {
-    if (permit.type === 'self' || permit.type === 'sharing') {
-      return permit.issuerSignature !== '0x';
-    }
-    if (permit.type === 'recipient') {
-      return permit.recipientSignature !== '0x';
-    }
-    return false;
-  },
-
-  /**
-   * Checks that a permit is signed and not expired.
-   */
-  isSignedAndNotExpired: (permit: Permit): ValidationResult => {
-    if (ValidationUtils.isExpired(permit)) {
-      return { valid: false, error: 'expired' };
-    }
-    if (!ValidationUtils.isSigned(permit)) {
-      return { valid: false, error: 'not-signed' };
-    }
-    return { valid: true, error: null };
-  },
-
-  /**
-   * Asserts that a permit is signed and not expired.
-   *
-   * Throws `Error` with message:
-   * - `Permit is expired`
-   * - `Permit is not signed`
-   */
-  assertSignedAndNotExpired: (permit: Permit): void => {
-    const result = ValidationUtils.isSignedAndNotExpired(permit);
-    if (result.valid) return;
-
-    if (result.error === 'expired') {
-      throw new Error('Permit is expired');
-    }
-    if (result.error === 'not-signed') {
-      throw new Error('Permit is not signed');
-    }
-
-    // Should be unreachable, but keeps this future-proof.
-    throw new Error('Permit is invalid');
-  },
-
-  isValid: (permit: Permit): ValidationResult => {
-    const schema =
-      permit.type === 'self'
-        ? SelfPermitValidator
-        : permit.type === 'sharing'
-          ? SharingPermitValidator
-          : permit.type === 'recipient'
-            ? ImportPermitValidator
-            : null;
-
-    if (schema == null) return { valid: false, error: 'invalid-schema' };
-
-    const schemaResult = schema.safeParse(permit);
-    if (!schemaResult.success) return { valid: false, error: 'invalid-schema' };
-
-    return ValidationUtils.isSignedAndNotExpired(permit);
-  },
-};