@cofhe/sdk 0.1.1 → 0.2.1

package/core/result.test.ts

@@ -1,180 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ResultOk, ResultErr, ResultErrOrInternal, resultWrapper, resultWrapperSync, type Result } from './result.js';
-import { CofhesdkError, CofhesdkErrorCode } from './error.js';
-
-export const expectResultError = <T>(result: Result<T>, errorPartial: string) => {
-  expect(result.success).to.eq(false, 'Result should be an error');
-  expect(result.error!.message).to.include(errorPartial, `Error should contain error partial: ${errorPartial}`);
-};
-
-export const expectResultSuccess = <T>(result: Result<T>): T => {
-  expect(result.success).to.eq(true, 'Result should be a success');
-  return result.data!;
-};
-
-export const expectResultValue = <T>(result: Result<T>, value: T): T => {
-  expect(result.success).to.eq(true, 'Result should be a success');
-  expect(result.data).to.eq(value, `Result should have the expected value ${value}`);
-  return result.data!;
-};
-
-describe('Result Type', () => {
-  describe('ResultOk', () => {
-    it('should create a successful result', () => {
-      const result = ResultOk('test data');
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('test data');
-      expect(result.error).toBe(null);
-    });
-
-    it('should handle different data types', () => {
-      const stringResult = ResultOk('string');
-      const numberResult = ResultOk(42);
-      const objectResult = ResultOk({ key: 'value' });
-      const nullResult = ResultOk(null);
-
-      expect(stringResult.data).toBe('string');
-      expect(numberResult.data).toBe(42);
-      expect(objectResult.data).toEqual({ key: 'value' });
-      expect(nullResult.data).toBe(null);
-    });
-  });
-
-  describe('ResultErr', () => {
-    it('should create an error result', () => {
-      const error = new CofhesdkError({
-        code: CofhesdkErrorCode.InternalError,
-        message: 'Test error',
-      });
-      const result = ResultErr(error);
-
-      expect(result.success).toBe(false);
-      expect(result.data).toBe(null);
-      expect(result.error).toBe(error);
-    });
-  });
-});
-
-describe('Error Utilities', () => {
-  describe('ResultErrOrInternal', () => {
-    it('should wrap unknown errors as internal errors', () => {
-      const result = ResultErrOrInternal(new Error('string error'));
-      expect(result.success).toBe(false);
-      expect(result.error!).toBeInstanceOf(CofhesdkError);
-      expect(result.error!.code).toBe(CofhesdkErrorCode.InternalError);
-      expect(result.error!.message).toBe('An internal error occurred | Caused by: string error');
-    });
-
-    it('should preserve CofhesdkError instances', () => {
-      const originalError = new CofhesdkError({
-        code: CofhesdkErrorCode.MissingPublicClient,
-        message: 'Public client missing',
-      });
-      const result = ResultErrOrInternal(originalError);
-      expect(result.success).toBe(false);
-      expect(result.error!).toBe(originalError);
-    });
-
-    it('should handle Error instances', () => {
-      const error = new Error('Standard error');
-      const result = ResultErrOrInternal(error);
-      expect(result.success).toBe(false);
-      expect(result.error!).toBeInstanceOf(CofhesdkError);
-      expect(result.error!.cause).toBe(error);
-    });
-  });
-});
-
-describe('Result Wrappers', () => {
-  describe('resultWrapperSync', () => {
-    it('should wrap successful sync function', () => {
-      const result = resultWrapperSync(() => 'success');
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('success');
-    });
-
-    it('should wrap failing sync function', () => {
-      const result = resultWrapperSync(() => {
-        throw new Error('Sync error');
-      });
-      expect(result.success).toBe(false);
-      expect(result.error).toBeInstanceOf(CofhesdkError);
-    });
-  });
-
-  describe('resultWrapper', () => {
-    it('should wrap successful async function', async () => {
-      const result = await resultWrapper(async () => 'async success');
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('async success');
-    });
-
-    it('should wrap failing async function', async () => {
-      const result = await resultWrapper(async () => {
-        throw new Error('Async error');
-      });
-      expect(result.success).toBe(false);
-      expect(result.error).toBeInstanceOf(CofhesdkError);
-    });
-
-    it('should handle async operations', async () => {
-      const result = await resultWrapper(async () => {
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        return 'delayed result';
-      });
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('delayed result');
-    });
-
-    it('should handle Promise rejections', async () => {
-      const result = await resultWrapper(async () => {
-        return Promise.reject(new Error('Promise rejection'));
-      });
-      expect(result.success).toBe(false);
-      expect(result.error).toBeInstanceOf(CofhesdkError);
-    });
-  });
-});
-
-describe('Result Type Guards', () => {
-  it('should correctly identify success results', () => {
-    const successResult = ResultOk('data');
-    expect(successResult.success).toBe(true);
-    expect(successResult.data).toBe('data');
-    expect(successResult.error).toBe(null);
-  });
-
-  it('should correctly identify error results', () => {
-    const errorResult = ResultErr(
-      new CofhesdkError({
-        code: CofhesdkErrorCode.InternalError,
-        message: 'Test error',
-      })
-    );
-    expect(errorResult.success).toBe(false);
-    expect(errorResult.data).toBe(null);
-    expect(errorResult.error).toBeInstanceOf(CofhesdkError);
-  });
-});
-
-describe('Result Test Utilities', () => {
-  it('expectResultSuccess should return data for success', () => {
-    const result = ResultOk('data');
-    expect(expectResultSuccess(result)).toBe('data');
-  });
-
-  it('expectResultValue should validate and return matching data', () => {
-    const result = ResultOk('expected');
-    expect(expectResultValue(result, 'expected')).toBe('expected');
-  });
-
-  it('expectResultError should validate error messages', () => {
-    const result = ResultErr(
-      new CofhesdkError({
-        code: CofhesdkErrorCode.InternalError,
-        message: 'Test error message',
-      })
-    );
-    expectResultError(result, 'Test error');
-  });
-});

