@berachain/berajs 0.1.1 → 0.1.2

package/src/errors/assert.ts

@@ -0,0 +1,144 @@
+import { type Address, isAddress, type PublicClient } from "viem";
+
+import { InvalidArgumentError } from "./InvalidArgumentError";
+
+function _isDefined<T>(value: T): value is NonNullable<T> {
+  return value !== undefined && value !== null;
+}
+
+type _AssertFn<T> = (value: T) => { expectedType: string; isValid: boolean };
+
+/**
+ * Internal assertion function.
+ * @throws An InvalidArgumentError if the value is not valid.
+ */
+function _assert<T>({
+  value,
+  property,
+  fn,
+}: {
+  value: T;
+  property: string;
+  fn: _AssertFn<T>;
+}) {
+  const result = fn(value);
+  if (!result.isValid) {
+    throw new InvalidArgumentError({
+      property,
+      value,
+      expected: result.expectedType,
+    });
+  }
+}
+
+function _assertDefined<T>({
+  value,
+  property,
+  fn,
+}: {
+  value: T;
+  property: string;
+  fn: (value: T) => { expectedType: string; isValid: boolean };
+}) {
+  _assert({
+    value,
+    property,
+    fn: (value) => {
+      const isDefined = _isDefined(value);
+      const { isValid, expectedType } = fn(value);
+      return {
+        expectedType,
+        isValid: isDefined && isValid,
+      };
+    },
+  });
+}
+
+/**
+ * Asserts that a value is defined.
+ * @throws An InvalidArgumentError if the value is undefined or null.
+ */
+export function assertDefined<T>(
+  /**
+   * The value to assert.
+   */
+  value: T,
+  /**
+   * The property name.
+   */
+  property: string,
+): asserts value is NonNullable<T> {
+  _assertDefined({
+    value,
+    property,
+    fn: (value) => ({ expectedType: "defined", isValid: _isDefined(value) }),
+  });
+}
+
+/**
+ * Asserts that a value is a PublicClient.
+ * @throws An InvalidArgumentError if the value is undefined or not a PublicClient.
+ */
+export function assertPublicClient(
+  /**
+   * The value to assert.
+   */
+  value: PublicClient | undefined,
+  /**
+   * The property name.
+   */
+  property: string = "publicClient",
+): asserts value is PublicClient {
+  // there's no current way to check if a value is a PublicClient, so we just assert it's defined and `value: PublicClient` will do the rest
+  assertDefined(value, property);
+}
+
+/**
+ * Asserts that a value is an address (20 bytes).
+ * @throws An InvalidArgumentError if the value is undefined, null, not a string, or not an address.
+ */
+export function assertAddress(
+  /**
+   * The value to assert.
+   */
+  value: string | undefined,
+  /**
+   * The property name.
+   */
+  property: string,
+): asserts value is Address {
+  _assertDefined({
+    value,
+    property,
+    fn: (value) => ({
+      expectedType: "Address",
+      isValid: typeof value === "string" && isAddress(value),
+    }),
+  });
+}
+
+/**
+ * Asserts that a value is a number greater than 0.
+ * @throws An InvalidArgumentError if the value is undefined, null, not a string or number, or not a number greater than 0.
+ */
+export function assertAmount(
+  /**
+   * The value to assert.
+   */
+  value: unknown,
+  /**
+   * The property name.
+   */
+  property: string,
+): asserts value is string | number {
+  _assertDefined({
+    value,
+    property,
+    fn: (value) => ({
+      expectedType: "number",
+      isValid:
+        (typeof value === "string" || typeof value === "number") &&
+        Number(value) > 0,
+    }),
+  });
+}

