@aboutcircles/sdk-utils 0.1.0

package/dist/errors.js

@@ -0,0 +1,165 @@
+/**
+ * Circles SDK Error Handling
+ * Provides a structured error system for consistent error handling across the SDK
+ */
+/**
+ * Base Circles SDK Error
+ * All SDK errors extend from this class
+ */
+export class CirclesError extends Error {
+    name;
+    code;
+    source;
+    cause;
+    context;
+    constructor(name, message, options) {
+        super(message);
+        this.name = name;
+        this.code = options?.code;
+        this.source = (options?.source ?? 'UNKNOWN');
+        this.cause = options?.cause;
+        this.context = options?.context;
+        // Maintain proper stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Convert error to JSON for logging/debugging
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            source: this.source,
+            context: this.context,
+            cause: this.cause instanceof Error ? {
+                name: this.cause.name,
+                message: this.cause.message,
+            } : this.cause,
+            stack: this.stack,
+        };
+    }
+    /**
+     * Get formatted error message with context
+     */
+    toString() {
+        let result = `[${this.source}] ${this.name}: ${this.message}`;
+        if (this.code) {
+            result += ` (Code: ${this.code})`;
+        }
+        if (this.context) {
+            result += `\nContext: ${JSON.stringify(this.context, null, 2)}`;
+        }
+        return result;
+    }
+}
+/**
+ * Validation errors
+ */
+export class ValidationError extends CirclesError {
+    constructor(message, options) {
+        super('ValidationError', message, { ...options, source: 'VALIDATION' });
+    }
+    /**
+     * Create error for invalid address
+     */
+    static invalidAddress(address) {
+        return new ValidationError('Invalid Ethereum address', {
+            code: 'VALIDATION_INVALID_ADDRESS',
+            context: { address },
+        });
+    }
+    /**
+     * Create error for invalid amount
+     */
+    static invalidAmount(amount, reason) {
+        return new ValidationError(reason || 'Invalid amount', {
+            code: 'VALIDATION_INVALID_AMOUNT',
+            context: { amount, reason },
+        });
+    }
+    /**
+     * Create error for missing parameter
+     */
+    static missingParameter(paramName) {
+        return new ValidationError(`Missing required parameter: ${paramName}`, {
+            code: 'VALIDATION_MISSING_PARAM',
+            context: { paramName },
+        });
+    }
+    /**
+     * Create error for invalid parameter
+     */
+    static invalidParameter(paramName, value, reason) {
+        return new ValidationError(`Invalid parameter '${paramName}': ${reason || 'value is invalid'}`, {
+            code: 'VALIDATION_INVALID_PARAM',
+            context: { paramName, value, reason },
+        });
+    }
+}
+/**
+ * Encoding/Conversion errors for utils package
+ */
+export class EncodingError extends CirclesError {
+    constructor(message, options) {
+        super('EncodingError', message, { ...options, source: 'ENCODING' });
+    }
+    /**
+     * Create error for ABI encoding failures
+     */
+    static abiEncoding(functionName, cause) {
+        return new EncodingError('Failed to encode ABI data', {
+            code: 'ENCODING_ABI_FAILED',
+            cause,
+            context: { functionName },
+        });
+    }
+    /**
+     * Create error for CID conversion failures
+     */
+    static cidConversion(cid, cause) {
+        return new EncodingError('Failed to convert CID', {
+            code: 'ENCODING_CID_FAILED',
+            cause,
+            context: { cid },
+        });
+    }
+}
+/**
+ * Helper to wrap unknown errors into CirclesError
+ */
+export function wrapError(error, source = 'UNKNOWN') {
+    if (error instanceof CirclesError) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return new CirclesError(error.name || 'UnknownError', error.message, {
+            source,
+            cause: error,
+        });
+    }
+    return new CirclesError('UnknownError', String(error), {
+        source,
+        cause: error,
+    });
+}
+/**
+ * Type guard to check if error is a CirclesError
+ */
+export function isCirclesError(error) {
+    return error instanceof CirclesError;
+}
+/**
+ * Helper to extract error message safely
+ */
+export function getErrorMessage(error) {
+    if (isCirclesError(error)) {
+        return error.message;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { CirclesConverter } from './circlesConverter';
+export { bytesToHex } from './bytes';
+export { encodeFunctionData, decodeFunctionResult, decodeErrorResult, checksumAddress } from './abi';
+export { cidV0ToHex, cidV0ToUint8Array } from './cid';
+export { uint256ToAddress } from './address';
+export { ZERO_ADDRESS } from './constants';
+export { parseContractError, ContractError } from './contractErrors';
+export { CirclesError, ValidationError, EncodingError, wrapError, isCirclesError, getErrorMessage, } from './errors';
+export type { BaseErrorSource, UtilsErrorSource } from './errors';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AACrG,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGrE,OAAO,EACL,YAAY,EACZ,eAAe,EACf,aAAa,EACb,SAAS,EACT,cAAc,EACd,eAAe,GAChB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC"}