package/core/result.ts

@@ -1,67 +0,0 @@
-/* eslint-disable no-unused-vars */
-import { CofhesdkError, CofhesdkErrorCode } from './error.js';
-
-export type Result<T> = { success: true; data: T; error: null } | { success: false; data: null; error: CofhesdkError };
-
-export const ResultErr = <T>(error: CofhesdkError): Result<T> => ({
-  success: false,
-  data: null,
-  error,
-});
-
-export const ResultOk = <T>(data: T): Result<T> => ({
-  success: true,
-  data,
-  error: null,
-});
-
-export const ResultErrOrInternal = <T>(error: unknown): Result<T> => {
-  return ResultErr(CofhesdkError.fromError(error));
-};
-
-export const ResultHttpError = (error: unknown, url: string, status?: number): CofhesdkError => {
-  if (error instanceof CofhesdkError) return error;
-
-  const message = status ? `HTTP error ${status} from ${url}` : `HTTP request failed for ${url}`;
-
-  return new CofhesdkError({
-    code: CofhesdkErrorCode.InternalError,
-    message,
-    cause: error instanceof Error ? error : undefined,
-  });
-};
-
-export const ResultValidationError = (message: string): CofhesdkError => {
-  return new CofhesdkError({
-    code: CofhesdkErrorCode.InvalidPermitData,
-    message,
-  });
-};
-
-// Async resultWrapper
-export const resultWrapper = async <T>(
-  tryFn: () => Promise<T>,
-  catchFn?: (error: CofhesdkError) => void,
-  finallyFn?: () => void
-): Promise<Result<T>> => {
-  try {
-    const result = await tryFn();
-    return ResultOk(result);
-  } catch (error) {
-    const result = ResultErrOrInternal(error);
-    catchFn?.(result.error!);
-    return result as Result<T>;
-  } finally {
-    finallyFn?.();
-  }
-};
-
-// Sync resultWrapper
-export const resultWrapperSync = <T>(fn: () => T): Result<T> => {
-  try {
-    const result = fn();
-    return ResultOk(result);
-  } catch (error) {
-    return ResultErrOrInternal(error);
-  }
-};

package/core/test-utils.ts

