@obolnetwork/obol-sdk 1.0.4 → 1.0.6

package/dist/index.js

@@ -115,8 +115,8 @@ var FORK_MAPPING;
     FORK_MAPPING[FORK_MAPPING["0x80000069"] = 3] = "0x80000069";
 })(FORK_MAPPING || (FORK_MAPPING = {}));
 const dkg_algorithm = "default";
-const config_version = "v1.5.0";
-const SDK_VERSION = "1.0.0";
+const config_version = "v1.7.0";
+const SDK_VERSION = "1.0.3"; //should we read it from package.json?
 const DEFAULT_BASE_URL = "https://api.obol.tech";
 const DEFAULT_CHAIN_ID = 5;
 
@@ -388,14 +388,7 @@ function output(out, instance) {
     }
 }
 _assert.output = output;
-const assert = {
-    number,
-    bool,
-    bytes,
-    hash,
-    exists,
-    output,
-};
+const assert = { number, bool, bytes, hash, exists, output };
 _assert.default = assert;
 
 var utils = {};
@@ -434,7 +427,7 @@ crypto$1.crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? glo
 	exports.isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
 	if (!exports.isLE)
 	    throw new Error('Non little-endian hardware is not supported');
-	const hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
+	const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
 	/**
 	 * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
 	 */
@@ -534,10 +527,9 @@ crypto$1.crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? glo
 	    }
 	}
 	exports.Hash = Hash;