package/src/errors/assert.unit.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it } from "vitest";
+
+import { assertAddress, assertAmount, assertDefined } from "./assert";
+import { InvalidArgumentError } from "./InvalidArgumentError";
+
+describe("assertDefined", () => {
+  it("does not throw when value is defined", () => {
+    expect(() => assertDefined("value", "testProp")).not.toThrow();
+    expect(() => assertDefined(0, "testProp")).not.toThrow();
+    expect(() => assertDefined(false, "testProp")).not.toThrow();
+    expect(() => assertDefined([], "testProp")).not.toThrow();
+  });
+
+  it("throws InvalidArgumentError when value is undefined", () => {
+    expect(() => assertDefined(undefined, "testProp")).toThrow(
+      InvalidArgumentError,
+    );
+    try {
+      assertDefined(undefined, "testProp");
+    } catch (e: unknown) {
+      expect(e).toBeInstanceOf(InvalidArgumentError);
+      if (e instanceof InvalidArgumentError) {
+        expect(e.property).toBe("testProp");
+        expect(e.value).toBe(undefined);
+        expect(e.expected).toBe("defined");
+      }
+    }
+  });
+
+  it("throws InvalidArgumentError when value is null", () => {
+    expect(() => assertDefined(null, "testProp")).toThrow(InvalidArgumentError);
+    try {
+      assertDefined(null, "testProp");
+    } catch (e: unknown) {
+      expect(e).toBeInstanceOf(InvalidArgumentError);
+      if (e instanceof InvalidArgumentError) {
+        expect(e.property).toBe("testProp");
+        expect(e.value).toBe(null);
+        expect(e.expected).toBe("defined");
+      }
+    }
+  });
+});
+
+describe("assertAddress", () => {
+  const validAddress = "0x0000000000000000000000000000000000000001";
+  const invalidAddress = "0x123";
+
+  it("does not throw for a valid address", () => {
+    expect(() => assertAddress(validAddress, "addr")).not.toThrow();
+  });
+
+  it("throws InvalidArgumentError for undefined", () => {
+    expect(() => assertAddress(undefined, "addr")).toThrow(
+      InvalidArgumentError,
+    );
+  });
+
+  it("throws InvalidArgumentError for null", () => {
+    expect(() => assertAddress(null, "addr")).toThrow(InvalidArgumentError);
+  });
+
+  it("throws InvalidArgumentError for non-string", () => {
+    expect(() => assertAddress(123, "addr")).toThrow(InvalidArgumentError);
+    expect(() => assertAddress({}, "addr")).toThrow(InvalidArgumentError);
+  });
+
+  it("throws InvalidArgumentError for invalid address string", () => {
+    expect(() => assertAddress(invalidAddress, "addr")).toThrow(
+      InvalidArgumentError,
+    );
+  });
+});
+
+describe("assertAmount", () => {
+  const validAmount = "1";
+  const invalidAmount = "-1";
+
+  it("does not throw for a valid amount", () => {
+    expect(() => assertAmount(validAmount, "amount")).not.toThrow();
+  });
+
+  it("throws InvalidArgumentError for undefined", () => {
+    expect(() => assertAmount(undefined, "amount")).toThrow(
+      InvalidArgumentError,
+    );
+  });
+
+  it("throws InvalidArgumentError for null", () => {
+    expect(() => assertAddress(null, "addr")).toThrow(InvalidArgumentError);
+  });
+
+  it("throws InvalidArgumentError for invalid amount", () => {
+    expect(() => assertAddress(invalidAmount, "amount")).toThrow(
+      InvalidArgumentError,
+    );
+  });
+
+  it("throws InvalidArgumentError for amount less than or equal to 0", () => {
+    expect(() => assertAmount("-1", "amount")).toThrow(InvalidArgumentError);
+    expect(() => assertAmount(-1, "amount")).toThrow(InvalidArgumentError);
+
+    expect(() => assertAmount("0", "amount")).toThrow(InvalidArgumentError);
+    expect(() => assertAmount(0, "amount")).toThrow(InvalidArgumentError);
+  });
+
+  it("throws InvalidArgumentError for non-numeric value", () => {
+    expect(() => assertAmount("0.", "amount")).toThrow(InvalidArgumentError);
+  });
+});