@@ -1,45 +0,0 @@
-import { expect } from 'vitest';
-import { type Result } from './result.js';
-import { CofhesdkError, CofhesdkErrorCode } from './error.js';
-
-/**
- * Assert that a Result is successful and return its data
- * Useful for type narrowing in tests
- */
-export const expectResultSuccess = <T>(result: Result<T>): NonNullable<T> => {
-  expect(result.error, `Result error: ${result.error?.toString()}`).toBe(null);
-  expect(result.success, `Result: ${bigintSafeJsonStringify(result)}`).toBe(true);
-  expect(result.data, `Result: ${bigintSafeJsonStringify(result)}`).not.toBe(null);
-  return result.data!;
-};
-
-/**
- * Assert that a Result is an error and optionally verify the error details
- */
-export const expectResultError = <T>(
-  result: Result<T>,
-  errorCode?: CofhesdkErrorCode,
-  errorMessage?: string
-): CofhesdkError => {
-  expect(result.success, `Result: ${bigintSafeJsonStringify(result)}`).toBe(false);
-  expect(result.data, `Result: ${bigintSafeJsonStringify(result)}`).toBe(null);
-  expect(result.error, `Result: ${bigintSafeJsonStringify(result)}`).not.toBe(null);
-  const error = result.error as CofhesdkError;
-  expect(error, `Result error: ${result.error?.toString()}`).toBeInstanceOf(CofhesdkError);
-  if (errorCode) {
-    expect(error.code, `Result error: ${result.error?.toString()}`).toBe(errorCode);
-  }
-  if (errorMessage) {
-    expect(error.message, `Result error: ${result.error?.toString()}`).toBe(errorMessage);
-  }
-  return error;
-};
-
-const bigintSafeJsonStringify = (value: unknown): string => {
-  return JSON.stringify(value, (key, value) => {
-    if (typeof value === 'bigint') {
-      return `${value}n`;
-    }
-    return value;
-  });
-};

package/dist/types-KImPrEIe.d.cts

@@ -1,48 +0,0 @@
-import { z } from 'zod';
-
-/**
- * Environment schema for @cofhe/sdk chains
- */
-declare const EnvironmentSchema: z.ZodEnum<["MOCK", "TESTNET", "MAINNET"]>;
-/**
- * Zod schema for CofheChain validation
- */
-declare const CofheChainSchema: z.ZodObject<{
-    /** Chain ID */
-    id: z.ZodNumber;
-    /** Human-readable chain name */
-    name: z.ZodString;
-    /** Network identifier */
-    network: z.ZodString;
-    /** coFhe service URL */
-    coFheUrl: z.ZodString;
-    /** Verifier service URL */
-    verifierUrl: z.ZodString;
-    /** Threshold network service URL */
-    thresholdNetworkUrl: z.ZodString;
-    /** Environment type */
-    environment: z.ZodEnum<["MOCK", "TESTNET", "MAINNET"]>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    id: number;
-    network: string;
-    coFheUrl: string;
-    verifierUrl: string;
-    thresholdNetworkUrl: string;
-    environment: "MOCK" | "TESTNET" | "MAINNET";
-}, {
-    name: string;
-    id: number;
-    network: string;
-    coFheUrl: string;
-    verifierUrl: string;
-    thresholdNetworkUrl: string;
-    environment: "MOCK" | "TESTNET" | "MAINNET";
-}>;
-/**
- * Type inference from the schema
- */
-type CofheChain = z.infer<typeof CofheChainSchema>;
-type Environment = z.infer<typeof EnvironmentSchema>;
-
-export type { CofheChain as C, Environment as E };

package/dist/types-KImPrEIe.d.ts

@@ -1,48 +0,0 @@
-import { z } from 'zod';
-
-/**
- * Environment schema for @cofhe/sdk chains
- */
-declare const EnvironmentSchema: z.ZodEnum<["MOCK", "TESTNET", "MAINNET"]>;
-/**
- * Zod schema for CofheChain validation
- */
-declare const CofheChainSchema: z.ZodObject<{
-    /** Chain ID */
-    id: z.ZodNumber;
-    /** Human-readable chain name */
-    name: z.ZodString;
-    /** Network identifier */
-    network: z.ZodString;
-    /** coFhe service URL */
-    coFheUrl: z.ZodString;
-    /** Verifier service URL */
-    verifierUrl: z.ZodString;
-    /** Threshold network service URL */
-    thresholdNetworkUrl: z.ZodString;
-    /** Environment type */
-    environment: z.ZodEnum<["MOCK", "TESTNET", "MAINNET"]>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    id: number;
-    network: string;
-    coFheUrl: string;
-    verifierUrl: string;
-    thresholdNetworkUrl: string;
-    environment: "MOCK" | "TESTNET" | "MAINNET";
-}, {
-    name: string;
-    id: number;
-    network: string;
-    coFheUrl: string;
-    verifierUrl: string;
-    thresholdNetworkUrl: string;
-    environment: "MOCK" | "TESTNET" | "MAINNET";
-}>;
-/**
- * Type inference from the schema
- */
-type CofheChain = z.infer<typeof CofheChainSchema>;
-type Environment = z.infer<typeof EnvironmentSchema>;
-
-export type { CofheChain as C, Environment as E };