@layerzerolabs/common-error-utils 0.2.68 → 0.2.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/common-error-utils",
-  "version": "0.2.68",
+  "version": "0.2.70",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -13,6 +13,9 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
   "dependencies": {
     "exponential-backoff": "^3.1.1",
     "ms": "^2.1.3"
@@ -21,8 +24,8 @@
     "@types/ms": "^2.1.0",
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/tsup-configuration": "0.2.68",
-    "@layerzerolabs/typescript-configuration": "0.2.68"
+    "@layerzerolabs/tsup-configuration": "0.2.70",
+    "@layerzerolabs/typescript-configuration": "0.2.70"
   },
   "publishConfig": {
     "access": "public",
@@ -30,7 +33,8 @@
   },
   "externalRepoConfig": {
     "targets": [
-      "audit-external"
+      "audit-external",
+      "onesig-client"
     ]
   },
   "scripts": {

package/.turbo/turbo-build.log

@@ -1,39 +0,0 @@
- WARN  Issue while reading "/home/runner/work/monorepo-internal/monorepo-internal/.npmrc". Failed to replace env in config: ${NPM_TOKEN}
-
-> @layerzerolabs/common-error-utils@0.0.0 build /home/runner/work/monorepo-internal/monorepo-internal/packages/common/common-error-utils
-> tsup
-
-CLI Building entry: src/errors.ts, src/index.ts, src/retry.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.1
-CLI Using tsup config: /home/runner/work/monorepo-internal/monorepo-internal/packages/common/common-error-utils/tsup.config.ts
-CLI Target: ES2023
-CLI Cleaning output folder
-CJS Build start
-ESM Build start
-CJS dist/index.cjs        1.81 KB
-CJS dist/YJF4D23A.cjs     245.00 B
-CJS dist/errors.cjs       1.63 KB
-CJS dist/MXJDS64O.cjs     5.06 KB
-CJS dist/CSP5OI2I.cjs     1.55 KB
-CJS dist/retry.cjs        302.00 B
-CJS dist/index.cjs.map    70.00 B
-CJS dist/YJF4D23A.cjs.map 73.00 B
-CJS dist/errors.cjs.map   71.00 B
-CJS dist/MXJDS64O.cjs.map 10.18 KB
-CJS dist/CSP5OI2I.cjs.map 5.03 KB
-CJS dist/retry.cjs.map    70.00 B
-CJS ⚡️ Build success in 215ms
-ESM dist/errors.js       315.00 B
-ESM dist/retry.js        143.00 B
-ESM dist/VUOMXK5T.js     222.00 B
-ESM dist/HSJL4TXR.js     4.62 KB
-ESM dist/WUDCWRMR.js     1.27 KB
-ESM dist/index.js        365.00 B
-ESM dist/errors.js.map   70.00 B
-ESM dist/retry.js.map    69.00 B
-ESM dist/VUOMXK5T.js.map 72.00 B
-ESM dist/HSJL4TXR.js.map 10.17 KB
-ESM dist/WUDCWRMR.js.map 5.01 KB
-ESM dist/index.js.map    69.00 B
-ESM ⚡️ Build success in 216ms

package/.turbo/turbo-lint.log

@@ -1,8 +0,0 @@
-
-> @layerzerolabs/common-error-utils@0.0.0 lint /home/runner/work/monorepo-internal/monorepo-internal/packages/common/common-error-utils
-> eslint . --max-warnings 0 || (eslint . --fix --max-warnings 0 && false)
-
-(node:65553) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/monorepo-internal/monorepo-internal/eslint.config.js?mtime=1775694520701 is not specified and it doesn't parse as CommonJS.
-Reparsing as ES module because module syntax was detected. This incurs a performance overhead.
-To eliminate this warning, add "type": "module" to /home/runner/work/monorepo-internal/monorepo-internal/package.json.
-(Use `node --trace-warnings ...` to show where the warning was created)

package/.turbo/turbo-test.log

@@ -1,33 +0,0 @@
-
-> @layerzerolabs/common-error-utils@0.0.0 test /home/runner/work/monorepo-internal/monorepo-internal/packages/common/common-error-utils
-> vitest --run --pass-with-no-tests --typecheck
-
-Testing types with tsc and vue-tsc is an experimental feature.
-Breaking changes might not follow SemVer, please pin Vitest's version when using it.
-
- RUN  v3.2.4 /home/runner/work/monorepo-internal/monorepo-internal/packages/common/common-error-utils
-
-stdout | tests/error.test.ts > SerializableError > wraps simple error
-SomeError constructor called {
-  cause: Error: Some error 2
-      at /home/runner/work/monorepo-internal/monorepo-internal/packages/common/common-error-utils/tests/error.test.ts:33:21
-      at file:///home/runner/work/monorepo-internal/monorepo-internal/node_modules/.pnpm/@vitest+runner@3.2.4/node_modules/@vitest/runner/dist/chunk-hooks.js:155:11
-      at file:///home/runner/work/monorepo-internal/monorepo-internal/node_modules/.pnpm/@vitest+runner@3.2.4/node_modules/@vitest/runner/dist/chunk-hooks.js:752:26
-      at file:///home/runner/work/monorepo-internal/monorepo-internal/node_modules/.pnpm/@vitest+runner@3.2.4/node_modules/@vitest/runner/dist/chunk-hooks.js:1897:20
-      at new Promise (<anonymous>)
-      at runWithTimeout (file:///home/runner/work/monorepo-internal/monorepo-internal/node_modules/.pnpm/@vitest+runner@3.2.4/node_modules/@vitest/runner/dist/chunk-hooks.js:1863:10)
-      at runTest (file:///home/runner/work/monorepo-internal/monorepo-internal/node_modules/.pnpm/@vitest+runner@3.2.4/node_modules/@vitest/runner/dist/chunk-hooks.js:1574:12)
-      at processTicksAndRejections (node:internal/process/task_queues:105:5)
-      at runSuite (file:///home/runner/work/monorepo-internal/monorepo-internal/node_modules/.pnpm/@vitest+runner@3.2.4/node_modules/@vitest/runner/dist/chunk-hooks.js:1729:8)
-      at runSuite (file:///home/runner/work/monorepo-internal/monorepo-internal/node_modules/.pnpm/@vitest+runner@3.2.4/node_modules/@vitest/runner/dist/chunk-hooks.js:1729:8)
-}
-
- ✓ tests/error.test.ts (3 tests) 12ms
- ✓ tests/retry.test.ts (6 tests) 71ms
-
- Test Files  2 passed (2)
-      Tests  9 passed (9)
-Type Errors  no errors
-   Start at  00:31:09
-   Duration  805ms (transform 144ms, setup 0ms, collect 200ms, tests 83ms, environment 0ms, prepare 250ms)
-

package/src/errors.ts

@@ -1,153 +0,0 @@
-const extractMessageFromJsonRpcError = (err: any): string => {
-    try {
-        if (typeof err.body === 'object' && err.body.message) {
-            return err.body.message;
-        }
-        const parsedBody = JSON.parse(err.body);
-        return parsedBody?.error?.message;
-    } catch {
-        return 'unknown';
-    }
-};
-
-export function convertErrorToObject(err: any): any {
-    return JSON.parse(JSON.stringify(err, Object.getOwnPropertyNames(err)));
-}
-
-export function normalizeError(err: any) {
-    const error = convertErrorToObject(err);
-    return {
-        // Normal Error properties
-        ...(error.name ? { name: error.name } : {}),
-        ...(error.message ? { message: error.message } : {}),
-        ...(error.stack ? { stack: error.stack } : {}),
-        // Rpc properties
-        ...(error.reason ? { reason: error.reason } : {}),
-        ...(error.code ? { code: error.code } : {}),
-        ...(error.event ? { event: error.event } : {}),
-        ...(error.body ? { body: extractMessageFromJsonRpcError(error) } : {}),
-    };
-}
-
-// Removes the last argument if it is an ErrorOptions
-type RemoveErrorOptions<T extends any[]> = T extends [...infer U, ErrorOptions?] ? U : never;
-
-/**
- * Base class for all serializable errors.
- * This class is designed to be extended by other error classes.
- * It provides a way to wrap errors and a way to check if an error is in the stack of a specific error class.
- * All errors that extend this class *must* have error options as the last argument in their constructor.
- */
-export abstract class SerializableError extends Error {
-    details: string[];
-    /*
-     * The instance of the error that was wrapped, if any.
-     * Creates a linked list of error objects.
-     * Only exists if the error hasn't been serialized and deserialized.
-     */
-    cause: unknown;
-    constructor(message: string, options?: ErrorOptions) {
-        super(message, options);
-        // for some reason, we need to set the cause directly on the instance, even after calling super
-        this.cause = options?.cause;
-        this.name = this.constructor.name;
-        this.details = [this.constructor.name, 'SerializableError'];
-    }
-
-    /*
-     * Checks if the error is an instance of the current class or a subclass. Returns the error if it is.
-     * We can't type the error as more than SerializableError because it could have been serialized and deserialized,
-     * which could make it lose extra fields.
-     */
-    static inStackOf<T extends abstract new (...args: any) => any>(
-        this: T,
-        error: any,
-    ): SerializableError | undefined {
-        if (error?.details?.includes(this.name)) {
-            return error as SerializableError;
-        } else if (error?.cause?.details?.includes(this.name)) {
-            return error.cause as SerializableError;
-        }
-        return undefined;
-    }
-
-    // We could limit this to only wrap serializable errors, but that could limit the flexibility of the error system.
-    static wrap<T extends new (...args: any) => SerializableError>(
-        this: T,
-        error: any,
-        // Remove the optional error arguments
-        ...args: RemoveErrorOptions<ConstructorParameters<T>>
-    ): InstanceType<T> {
-        const wrappedError = new this(...args, { cause: error });
-
-        wrappedError.details = error?.details
-            ? [wrappedError.name, ...error.details]
-            : [wrappedError.name, 'SerializableError', error?.name ?? 'UnknownError'];
-
-        wrappedError.message = `${wrappedError.message} > ${error?.message ?? String(error)}`;
-
-        return wrappedError as InstanceType<T>;
-    }
-}
-
-export class NonRetryableError extends SerializableError {
-    constructor(message: string, options?: ErrorOptions) {
-        super(message, options);
-    }
-}
-
-export class NotFoundError extends SerializableError {
-    constructor(message?: string, options?: ErrorOptions) {
-        super(message ? `Not found: ${message}` : 'Not found', options);
-    }
-}
-
-// TODO: extend this for chain specific providers
-export class ProviderError extends SerializableError {
-    constructor(providerUri: string, options?: ErrorOptions) {
-        super(`Provider error at host '${ProviderError.parseHost(providerUri)}'`, options);
-    }
-
-    private static parseHost(providerUri: string): string {
-        try {
-            const url = new URL(providerUri);
-            return url.host;
-        } catch {
-            return 'UNKNOWN_HOST';
-        }
-    }
-}
-
-export class NonEmittableError extends SerializableError {
-    constructor(message: string, options?: ErrorOptions) {
-        super(message, options);
-        this.name = 'NonEmittableError';
-    }
-}
-
-export class QuorumNotAchievedYet extends SerializableError {
-    constructor(options?: ErrorOptions) {
-        super('The quorum was not achieved yet', options);
-    }
-}
-
-export class MultiError extends Error {
-    constructor(public readonly errs: any[]) {
-        super(errs.map((err) => err.message).join(', '));
-    }
-}
-
-export const throwError = <Err extends Error>(
-    message: string,
-    error?: (message: string) => Err,
-): never => {
-    throw error?.(message) ?? new Error(message);
-};
-
-/**
- * Assert that a value is never.
- * Most useful for enforcing exhaustive switch statements.
- */
-export const assertUnreachable = (value: never): never => {
-    throw new NonRetryableError(`Unreachable value: ${value}`);
-};

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './errors';
-export * from './retry';

package/src/retry.ts

@@ -1,97 +0,0 @@
-import { backOff } from 'exponential-backoff';
-import type { StringValue } from 'ms';
-import ms from 'ms';
-
-export interface RetryPolicy {
-    /**
-     * Maximum time of a single execution attempt.
-     * This timeout should be as short as the longest possible execution of the Activity body.
-     *
-     * @default 10 minutes
-     * @format {@link https://www.npmjs.com/package/ms | ms-formatted string}
-     */
-    startToCloseTimeout?: StringValue;
-
-    /**
-     * Coefficient used to calculate the next retry interval.
-     * The next retry interval is previous interval multiplied by this coefficient.
-     * @minimum 1
-     * @default 2
-     */
-    backoffCoefficient?: number;
-
-    /**
-     * Interval of the first retry.
-     * If coefficient is 1 then it is used for all retries
-     * @format {@link https://www.npmjs.com/package/ms | ms-formatted string}
-     * @default 1 second
-     */
-    initialInterval?: StringValue;
-
-    /**
-     * Maximum number of attempts. When exceeded, retries stop.
-     *
-     * @default Infinity
-     */
-    maximumAttempts?: number;
-
-    /**
-     * Maximum interval between retries.
-     * Exponential backoff leads to interval increase.
-     * This value is the cap of the increase.
-     *
-     * @default 100x of {@link initialInterval}
-     * @format {@link https://www.npmjs.com/package/ms | ms-formatted string}
-     */
-    maximumInterval?: StringValue;
-
-    /**
-     * List of application failures types to not retry.
-     */
-    nonRetryableErrorTypes?: string[];
-}
-
-/**
- * Executes a function with a retry policy.
- * @param fn - The function to execute.
- * @param policy - The retry policy to apply.
- * @param shouldRetry - A callback that determines if the error is retryable besides the nonRetryableErrorTypes.
- * @return A promise that resolves to the result of the function or rejects with an error.
- * @throws Error if the function fails after all retries.
- */
-export const runWithRetryPolicy = <T = unknown>(
-    fn: () => Promise<T>,
-    policy?: RetryPolicy,
-    shouldRetry?: (err: any) => boolean,
-): Promise<T> => {
-    const perTryTimeout = ms(policy?.startToCloseTimeout ?? '10 minutes');
-    const numOfAttempts = policy?.maximumAttempts ?? Infinity;
-    const startingDelay = ms(policy?.initialInterval ?? '1s');
-    const maxDelay = policy?.maximumInterval ? ms(policy.maximumInterval) : startingDelay * 100;
-    const timeMultiple = Math.max(policy?.backoffCoefficient ?? 2, 1);
-    const nonRetryableErrorTypes = policy?.nonRetryableErrorTypes ?? [];
-
-    return backOff(
-        () =>
-            new Promise((resolve, reject) => {
-                fn().then(resolve).catch(reject);
-                setTimeout(() => {
-                    reject(new Error(`Execution timed out after ${perTryTimeout}ms`));
-                }, perTryTimeout);
-            }),
-        {
-            maxDelay,
-            startingDelay,
-            jitter: 'full',
-            timeMultiple,
-            numOfAttempts,
-            retry: async (error: any) => {
-                const errorType = error?.constructor?.name ?? error?.name;
-                return (
-                    !nonRetryableErrorTypes.includes(errorType) &&
-                    (shouldRetry ? shouldRetry(error) : true)
-                );
-            },
-        },
-    );
-};

package/tests/error.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { NotFoundError, SerializableError } from './../src/';
-
-describe('SerializableError', () => {
-    it('should check if error is in stack', () => {
-        const err = new NotFoundError('User');
-        expect(err.name).toBe('NotFoundError');
-        expect(err.message).toBe('Not found: User');
-        expect(err.cause).toBeUndefined();
-        expect(err.details).toEqual(['NotFoundError', 'SerializableError']);
-        expect(NotFoundError.inStackOf(err)).toBe(err);
-    });
-
-    it('should wrap an error', () => {
-        const originalError = new Error('No rows returned');
-        const wrappedError = NotFoundError.wrap(originalError, 'User');
-
-        expect(wrappedError.name).toBe('NotFoundError');
-        expect(wrappedError.message).toBe('Not found: User > No rows returned');
-        expect(wrappedError.cause).toBe(originalError);
-        expect(wrappedError.details).toEqual(['NotFoundError', 'SerializableError', 'Error']);
-    });
-
-    it('wraps simple error', () => {
-        class SomeError extends SerializableError {
-            constructor(opts: ErrorOptions) {
-                console.log('SomeError constructor called', opts);
-                super('Some error', opts);
-            }
-        }
-
-        const err = new Error('Some error 2');
-        const wrapped = SomeError.wrap(err);
-        expect(wrapped.name).toBe('SomeError');
-        expect(wrapped.message).toBe('Some error > Some error 2');
-        expect(wrapped.cause).toBe(err);
-        expect(wrapped.details).toEqual(['SomeError', 'SerializableError', 'Error']);
-    });
-});

package/tests/retry.test.ts

@@ -1,110 +0,0 @@
-import { backOff } from 'exponential-backoff';
-import { afterEach, describe, expect, test, vi } from 'vitest';
-
-import { runWithRetryPolicy } from '../src/retry';
-
-vi.mock('exponential-backoff', async (importOriginal) => {
-    const originalModule = await importOriginal<typeof import('exponential-backoff')>();
-    return {
-        ...originalModule,
-        backOff: vi.fn(originalModule.backOff),
-    };
-});
-
-const mockedBackOff = vi.mocked(backOff);
-
-describe('runWithRetryPolicy', () => {
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-
-    test('startToCloseTimeout', async () => {
-        const longRunningFn = () => new Promise(() => {}); // Never resolves
-
-        await expect(
-            runWithRetryPolicy(longRunningFn, {
-                startToCloseTimeout: '50ms',
-                maximumAttempts: 1,
-            }),
-        ).rejects.toThrow('Execution timed out after 50ms');
-    });
-
-    test('maximumAttempts', async () => {
-        const failingFn = vi.fn().mockRejectedValue(new Error('simulated failure'));
-
-        await expect(
-            runWithRetryPolicy(failingFn, {
-                maximumAttempts: 3,
-                initialInterval: '1ms',
-            }),
-        ).rejects.toThrow('simulated failure');
-
-        expect(mockedBackOff).toHaveBeenCalledWith(
-            expect.any(Function),
-            expect.objectContaining({ numOfAttempts: 3 }),
-        );
-        expect(failingFn).toHaveBeenCalledTimes(3);
-    });
-
-    test('initialInterval', async () => {
-        const fn = async () => {};
-
-        await runWithRetryPolicy(fn, {
-            initialInterval: '5s',
-        });
-
-        expect(mockedBackOff).toHaveBeenCalledWith(
-            expect.any(Function),
-            expect.objectContaining({ startingDelay: 5000 }),
-        );
-    });
-
-    test('maximumInterval', async () => {
-        const fn = async () => {};
-        await runWithRetryPolicy(fn, {
-            maximumInterval: '10s',
-        });
-        expect(mockedBackOff).toHaveBeenCalledWith(
-            expect.any(Function),
-            expect.objectContaining({ maxDelay: 10000 }),
-        );
-    });
-
-    test('backoffCoefficient', async () => {
-        const fn = async () => {};
-        await runWithRetryPolicy(fn, {
-            backoffCoefficient: 3,
-        });
-        expect(mockedBackOff).toHaveBeenCalledWith(
-            expect.any(Function),
-            expect.objectContaining({ timeMultiple: 3 }),
-        );
-    });
-
-    test('nonRetryableErrorTypes', async () => {
-        class CustomError extends Error {
-            constructor(message: string) {
-                super(message);
-                this.name = 'CustomError';
-            }
-        }
-
-        const retryableError = new Error('A retryable error');
-        const nonRetryableError = new CustomError('A non-retryable error');
-
-        const failingFn = vi
-            .fn()
-            .mockRejectedValueOnce(retryableError)
-            .mockRejectedValueOnce(nonRetryableError);
-
-        await expect(
-            runWithRetryPolicy(failingFn, {
-                maximumAttempts: 5,
-                initialInterval: '1ms',
-                nonRetryableErrorTypes: ['CustomError'],
-            }),
-        ).rejects.toThrow(nonRetryableError);
-
-        expect(failingFn).toHaveBeenCalledTimes(2);
-    });
-});

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-    "extends": "@layerzerolabs/typescript-configuration/tsconfig.base.json",
-    "compilerOptions": {
-        "rootDir": "./src",
-        "outDir": "./dist",
-        "strictPropertyInitialization": false,
-        "noUnusedLocals": false,
-        "noUnusedParameters": false,
-        "jsx": "react-jsx"
-    },
-    "exclude": [
-        "node_modules",
-        "**/__mocks__/*",
-        "**/__tests__/*",
-        "**/*.spec.ts",
-        "**/*.test.ts",
-        "dist"
-    ],
-    "include": ["src/**/*"]
-}

package/tsup.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from 'tsup';
-
-import { createPackageTsupConfig } from '@layerzerolabs/tsup-configuration';
-
-export default defineConfig(({ watch }) => ({
-    ...createPackageTsupConfig(),
-    clean: !watch,
-}));