@morpho-org/blue-sdk 1.0.2 → 1.0.4

package/lib/helpers/format/format.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = exports.PercentFormatter = exports.ShortFormatter = exports.CommasFormatter = exports.NumberFormatter = exports.CommonFormatter = exports.HexFormatter = exports.BaseFormatter = void 0;
+const ethers_1 = require("ethers");
+const locale_1 = require("../locale");
+var Format;
+(function (Format) {
+    Format["number"] = "number";
+    Format["commas"] = "commas";
+    Format["short"] = "short";
+    Format["hex"] = "hex";
+    Format["percent"] = "percent";
+})(Format || (Format = {}));
+String.prototype.insert = function (index, substr, fillWith) {
+    if (index < 0)
+        index = this.length + index;
+    let filler = "";
+    if (index < 0) {
+        if (fillWith)
+            filler = fillWith.repeat(-index).slice(index);
+        index = 0;
+    }
+    return this.slice(0, index) + substr + filler + this.slice(index);
+};
+const RANGES = [
+    {
+        minDecimals: 24,
+        symbol: "Y",
+    },
+    {
+        minDecimals: 21,
+        symbol: "Z",
+    },
+    {
+        minDecimals: 18,
+        symbol: "E",
+    },
+    {
+        minDecimals: 15,
+        symbol: "P",
+    },
+    {
+        minDecimals: 12,
+        symbol: "T",
+    },
+    {
+        minDecimals: 9,
+        symbol: "B",
+    },
+    {
+        minDecimals: 6,
+        symbol: "M",
+    },
+    {
+        minDecimals: 4,
+        power: 3,
+        symbol: "k",
+    },
+];
+const _formatShort = (bi, decimals, formatOptions) => {
+    const stringValue = bi.toString();
+    const params = RANGES.find((range) => stringValue.length > range.minDecimals + decimals);
+    if (params) {
+        return (_applyOptions(stringValue.insert(-((params.power ?? params.minDecimals) + decimals), ".", "0"), formatOptions) + params.symbol);
+    }
+    if (formatOptions.smallValuesWithCommas) {
+        return _formatCommas(bi, decimals, formatOptions);
+    }
+    return _applyOptions(stringValue.insert(-decimals, ".", "0"), formatOptions);
+};
+const _formatCommas = (bi, decimals, formatOptions) => {
+    const stringValue = decimals
+        ? bi.toString().insert(-decimals, ".", "0")
+        : bi.toString();
+    const [wholePart, decimalPart] = stringValue.split(".");
+    return _applyOptions(wholePart
+        .split("")
+        .reduce((formattedNumber, digit, i, arr) => `${formattedNumber}${!i || (arr.length - i) % 3 ? "" : ","}${digit}`, "") + (decimalPart ? "." + decimalPart : ""), formatOptions);
+};
+const _formatNumber = (bi, decimals, formatOptions) => {
+    if (decimals === 0)
+        return _applyOptions(bi.toString(), formatOptions);
+    return _applyOptions(bi.toString().insert(-decimals, ".", "0"), formatOptions);
+};
+const _withUnit = (value, unit) => {
+    switch (unit) {
+        case "$":
+            return `$${value}`;
+        case "":
+        case "%":
+            return `${value}${unit}`;
+        default:
+            return `${value} ${unit}`;
+    }
+};
+const _applyOptions = (value, formatOptions) => {
+    let [wholePart, decimalPart = ""] = value.split(".");
+    const isZero = value.match(/[1-9]/)?.index === undefined;
+    if (formatOptions.digits !== undefined) {
+        decimalPart = decimalPart + "0".repeat(formatOptions.digits);
+        decimalPart = decimalPart.slice(0, formatOptions.digits);
+    }
+    if (formatOptions.removeTrailingZero) {
+        decimalPart = decimalPart.replace(/\.?0+$/, "");
+    }
+    value = (wholePart || "0") + (decimalPart ? "." + decimalPart : "");
+    const { value: _value, decimalSymbol } = (0, locale_1.getEnUSNumberToLocalParts)(value, formatOptions.locale);
+    value = _value;
+    const firstNonZero = value.match(/[1-9]/);
+    if (firstNonZero?.index === undefined &&
+        formatOptions.digits &&
+        !isZero &&
+        formatOptions.readable)
+        return `< 0${decimalSymbol}${"0".repeat(formatOptions.digits - 1)}1`;
+    return value;
+};
+function formatBI(bi, decimals, formatOptions = { format: Format.hex }) {
+    if (formatOptions.format === Format.hex)
+        return bi.toString(16);
+    const maxBI = formatOptions.max !== undefined &&
+        (0, ethers_1.parseUnits)(formatOptions.max.toString(), decimals);
+    if (maxBI && bi > maxBI) {
+        return `> ${formatBI(maxBI, decimals, formatOptions)}`;
+    }
+    const minBI = formatOptions.min !== undefined &&
+        (0, ethers_1.parseUnits)(formatOptions.min.toString(), decimals);
+    if (minBI !== false && bi < minBI && bi !== 0n) {
+        return `< ${formatBI(minBI, decimals, formatOptions)}`;
+    }
+    let value;
+    const isNegative = bi < 0n;
+    const absBI = bi > 0n ? bi : -bi;
+    switch (formatOptions.format) {
+        case Format.commas:
+            value = _formatCommas(absBI, decimals, formatOptions);
+            break;
+        case Format.number:
+            value = _formatNumber(absBI, decimals, formatOptions);
+            break;
+        case Format.short:
+            value = _formatShort(absBI, decimals, formatOptions);
+            break;
+        case Format.percent:
+            value = _formatNumber(absBI * 100n, decimals, formatOptions);
+            break;
+    }
+    const formattedValue = (isNegative && !/^0\.0+$/.test(value)
+        ? "-"
+        : formatOptions.sign
+            ? "+"
+            : "") + value;
+    if (formatOptions.unit) {
+        return _withUnit(formattedValue, formatOptions.unit);
+    }
+    return formattedValue;
+}
+/**
+ * returns a string representation of a number, always in a decimal format (avoid the 1.34e-15 format for small numbers)
+ * @param number
+ */
+const safeNumberToString = (number) => {
+    const str = number.toString();
+    const [a, n] = str.split(/[eE]/);
+    if (a == null || n == null)
+        return str;
+    if (n[0] === "+") {
+        const [whole, decimal = ""] = a.split(".");
+        return whole + decimal + "0".repeat(+n - decimal.length);
+    }
+    if (n[0] === "-") {
+        const isNegative = a[0] === "-";
+        return ((isNegative ? "-" : "") +
+            "0." +
+            "0".repeat(-+n - 1) +
+            (isNegative ? a.slice(1) : a).split(".").join(""));
+    }
+    throw new Error(`Unhandled case: ${str}`);
+};
+class BaseFormatter {
+    constructor() { }
+    of(value, decimals) {
+        let _decimals;
+        if (typeof value === "number") {
+            const strNumber = safeNumberToString(value);
+            let [, d = ""] = strNumber.split(".");
+            _decimals = d.length;
+            value = (0, ethers_1.parseUnits)(strNumber, _decimals);
+        }
+        else {
+            _decimals = decimals;
+        }
+        return formatBI(value, _decimals, this._options);
+    }
+}
+exports.BaseFormatter = BaseFormatter;
+class HexFormatter extends BaseFormatter {
+    constructor() {
+        super(...arguments);
+        this._options = { format: Format.hex };
+    }
+}
+exports.HexFormatter = HexFormatter;
+class CommonFormatter extends BaseFormatter {
+    digits(_d) {
+        this._options.digits = _d;
+        return this;
+    }
+    removeTrailingZero() {
+        this._options.removeTrailingZero = true;
+        return this;
+    }
+    readable() {
+        this._options.readable = true;
+        return this;
+    }
+    min(_m) {
+        this._options.min = _m;
+        return this;
+    }
+    max(_m) {
+        this._options.max = _m;
+        return this;
+    }
+    sign() {
+        this._options.sign = true;
+        return this;
+    }
+    unit(_u) {
+        this._options.unit = _u;
+        return this;
+    }
+    locale(_l) {
+        this._options.locale = _l;
+        return this;
+    }
+}
+exports.CommonFormatter = CommonFormatter;
+class NumberFormatter extends CommonFormatter {
+    constructor() {
+        super(...arguments);
+        this._options = { format: Format.number };
+    }
+}
+exports.NumberFormatter = NumberFormatter;
+class CommasFormatter extends CommonFormatter {
+    constructor() {
+        super(...arguments);
+        this._options = { format: Format.commas };
+    }
+}
+exports.CommasFormatter = CommasFormatter;
+class ShortFormatter extends CommonFormatter {
+    constructor() {
+        super(...arguments);
+        this._options = { format: Format.short };
+    }
+    smallValuesWithCommas() {
+        this._options.smallValuesWithCommas = true;
+        return this;
+    }
+}
+exports.ShortFormatter = ShortFormatter;
+class PercentFormatter extends CommonFormatter {
+    constructor() {
+        super(...arguments);
+        this._options = { format: Format.percent };
+    }
+}
+exports.PercentFormatter = PercentFormatter;
+exports.format = {
+    /**
+     * Return the value as an integer in hex format
+     */
+    get hex() {
+        return new HexFormatter();
+    },
+    /**
+     * Return the value as a stringified number (12345.6789)
+     */
+    get number() {
+        return new NumberFormatter();
+    },
+    /**
+     * Return the value as a commas-separated stringified number (12,345.6789)
+     */
+    get commas() {
+        return new CommasFormatter();
+    },
+    /**
+     * Return the value as a shorted stringified number (12.3456789k)
+     */
+    get short() {
+        return new ShortFormatter();
+    },
+    /**
+     * Return the value as a percent based stringified number (10.00 instead of 0.1)
+     */
+    get percent() {
+        return new PercentFormatter();
+    },
+};