-	// Check if object doens't have custom constructor (like Uint8Array/Array)
-	const isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;
+	const toStr = {}.toString;
 	function checkOpts(defaults, opts) {
-	    if (opts !== undefined && (typeof opts !== 'object' || !isPlainObject(opts)))
+	    if (opts !== undefined && toStr.call(opts) !== '[object Object]')
 	        throw new Error('Options should be object or undefined');
 	    const merged = Object.assign(defaults, opts);
 	    return merged;
@@ -616,7 +608,7 @@ class SHA2 extends utils_js_1$1.Hash {
         this.view = (0, utils_js_1$1.createView)(this.buffer);
     }
     update(data) {
-        _assert_js_1.default.exists(this);
+        (0, _assert_js_1.exists)(this);
         const { view, buffer, blockLen } = this;
         data = (0, utils_js_1$1.toBytes)(data);
         const len = data.length;
@@ -642,8 +634,8 @@ class SHA2 extends utils_js_1$1.Hash {
         return this;
     }
     digestInto(out) {
-        _assert_js_1.default.exists(this);
-        _assert_js_1.default.output(out, this);
+        (0, _assert_js_1.exists)(this);
+        (0, _assert_js_1.output)(out, this);
         this.finished = true;
         // Padding
         // We can avoid allocation of buffer for padding completely if it
@@ -704,6 +696,8 @@ Object.defineProperty(sha256, "__esModule", { value: true });
 sha256.sha224 = sha256.sha256 = void 0;
 const _sha2_js_1 = _sha2;
 const utils_js_1 = utils;
+// SHA2-256 need to try 2^128 hashes to execute birthday attack.
+// BTC network is doing 2^67 hashes/sec as per early 2023.
 // Choice: a ? b : c
 const Chi = (a, b, c) => (a & b) ^ (~a & c);
 // Majority function, true if any two inpust is true
@@ -711,7 +705,7 @@ const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
 // Round constants:
 // first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)
 // prettier-ignore
-const SHA256_K = new Uint32Array([
+const SHA256_K = /* @__PURE__ */ new Uint32Array([
     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
@@ -723,12 +717,12 @@ const SHA256_K = new Uint32Array([
 ]);
 // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
 // prettier-ignore
-const IV = new Uint32Array([
+const IV = /* @__PURE__ */ new Uint32Array([
     0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
 ]);
 // Temporary buffer, not used to store anything between runs
 // Named this way because it matches specification.
-const SHA256_W = new Uint32Array(64);
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
 class SHA256 extends _sha2_js_1.SHA2 {
     constructor() {
         super(64, 32, 8, false);
@@ -7984,12 +7978,12 @@ vectorComposite.VectorCompositeType = VectorCompositeType;
  * @returns The config hash or he definition hash in of the corresponding cluster definition
  */
 const clusterConfigOrDefinitionHash = (cluster, configOnly) => {
-    const definitionType = clusterDefinitionContainerTypeV1X5(configOnly);
-    const val = hashClusterDefinitionV1X5(cluster, configOnly);
+    const definitionType = clusterDefinitionContainerTypeV1X7(configOnly);
+    const val = hashClusterDefinitionV1X7(cluster, configOnly);
     return ('0x' + Buffer.from(definitionType.hashTreeRoot(val).buffer).toString('hex'));
 };
-const hashClusterDefinitionV1X5 = (cluster, configOnly) => {
-    const definitionType = clusterDefinitionContainerTypeV1X5(configOnly);
+const hashClusterDefinitionV1X7 = (cluster, configOnly) => {
+    const definitionType = clusterDefinitionContainerTypeV1X7(configOnly);
     const val = definitionType.defaultValue();
     //order should be same as charon https://github.com/ObolNetwork/charon/blob/d00b31e6465a260a43ce40f15c47fb5a5b009042/cluster/ssz.go#L285
     val.uuid = strToUint8Array(cluster.uuid);
@@ -8070,7 +8064,7 @@ const newOperatorContainerType = (configOnly) => {
  * @param cluster ClusterDefinition to calculate the type from
  * @returns SSZ Containerized type of cluster input
  */
-const clusterDefinitionContainerTypeV1X5 = (configOnly) => {
+const clusterDefinitionContainerTypeV1X7 = (configOnly) => {
     let returnedContainerType = {
         uuid: new lib$1.ByteListType(64),
         name: new lib$1.ByteListType(256),
@@ -15483,324 +15477,344 @@ function validateDefinition(data) {
  * 
  */
 
-const ARRAY_BUFFER_NAME = "[object ArrayBuffer]";
-class BufferSourceConverter {
-    static isArrayBuffer(data) {
-        return Object.prototype.toString.call(data) === ARRAY_BUFFER_NAME;
-    }
-    static toArrayBuffer(data) {
-        if (this.isArrayBuffer(data)) {
-            return data;
-        }
-        if (data.byteLength === data.buffer.byteLength) {
-            return data.buffer;
-        }
-        return this.toUint8Array(data).slice().buffer;
-    }
-    static toUint8Array(data) {
-        return this.toView(data, Uint8Array);
-    }
-    static toView(data, type) {
-        if (data.constructor === type) {
-            return data;
-        }
-        if (this.isArrayBuffer(data)) {
-            return new type(data);
-        }
-        if (this.isArrayBufferView(data)) {
-            return new type(data.buffer, data.byteOffset, data.byteLength);
-        }
-        throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
-    }
-    static isBufferSource(data) {
-        return this.isArrayBufferView(data)
-            || this.isArrayBuffer(data);
-    }
-    static isArrayBufferView(data) {
-        return ArrayBuffer.isView(data)
-            || (data && this.isArrayBuffer(data.buffer));
-    }
-    static isEqual(a, b) {
-        const aView = BufferSourceConverter.toUint8Array(a);
-        const bView = BufferSourceConverter.toUint8Array(b);
-        if (aView.length !== bView.byteLength) {
-            return false;
-        }
-        for (let i = 0; i < aView.length; i++) {
-            if (aView[i] !== bView[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    static concat(...args) {
-        if (Array.isArray(args[0])) {
-            const buffers = args[0];
-            let size = 0;
-            for (const buffer of buffers) {
-                size += buffer.byteLength;
-            }
-            const res = new Uint8Array(size);
-            let offset = 0;
-            for (const buffer of buffers) {
-                const view = this.toUint8Array(buffer);
-                res.set(view, offset);
-                offset += view.length;
-            }
-            if (args[1]) {
-                return this.toView(res, args[1]);
-            }
-            return res.buffer;
-        }
-        else {
-            return this.concat(args);
-        }
-    }
+const ARRAY_BUFFER_NAME = "[object ArrayBuffer]";
+class BufferSourceConverter {
+    static isArrayBuffer(data) {
+        return Object.prototype.toString.call(data) === ARRAY_BUFFER_NAME;
+    }
+    static toArrayBuffer(data) {
+        if (this.isArrayBuffer(data)) {
+            return data;
+        }
+        if (data.byteLength === data.buffer.byteLength) {
+            return data.buffer;
+        }
+        if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+            return data.buffer;
+        }
+        return this.toUint8Array(data.buffer)
+            .slice(data.byteOffset, data.byteOffset + data.byteLength)
+            .buffer;
+    }
+    static toUint8Array(data) {
+        return this.toView(data, Uint8Array);
+    }
+    static toView(data, type) {
+        if (data.constructor === type) {
+            return data;
+        }
+        if (this.isArrayBuffer(data)) {
+            return new type(data);
+        }
+        if (this.isArrayBufferView(data)) {
+            return new type(data.buffer, data.byteOffset, data.byteLength);
+        }
+        throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
+    }
+    static isBufferSource(data) {
+        return this.isArrayBufferView(data)
+            || this.isArrayBuffer(data);
+    }
+    static isArrayBufferView(data) {
+        return ArrayBuffer.isView(data)
+            || (data && this.isArrayBuffer(data.buffer));
+    }
+    static isEqual(a, b) {
+        const aView = BufferSourceConverter.toUint8Array(a);
+        const bView = BufferSourceConverter.toUint8Array(b);
+        if (aView.length !== bView.byteLength) {
+            return false;
+        }
+        for (let i = 0; i < aView.length; i++) {
+            if (aView[i] !== bView[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static concat(...args) {
+        let buffers;
+        if (Array.isArray(args[0]) && !(args[1] instanceof Function)) {
+            buffers = args[0];
+        }
+        else if (Array.isArray(args[0]) && args[1] instanceof Function) {
+            buffers = args[0];
+        }
+        else {
+            if (args[args.length - 1] instanceof Function) {
+                buffers = args.slice(0, args.length - 1);
+            }
+            else {
+                buffers = args;
+            }
+        }
+        let size = 0;
+        for (const buffer of buffers) {
+            size += buffer.byteLength;
+        }
+        const res = new Uint8Array(size);
+        let offset = 0;
+        for (const buffer of buffers) {
+            const view = this.toUint8Array(buffer);
+            res.set(view, offset);
+            offset += view.length;
+        }
+        if (args[args.length - 1] instanceof Function) {
+            return this.toView(res, args[args.length - 1]);
+        }
+        return res.buffer;
+    }
 }
 
-class Utf8Converter {
-    static fromString(text) {
-        const s = unescape(encodeURIComponent(text));
-        const uintArray = new Uint8Array(s.length);
-        for (let i = 0; i < s.length; i++) {
-            uintArray[i] = s.charCodeAt(i);
-        }
-        return uintArray.buffer;
-    }
-    static toString(buffer) {
-        const buf = BufferSourceConverter.toUint8Array(buffer);
-        let encodedString = "";
-        for (let i = 0; i < buf.length; i++) {
-            encodedString += String.fromCharCode(buf[i]);
-        }
-        const decodedString = decodeURIComponent(escape(encodedString));
-        return decodedString;
-    }
-}
-class Utf16Converter {
-    static toString(buffer, littleEndian = false) {
-        const arrayBuffer = BufferSourceConverter.toArrayBuffer(buffer);
-        const dataView = new DataView(arrayBuffer);
-        let res = "";
-        for (let i = 0; i < arrayBuffer.byteLength; i += 2) {
-            const code = dataView.getUint16(i, littleEndian);
-            res += String.fromCharCode(code);
-        }
-        return res;
-    }
-    static fromString(text, littleEndian = false) {
-        const res = new ArrayBuffer(text.length * 2);
-        const dataView = new DataView(res);
-        for (let i = 0; i < text.length; i++) {
-            dataView.setUint16(i * 2, text.charCodeAt(i), littleEndian);
-        }
-        return res;
-    }
-}
-class Convert {
-    static isHex(data) {
-        return typeof data === "string"
-            && /^[a-z0-9]+$/i.test(data);
-    }
-    static isBase64(data) {
-        return typeof data === "string"
-            && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(data);
-    }
-    static isBase64Url(data) {
-        return typeof data === "string"
-            && /^[a-zA-Z0-9-_]+$/i.test(data);
-    }
-    static ToString(buffer, enc = "utf8") {
-        const buf = BufferSourceConverter.toUint8Array(buffer);
-        switch (enc.toLowerCase()) {
-            case "utf8":
-                return this.ToUtf8String(buf);
-            case "binary":
-                return this.ToBinary(buf);
-            case "hex":
-                return this.ToHex(buf);
-            case "base64":
-                return this.ToBase64(buf);
-            case "base64url":
-                return this.ToBase64Url(buf);
-            case "utf16le":
-                return Utf16Converter.toString(buf, true);
-            case "utf16":
-            case "utf16be":
-                return Utf16Converter.toString(buf);
-            default:
-                throw new Error(`Unknown type of encoding '${enc}'`);
-        }
-    }
-    static FromString(str, enc = "utf8") {
-        if (!str) {
-            return new ArrayBuffer(0);
-        }
-        switch (enc.toLowerCase()) {
-            case "utf8":
-                return this.FromUtf8String(str);
-            case "binary":
-                return this.FromBinary(str);
-            case "hex":
-                return this.FromHex(str);
-            case "base64":
-                return this.FromBase64(str);
-            case "base64url":
-                return this.FromBase64Url(str);
-            case "utf16le":
-                return Utf16Converter.fromString(str, true);
-            case "utf16":
-            case "utf16be":
-                return Utf16Converter.fromString(str);
-            default:
-                throw new Error(`Unknown type of encoding '${enc}'`);
-        }
-    }
-    static ToBase64(buffer) {
-        const buf = BufferSourceConverter.toUint8Array(buffer);
-        if (typeof btoa !== "undefined") {
-            const binary = this.ToString(buf, "binary");
-            return btoa(binary);
-        }
-        else {
-            return Buffer.from(buf).toString("base64");
-        }
-    }
-    static FromBase64(base64) {
-        const formatted = this.formatString(base64);
-        if (!formatted) {
-            return new ArrayBuffer(0);
-        }
-        if (!Convert.isBase64(formatted)) {
-            throw new TypeError("Argument 'base64Text' is not Base64 encoded");
-        }
-        if (typeof atob !== "undefined") {
-            return this.FromBinary(atob(formatted));
-        }
-        else {
-            return new Uint8Array(Buffer.from(formatted, "base64")).buffer;
-        }
-    }
-    static FromBase64Url(base64url) {
-        const formatted = this.formatString(base64url);
-        if (!formatted) {
-            return new ArrayBuffer(0);
-        }
-        if (!Convert.isBase64Url(formatted)) {
-            throw new TypeError("Argument 'base64url' is not Base64Url encoded");
-        }
-        return this.FromBase64(this.Base64Padding(formatted.replace(/\-/g, "+").replace(/\_/g, "/")));
-    }
-    static ToBase64Url(data) {
-        return this.ToBase64(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, "");
-    }
-    static FromUtf8String(text, encoding = Convert.DEFAULT_UTF8_ENCODING) {
-        switch (encoding) {
-            case "ascii":
-                return this.FromBinary(text);
-            case "utf8":
-                return Utf8Converter.fromString(text);
-            case "utf16":
-            case "utf16be":
-                return Utf16Converter.fromString(text);
-            case "utf16le":
-            case "usc2":
-                return Utf16Converter.fromString(text, true);
-            default:
-                throw new Error(`Unknown type of encoding '${encoding}'`);
-        }
-    }
-    static ToUtf8String(buffer, encoding = Convert.DEFAULT_UTF8_ENCODING) {
-        switch (encoding) {
-            case "ascii":
-                return this.ToBinary(buffer);
-            case "utf8":
-                return Utf8Converter.toString(buffer);
-            case "utf16":
-            case "utf16be":
-                return Utf16Converter.toString(buffer);
-            case "utf16le":
-            case "usc2":
-                return Utf16Converter.toString(buffer, true);
-            default:
-                throw new Error(`Unknown type of encoding '${encoding}'`);
-        }
-    }
-    static FromBinary(text) {
-        const stringLength = text.length;
-        const resultView = new Uint8Array(stringLength);
-        for (let i = 0; i < stringLength; i++) {
-            resultView[i] = text.charCodeAt(i);
-        }
-        return resultView.buffer;
-    }
-    static ToBinary(buffer) {
-        const buf = BufferSourceConverter.toUint8Array(buffer);
-        let res = "";
-        for (let i = 0; i < buf.length; i++) {
-            res += String.fromCharCode(buf[i]);
-        }
-        return res;
-    }
-    static ToHex(buffer) {
-        const buf = BufferSourceConverter.toUint8Array(buffer);
-        const splitter = "";
-        const res = [];
-        const len = buf.length;
-        for (let i = 0; i < len; i++) {
-            const char = buf[i].toString(16).padStart(2, "0");
-            res.push(char);
-        }
-        return res.join(splitter);
-    }
-    static FromHex(hexString) {
-        let formatted = this.formatString(hexString);
-        if (!formatted) {
-            return new ArrayBuffer(0);
-        }
-        if (!Convert.isHex(formatted)) {
-            throw new TypeError("Argument 'hexString' is not HEX encoded");
-        }
-        if (formatted.length % 2) {
-            formatted = `0${formatted}`;
-        }
-        const res = new Uint8Array(formatted.length / 2);
-        for (let i = 0; i < formatted.length; i = i + 2) {
-            const c = formatted.slice(i, i + 2);
-            res[i / 2] = parseInt(c, 16);
-        }
-        return res.buffer;
-    }
-    static ToUtf16String(buffer, littleEndian = false) {
-        return Utf16Converter.toString(buffer, littleEndian);
-    }
-    static FromUtf16String(text, littleEndian = false) {
-        return Utf16Converter.fromString(text, littleEndian);
-    }
-    static Base64Padding(base64) {
-        const padCount = 4 - (base64.length % 4);
-        if (padCount < 4) {
-            for (let i = 0; i < padCount; i++) {
-                base64 += "=";
-            }
-        }
-        return base64;
-    }
-    static formatString(data) {
-        return (data === null || data === void 0 ? void 0 : data.replace(/[\n\r\t ]/g, "")) || "";
-    }
-}
+const STRING_TYPE = "string";
+const HEX_REGEX = /^[0-9a-f]+$/i;
+const BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const BASE64URL_REGEX = /^[a-zA-Z0-9-_]+$/;
+class Utf8Converter {
+    static fromString(text) {
+        const s = unescape(encodeURIComponent(text));
+        const uintArray = new Uint8Array(s.length);
+        for (let i = 0; i < s.length; i++) {
+            uintArray[i] = s.charCodeAt(i);
+        }
+        return uintArray.buffer;
+    }
+    static toString(buffer) {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        let encodedString = "";
+        for (let i = 0; i < buf.length; i++) {
+            encodedString += String.fromCharCode(buf[i]);
+        }
+        const decodedString = decodeURIComponent(escape(encodedString));
+        return decodedString;
+    }
+}
+class Utf16Converter {
+    static toString(buffer, littleEndian = false) {
+        const arrayBuffer = BufferSourceConverter.toArrayBuffer(buffer);
+        const dataView = new DataView(arrayBuffer);
+        let res = "";
+        for (let i = 0; i < arrayBuffer.byteLength; i += 2) {
+            const code = dataView.getUint16(i, littleEndian);
+            res += String.fromCharCode(code);
+        }
+        return res;
+    }
+    static fromString(text, littleEndian = false) {
+        const res = new ArrayBuffer(text.length * 2);
+        const dataView = new DataView(res);
+        for (let i = 0; i < text.length; i++) {
+            dataView.setUint16(i * 2, text.charCodeAt(i), littleEndian);
+        }
+        return res;
+    }
+}
+class Convert {
+    static isHex(data) {
+        return typeof data === STRING_TYPE
+            && HEX_REGEX.test(data);
+    }
+    static isBase64(data) {
+        return typeof data === STRING_TYPE
+            && BASE64_REGEX.test(data);
+    }
+    static isBase64Url(data) {
+        return typeof data === STRING_TYPE
+            && BASE64URL_REGEX.test(data);
+    }
+    static ToString(buffer, enc = "utf8") {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        switch (enc.toLowerCase()) {
+            case "utf8":
+                return this.ToUtf8String(buf);
+            case "binary":
+                return this.ToBinary(buf);
+            case "hex":
+                return this.ToHex(buf);
+            case "base64":
+                return this.ToBase64(buf);
+            case "base64url":
+                return this.ToBase64Url(buf);
+            case "utf16le":
+                return Utf16Converter.toString(buf, true);
+            case "utf16":
+            case "utf16be":
+                return Utf16Converter.toString(buf);
+            default:
+                throw new Error(`Unknown type of encoding '${enc}'`);
+        }
+    }
+    static FromString(str, enc = "utf8") {
+        if (!str) {
+            return new ArrayBuffer(0);
+        }
+        switch (enc.toLowerCase()) {
+            case "utf8":
+                return this.FromUtf8String(str);
+            case "binary":
+                return this.FromBinary(str);
+            case "hex":
+                return this.FromHex(str);
+            case "base64":
+                return this.FromBase64(str);
+            case "base64url":
+                return this.FromBase64Url(str);
+            case "utf16le":
+                return Utf16Converter.fromString(str, true);
+            case "utf16":
+            case "utf16be":
+                return Utf16Converter.fromString(str);
+            default:
+                throw new Error(`Unknown type of encoding '${enc}'`);
+        }
+    }
+    static ToBase64(buffer) {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        if (typeof btoa !== "undefined") {
+            const binary = this.ToString(buf, "binary");
+            return btoa(binary);
+        }
+        else {
+            return Buffer.from(buf).toString("base64");
+        }
+    }
+    static FromBase64(base64) {
+        const formatted = this.formatString(base64);
+        if (!formatted) {
+            return new ArrayBuffer(0);
+        }
+        if (!Convert.isBase64(formatted)) {
+            throw new TypeError("Argument 'base64Text' is not Base64 encoded");
+        }
+        if (typeof atob !== "undefined") {
+            return this.FromBinary(atob(formatted));
+        }
+        else {
+            return new Uint8Array(Buffer.from(formatted, "base64")).buffer;
+        }
+    }
+    static FromBase64Url(base64url) {
+        const formatted = this.formatString(base64url);
+        if (!formatted) {
+            return new ArrayBuffer(0);
+        }
+        if (!Convert.isBase64Url(formatted)) {
+            throw new TypeError("Argument 'base64url' is not Base64Url encoded");
+        }
+        return this.FromBase64(this.Base64Padding(formatted.replace(/\-/g, "+").replace(/\_/g, "/")));
+    }
+    static ToBase64Url(data) {
+        return this.ToBase64(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, "");
+    }
+    static FromUtf8String(text, encoding = Convert.DEFAULT_UTF8_ENCODING) {
+        switch (encoding) {
+            case "ascii":
+                return this.FromBinary(text);
+            case "utf8":
+                return Utf8Converter.fromString(text);
+            case "utf16":
+            case "utf16be":
+                return Utf16Converter.fromString(text);
+            case "utf16le":
+            case "usc2":
+                return Utf16Converter.fromString(text, true);
+            default:
+                throw new Error(`Unknown type of encoding '${encoding}'`);
+        }
+    }
+    static ToUtf8String(buffer, encoding = Convert.DEFAULT_UTF8_ENCODING) {
+        switch (encoding) {
+            case "ascii":
+                return this.ToBinary(buffer);
+            case "utf8":
+                return Utf8Converter.toString(buffer);
+            case "utf16":
+            case "utf16be":
+                return Utf16Converter.toString(buffer);
+            case "utf16le":
+            case "usc2":
+                return Utf16Converter.toString(buffer, true);
+            default:
+                throw new Error(`Unknown type of encoding '${encoding}'`);
+        }
+    }
+    static FromBinary(text) {
+        const stringLength = text.length;
+        const resultView = new Uint8Array(stringLength);
+        for (let i = 0; i < stringLength; i++) {
+            resultView[i] = text.charCodeAt(i);
+        }
+        return resultView.buffer;
+    }
+    static ToBinary(buffer) {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        let res = "";
+        for (let i = 0; i < buf.length; i++) {
+            res += String.fromCharCode(buf[i]);
+        }
+        return res;
+    }
+    static ToHex(buffer) {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        let result = "";
+        const len = buf.length;
+        for (let i = 0; i < len; i++) {
+            const byte = buf[i];
+            if (byte < 16) {
+                result += "0";
+            }
+            result += byte.toString(16);
+        }
+        return result;
+    }
+    static FromHex(hexString) {
+        let formatted = this.formatString(hexString);
+        if (!formatted) {
+            return new ArrayBuffer(0);
+        }
+        if (!Convert.isHex(formatted)) {
+            throw new TypeError("Argument 'hexString' is not HEX encoded");
+        }
+        if (formatted.length % 2) {
+            formatted = `0${formatted}`;
+        }
+        const res = new Uint8Array(formatted.length / 2);
+        for (let i = 0; i < formatted.length; i = i + 2) {
+            const c = formatted.slice(i, i + 2);
+            res[i / 2] = parseInt(c, 16);
+        }
+        return res.buffer;
+    }
+    static ToUtf16String(buffer, littleEndian = false) {
+        return Utf16Converter.toString(buffer, littleEndian);
+    }
+    static FromUtf16String(text, littleEndian = false) {
+        return Utf16Converter.fromString(text, littleEndian);
+    }
+    static Base64Padding(base64) {
+        const padCount = 4 - (base64.length % 4);
+        if (padCount < 4) {
+            for (let i = 0; i < padCount; i++) {
+                base64 += "=";
+            }
+        }
+        return base64;
+    }
+    static formatString(data) {
+        return (data === null || data === void 0 ? void 0 : data.replace(/[\n\r\t ]/g, "")) || "";
+    }
+}
 Convert.DEFAULT_UTF8_ENCODING = "utf8";
-function combine(...buf) {
-    const totalByteLength = buf.map((item) => item.byteLength).reduce((prev, cur) => prev + cur);
-    const res = new Uint8Array(totalByteLength);
-    let currentPos = 0;
-    buf.map((item) => new Uint8Array(item)).forEach((arr) => {
-        for (const item2 of arr) {
-            res[currentPos++] = item2;
-        }
-    });
-    return res.buffer;
+function combine(...buf) {
+    const totalByteLength = buf.map((item) => item.byteLength).reduce((prev, cur) => prev + cur);
+    const res = new Uint8Array(totalByteLength);
+    let currentPos = 0;
+    buf.map((item) => new Uint8Array(item)).forEach((arr) => {
+        for (const item2 of arr) {
+            res[currentPos++] = item2;
+        }
+    });
+    return res.buffer;
 }
 
 /*!
@@ -24048,15 +24062,31 @@ class Crypto extends Crypto$1 {
 if (typeof window === 'undefined') {
     global.crypto = new Crypto();
 }
+/**
+ * Obol sdk Client can be used for creating, managing and activating distributed validators.
+ */
 class Client extends Base {
+    /**
+     * @param config
+     * @param signer ethersJS Signer
+     * @returns Obol-SDK Client instance
+     *
+     * An example of how to instantiate obol-sdk Client:
+     * [obolClient](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L29)
+     */
     constructor(config, signer) {
         super(config);
         this.signer = signer;
     }
     /**
-     * @param cluster The new unique cluster
-     * @returns Invite Link with config_hash
-    */
+     * Creates a cluster definition which contains cluster configuration.
+     * @param {ClusterPayload} newCluster - The new unique cluster.
+     * @returns {Promise<string>} config_hash.
+     * @throws On duplicate entries, missing or wrong cluster keys.
+     *
+     * An example of how to use createClusterDefinition:
+     * [createObolCluster](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts)
+     */
     async createClusterDefinition(newCluster) {
         const isValid = validateDefinition(newCluster);
         if (isValid !== null)
@@ -24084,9 +24114,25 @@ class Client extends Base {
         }
     }
     /**
-     * @param configHash The config hash of the requested cluster
-     * @returns The matched cluster details (lock) from DB
-    */
+     * @returns {Promise<ClusterDefintion>} The  cluster definition for config hash
+     * @throws On not found config hash.
+     *
+     * An example of how to use getClusterDefinition:
+     * [getObolClusterDefinition](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts)
+     */
+    async getClusterDefinition(configHash) {
+        const clusterDefinition = await this.request(`/dv/${configHash}`, {
+            method: 'GET',
+        });
+        return clusterDefinition;
+    }
+    /**
+     * @returns {Promise<ClusterLock>} The matched cluster details (lock) from DB
+     * @throws On not found cluster definition or lock.
+     *
+     * An example of how to use getClusterLock:
+     * [getObolClusterLock](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts)
+     */
     async getClusterLock(configHash) {
         const lock = await this.request(`/lock/configHash/${configHash}`, {
             method: 'GET',