package/lib/helpers/format/format.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/helpers/format/format.test.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const format_1 = require("./format");
+describe("format", () => {
+    const number = 12345.6789;
+    const bigint = 123456789n;
+    const decimals = 4;
+    describe("hex", () => {
+        describe("should properly format number in hex format", () => {
+            it("without option", () => {
+                expect(format_1.format.hex.of(number)).toEqual((123456789).toString(16));
+            });
+        });
+        describe("should properly format bigint in hex format", () => {
+            it("without option", () => {
+                expect(format_1.format.hex.of(bigint, decimals)).toEqual((123456789).toString(16));
+            });
+        });
+    });
+    describe("number", () => {
+        describe("should properly format number in number format", () => {
+            it("without option", () => {
+                expect(format_1.format.number.of(number)).toEqual("12345.6789");
+            });
+            it("with digits", () => {
+                expect(format_1.format.number.digits(2).of(number)).toEqual("12345.67");
+            });
+            it("with min", () => {
+                expect(format_1.format.number.min(20000).of(number)).toEqual("< 20000.0000");
+            });
+            it("with max", () => {
+                expect(format_1.format.number.max(10000).of(number)).toEqual("> 10000.0000");
+            });
+            it("with sign", () => {
+                expect(format_1.format.number.sign().of(number)).toEqual("+12345.6789");
+            });
+            it("with unit", () => {
+                expect(format_1.format.number.unit("$").of(number)).toEqual("$12345.6789");
+            });
+            it("without trailing zeros", () => {
+                expect(format_1.format.number.digits(6).of(number)).toEqual("12345.678900");
+                expect(format_1.format.number.digits(6).removeTrailingZero().of(number)).toEqual("12345.6789");
+            });
+            it("with locale", () => {
+                expect(format_1.format.number.locale("fr-FR").of(number)).toEqual("12345,6789");
+            });
+        });
+        describe("should properly format bigint in number format", () => {
+            it("without option", () => {
+                expect(format_1.format.number.of(bigint, decimals)).toEqual("12345.6789");
+            });
+            it("with digits", () => {
+                expect(format_1.format.number.digits(2).of(bigint, decimals)).toEqual("12345.67");
+            });
+            it("with min", () => {
+                expect(format_1.format.number.min(20000).of(bigint, decimals)).toEqual("< 20000.0000");
+            });
+            it("with max", () => {
+                expect(format_1.format.number.max(10000).of(bigint, decimals)).toEqual("> 10000.0000");
+            });
+            it("with sign", () => {
+                expect(format_1.format.number.sign().of(bigint, decimals)).toEqual("+12345.6789");
+            });
+            it("with unit", () => {
+                expect(format_1.format.number.unit("$").of(bigint, decimals)).toEqual("$12345.6789");
+            });
+            it("without trailing zeros", () => {
+                expect(format_1.format.number.digits(6).of(bigint, decimals)).toEqual("12345.678900");
+                expect(format_1.format.number.digits(6).removeTrailingZero().of(bigint, decimals)).toEqual("12345.6789");
+            });
+            it("with locale", () => {
+                expect(format_1.format.number.locale("fr-FR").of(bigint, decimals)).toEqual("12345,6789");
+            });
+        });
+    });
+    describe("short", () => {
+        describe("should properly format number in short format", () => {
+            it("without option", () => {
+                expect(format_1.format.short.of(number)).toEqual("12.3456789k");
+            });
+            it("with digits", () => {
+                expect(format_1.format.short.digits(2).of(number)).toEqual("12.34k");
+            });
+            it("with min", () => {
+                expect(format_1.format.short.min(20000).of(number)).toEqual("< 20.0000000k");
+            });
+            it("with max", () => {
+                expect(format_1.format.short.max(10000).of(number)).toEqual("> 10.0000000k");
+            });
+            it("with sign", () => {
+                expect(format_1.format.short.sign().of(number)).toEqual("+12.3456789k");
+            });
+            it("with unit", () => {
+                expect(format_1.format.short.unit("€").of(number)).toEqual("12.3456789k €");
+            });
+            it("without trailing zeros", () => {
+                expect(format_1.format.short.digits(8).of(number)).toEqual("12.34567890k");
+                expect(format_1.format.short.digits(8).removeTrailingZero().of(number)).toEqual("12.3456789k");
+            });
+            it("with small numbers with commas", () => {
+                expect(format_1.format.short.smallValuesWithCommas().of(number / 10)).toEqual("1,234.56789");
+            });
+            it("with locale", () => {
+                expect(format_1.format.short.locale("fr-FR").of(number)).toEqual("12,3456789k");
+            });
+        });
+        describe("should properly format bigint in short format", () => {
+            it("without option", () => {
+                expect(format_1.format.short.of(bigint, decimals)).toEqual("12.3456789k");
+            });
+            it("with digits", () => {
+                expect(format_1.format.short.digits(2).of(bigint, decimals)).toEqual("12.34k");
+            });
+            it("with min", () => {
+                expect(format_1.format.short.min(20000).of(bigint, decimals)).toEqual("< 20.0000000k");
+            });
+            it("with max", () => {
+                expect(format_1.format.short.max(10000).of(bigint, decimals)).toEqual("> 10.0000000k");
+            });
+            it("with sign", () => {
+                expect(format_1.format.short.sign().of(bigint, decimals)).toEqual("+12.3456789k");
+            });
+            it("with unit", () => {
+                expect(format_1.format.short.unit("€").of(bigint, decimals)).toEqual("12.3456789k €");
+            });
+            it("without trailing zeros", () => {
+                expect(format_1.format.short.digits(8).of(bigint, decimals)).toEqual("12.34567890k");
+                expect(format_1.format.short.digits(8).removeTrailingZero().of(bigint, decimals)).toEqual("12.3456789k");
+            });
+            it("with locale", () => {
+                expect(format_1.format.short.locale("fr-FR").of(bigint, decimals)).toEqual("12,3456789k");
+            });
+            it("with small numbers with commas", () => {
+                expect(format_1.format.short.smallValuesWithCommas().of(bigint, decimals + 1)).toEqual("1,234.56789");
+            });
+            it("with small numbers with commas with locale", () => {
+                expect(format_1.format.short
+                    .smallValuesWithCommas()
+                    .locale("fr-FR")
+                    .of(bigint, decimals + 1)
+                // the correct space in fr-FR is narrow no-break space (U+202F)
+                ).toEqual("1\u202F234,56789");
+            });
+        });
+    });
+    describe("commas", () => {
+        describe("should properly format number in commas format", () => {
+            it("without option", () => {
+                expect(format_1.format.commas.of(number)).toEqual("12,345.6789");
+            });
+            it("with digits", () => {
+                expect(format_1.format.commas.digits(2).of(number)).toEqual("12,345.67");
+            });
+            it("with min", () => {
+                expect(format_1.format.commas.min(20000).of(number)).toEqual("< 20,000.0000");
+            });
+            it("with max", () => {
+                expect(format_1.format.commas.max(10000).of(number)).toEqual("> 10,000.0000");
+            });
+            it("with sign", () => {
+                expect(format_1.format.commas.sign().of(number)).toEqual("+12,345.6789");
+            });
+            it("with unit", () => {
+                expect(format_1.format.commas.unit("ETH").of(number)).toEqual("12,345.6789 ETH");
+            });
+            it("without trailing zeros", () => {
+                expect(format_1.format.commas.digits(6).of(number)).toEqual("12,345.678900");
+                expect(format_1.format.commas.digits(6).removeTrailingZero().of(number)).toEqual("12,345.6789");
+            });
+            it("with locale", () => {
+                expect(format_1.format.commas.locale("fr-FR").of(number)).toEqual("12\u202F345,6789");
+            });
+        });
+        describe("should properly format bigint in commas format", () => {
+            it("without option", () => {
+                expect(format_1.format.commas.of(bigint, decimals)).toEqual("12,345.6789");
+            });
+            it("with digits", () => {
+                expect(format_1.format.commas.digits(2).of(bigint, decimals)).toEqual("12,345.67");
+            });
+            it("with min", () => {
+                expect(format_1.format.commas.min(20000).of(bigint, decimals)).toEqual("< 20,000.0000");
+            });
+            it("with max", () => {
+                expect(format_1.format.commas.max(10000).of(bigint, decimals)).toEqual("> 10,000.0000");
+            });
+            it("with sign", () => {
+                expect(format_1.format.commas.sign().of(bigint, decimals)).toEqual("+12,345.6789");
+            });
+            it("with unit", () => {
+                expect(format_1.format.commas.unit("ETH").of(bigint, decimals)).toEqual("12,345.6789 ETH");
+            });
+            it("without trailing zeros", () => {
+                expect(format_1.format.commas.digits(6).of(bigint, decimals)).toEqual("12,345.678900");
+                expect(format_1.format.commas.digits(6).removeTrailingZero().of(bigint, decimals)).toEqual("12,345.6789");
+            });
+            it("with locale", () => {
+                // the correct space in fr-FR is narrow no-break space (U+202F)
+                expect(format_1.format.commas.locale("fr-FR").of(bigint, decimals)).toEqual("12\u202F345,6789");
+            });
+        });
+    });
+    describe("percent", () => {
+        describe("should properly format number in percent format", () => {
+            it("without option", () => {
+                expect(format_1.format.percent.of(number)).toEqual("1234567.8900");
+            });
+            it("with digits", () => {
+                expect(format_1.format.percent.digits(1).of(number)).toEqual("1234567.8");
+            });
+            it("with min", () => {
+                expect(format_1.format.percent.min(20000).of(number)).toEqual("< 2000000.0000");
+            });
+            it("with max", () => {
+                expect(format_1.format.percent.max(10000).of(number)).toEqual("> 1000000.0000");
+            });
+            it("with sign", () => {
+                expect(format_1.format.percent.sign().of(number)).toEqual("+1234567.8900");
+            });
+            it("with unit", () => {
+                expect(format_1.format.percent.unit("%").of(number)).toEqual("1234567.8900%");
+            });
+            it("without trailing zeros", () => {
+                expect(format_1.format.percent.removeTrailingZero().of(number)).toEqual("1234567.89");
+            });
+            it("with locale", () => {
+                expect(format_1.format.percent.locale("fr-FR").of(number)).toEqual("1234567,8900");
+            });
+        });
+        describe("should properly format bigint in percent format", () => {
+            it("without option", () => {
+                expect(format_1.format.percent.of(bigint, decimals)).toEqual("1234567.8900");
+            });
+            it("with digits", () => {
+                expect(format_1.format.percent.digits(1).of(bigint, decimals)).toEqual("1234567.8");
+            });
+            it("with min", () => {
+                expect(format_1.format.percent.min(20000).of(bigint, decimals)).toEqual("< 2000000.0000");
+            });
+            it("with max", () => {
+                expect(format_1.format.percent.max(10000).of(bigint, decimals)).toEqual("> 1000000.0000");
+            });
+            it("with sign", () => {
+                expect(format_1.format.percent.sign().of(bigint, decimals)).toEqual("+1234567.8900");
+            });
+            it("with unit", () => {
+                expect(format_1.format.percent.unit("%").of(bigint, decimals)).toEqual("1234567.8900%");
+            });
+            it("without trailing zeros", () => {
+                expect(format_1.format.percent.removeTrailingZero().of(bigint, decimals)).toEqual("1234567.89");
+            });
+            it("with locale", () => {
+                expect(format_1.format.percent.locale("fr-FR").of(bigint, decimals)).toEqual("1234567,8900");
+            });
+        });
+    });
+});

package/lib/helpers/format/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./format"), exports);

package/lib/helpers/getChecksumedAddress.d.ts

@@ -0,0 +1,7 @@
+import { AddressLike } from "ethers";
+/**
+ * Transform an AddressLike into a checksumed address
+ *
+ * @param address Address to transform
+ */
+export declare const getChecksumedAddress: (address: AddressLike) => Promise<string>;

package/lib/helpers/getChecksumedAddress.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChecksumedAddress = void 0;
+const ethers_1 = require("ethers");
+/**
+ * Transform an AddressLike into a checksumed address
+ *
+ * @param address Address to transform
+ */
+const getChecksumedAddress = async (address) => {
+    const awaited = await address;
+    // Ethers getAddress function is throwing an error if the address is already checksumed
+    if (typeof awaited === "string")
+        return (0, ethers_1.getAddress)(awaited.toLowerCase());
+    return (0, ethers_1.getAddress)((await awaited.getAddress()).toLowerCase());
+};
+exports.getChecksumedAddress = getChecksumedAddress;

package/lib/helpers/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./getChecksumedAddress"), exports);
+__exportStar(require("./isZeroAddressOrUnset"), exports);
+__exportStar(require("./locale"), exports);
+__exportStar(require("./format"), exports);

package/{src/helpers/isZeroAddressOrUnset.ts → lib/helpers/isZeroAddressOrUnset.d.ts}

@@ -1,13 +1,7 @@
-import { ZeroAddress } from "ethers";
-
 /**
  * Check if an address is the zero address, null, or undefined.
  *
  * @param address - The address to check, which can be a valid address, null, or undefined.
  * @returns True if the address is zero, null, or undefined; otherwise, false.
  */
-export function isZeroAddressOrUnset(
-  address: string | null | undefined
-): boolean {
-  return address === undefined || address === null || address === ZeroAddress;
-}
+export declare function isZeroAddressOrUnset(address: string | null | undefined): boolean;

package/lib/helpers/isZeroAddressOrUnset.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isZeroAddressOrUnset = void 0;
+const ethers_1 = require("ethers");
+/**
+ * Check if an address is the zero address, null, or undefined.
+ *
+ * @param address - The address to check, which can be a valid address, null, or undefined.
+ * @returns True if the address is zero, null, or undefined; otherwise, false.
+ */
+function isZeroAddressOrUnset(address) {
+    return address === undefined || address === null || address === ethers_1.ZeroAddress;
+}
+exports.isZeroAddressOrUnset = isZeroAddressOrUnset;