@keetanetwork/keetanet-client 0.12.0 → 0.12.2

package/client/index-browser.js

@@ -76,7 +76,7 @@ class browserSHA3_256 {
 
 function createHash(hashName, ...args) {
 	let hash;
-	if (hashName === 'sha3-256') {
+	if (hashName.toLowerCase() === 'sha3-256') {
 		hash = new browserSHA3_256();
 	} else {
 		hash = crypto.createHash(hashName, ...args);
@@ -86,7 +86,7 @@ function createHash(hashName, ...args) {
 
 function createHmac(hashName, key, ...args) {
 	let hmac;
-	if (hashName === 'sha3-256') {
+	if (hashName.toLowerCase() === 'sha3-256') {
 		hmac = new browserSHA3_256(key);
 	} else {
 		hmac = crypto.createHmac(hashName, key, ...args);
@@ -20619,7 +20619,7 @@ var $TypeError = __webpack_require__(9675);
 var $call = __webpack_require__(76);
 var $actualApply = __webpack_require__(3144);
 
-/** @type {import('.')} */
+/** @type {(args: [Function, thisArg?: unknown, ...args: unknown[]]) => Function} TODO FIXME, find a way to use import('.') */
 module.exports = function callBindBasic(args) {
 	if (args.length < 1 || typeof args[0] !== 'function') {
 		throw new $TypeError('a function is required');
@@ -20712,10 +20712,11 @@ var $indexOf = callBindBasic([GetIntrinsic('%String.prototype.indexOf%')]);
 
 /** @type {import('.')} */
 module.exports = function callBoundIntrinsic(name, allowMissing) {
-	// eslint-disable-next-line no-extra-parens
-	var intrinsic = /** @type {Parameters<typeof callBindBasic>[0][0]} */ (GetIntrinsic(name, !!allowMissing));
+	/* eslint no-extra-parens: 0 */
+
+	var intrinsic = /** @type {(this: unknown, ...args: unknown[]) => unknown} */ (GetIntrinsic(name, !!allowMissing));
 	if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
-		return callBindBasic([intrinsic]);
+		return callBindBasic(/** @type {const} */ ([intrinsic]));
 	}
 	return intrinsic;
 };
@@ -46167,6 +46168,7 @@ var isCallable = __webpack_require__(9600);
 var toStr = Object.prototype.toString;
 var hasOwnProperty = Object.prototype.hasOwnProperty;
 
+/** @type {<This, A extends readonly unknown[]>(arr: A, iterator: (this: This | void, value: A[number], index: number, arr: A) => void, receiver: This | undefined) => void} */
 var forEachArray = function forEachArray(array, iterator, receiver) {
     for (var i = 0, len = array.length; i < len; i++) {
         if (hasOwnProperty.call(array, i)) {
@@ -46179,6 +46181,7 @@ var forEachArray = function forEachArray(array, iterator, receiver) {
     }
 };
 
+/** @type {<This, S extends string>(string: S, iterator: (this: This | void, value: S[number], index: number, string: S) => void, receiver: This | undefined) => void} */
 var forEachString = function forEachString(string, iterator, receiver) {
     for (var i = 0, len = string.length; i < len; i++) {
         // no such thing as a sparse string.
@@ -46190,6 +46193,7 @@ var forEachString = function forEachString(string, iterator, receiver) {
     }
 };
 
+/** @type {<This, O>(obj: O, iterator: (this: This | void, value: O[keyof O], index: keyof O, obj: O) => void, receiver: This | undefined) => void} */
 var forEachObject = function forEachObject(object, iterator, receiver) {
     for (var k in object) {
         if (hasOwnProperty.call(object, k)) {
@@ -46202,7 +46206,13 @@ var forEachObject = function forEachObject(object, iterator, receiver) {
     }
 };
 
-var forEach = function forEach(list, iterator, thisArg) {
+/** @type {(x: unknown) => x is readonly unknown[]} */
+function isArray(x) {
+    return toStr.call(x) === '[object Array]';
+}
+
+/** @type {import('.')._internal} */
+module.exports = function forEach(list, iterator, thisArg) {
     if (!isCallable(iterator)) {
         throw new TypeError('iterator must be a function');
     }
@@ -46212,7 +46222,7 @@ var forEach = function forEach(list, iterator, thisArg) {
         receiver = thisArg;
     }
 
-    if (toStr.call(list) === '[object Array]') {
+    if (isArray(list)) {
         forEachArray(list, iterator, receiver);
     } else if (typeof list === 'string') {
         forEachString(list, iterator, receiver);
@@ -46221,8 +46231,6 @@ var forEach = function forEach(list, iterator, thisArg) {
     }
 };
 
-module.exports = forEach;
-
 
 /***/ }),
 
@@ -46610,6 +46618,7 @@ var INTRINSICS = {
 	'%Error%': $Error,
 	'%eval%': eval, // eslint-disable-line no-eval
 	'%EvalError%': $EvalError,
+	'%Float16Array%': typeof Float16Array === 'undefined' ? undefined : Float16Array,
 	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
 	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
 	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,
@@ -93306,8 +93315,8 @@ var availableTypedArrays = __webpack_require__(9209);
 var callBind = __webpack_require__(487);
 var callBound = __webpack_require__(6556);
 var gOPD = __webpack_require__(5795);
+var getProto = __webpack_require__(3628);
 
-/** @type {(O: object) => string} */
 var $toString = callBound('Object.prototype.toString');
 var hasToStringTag = __webpack_require__(9092)();
 
@@ -93315,7 +93324,6 @@ var g = typeof globalThis === 'undefined' ? __webpack_require__.g : globalThis;
 var typedArrays = availableTypedArrays();
 
 var $slice = callBound('String.prototype.slice');
-var getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');
 
 /** @type {<T = unknown>(array: readonly T[], value: unknown) => number} */
 var $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) {
@@ -93327,18 +93335,18 @@ var $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(ar
 	return -1;
 };
 
-/** @typedef {(receiver: import('.').TypedArray) => string | typeof Uint8Array.prototype.slice.call | typeof Uint8Array.prototype.set.call} Getter */
-/** @type {{ [k in `\$${import('.').TypedArrayName}`]?: Getter } & { __proto__: null }} */
+/** @typedef {import('./types').Getter} Getter */
+/** @type {import('./types').Cache} */
 var cache = { __proto__: null };
-if (hasToStringTag && gOPD && getPrototypeOf) {
+if (hasToStringTag && gOPD && getProto) {
 	forEach(typedArrays, function (typedArray) {
 		var arr = new g[typedArray]();
-		if (Symbol.toStringTag in arr) {
-			var proto = getPrototypeOf(arr);
+		if (Symbol.toStringTag in arr && getProto) {
+			var proto = getProto(arr);
 			// @ts-expect-error TS won't narrow inside a closure
 			var descriptor = gOPD(proto, Symbol.toStringTag);
-			if (!descriptor) {
-				var superProto = getPrototypeOf(proto);
+			if (!descriptor && proto) {
+				var superProto = getProto(proto);
 				// @ts-expect-error TS won't narrow inside a closure
 				descriptor = gOPD(superProto, Symbol.toStringTag);
 			}
@@ -93351,8 +93359,12 @@ if (hasToStringTag && gOPD && getPrototypeOf) {
 		var arr = new g[typedArray]();
 		var fn = arr.slice || arr.set;
 		if (fn) {
-			// @ts-expect-error TODO: fix
-			cache['$' + typedArray] = callBind(fn);
+			cache[
+				/** @type {`$${import('.').TypedArrayName}`} */ ('$' + typedArray)
+			] = /** @type {import('./types').BoundSlice | import('./types').BoundSet} */ (
+				// @ts-expect-error TODO FIXME
+				callBind(fn)
+			);
 		}
 	});
 }
@@ -93361,15 +93373,14 @@ if (hasToStringTag && gOPD && getPrototypeOf) {
 var tryTypedArrays = function tryAllTypedArrays(value) {
 	/** @type {ReturnType<typeof tryAllTypedArrays>} */ var found = false;
 	forEach(
-		// eslint-disable-next-line no-extra-parens
-		/** @type {Record<`\$${TypedArrayName}`, Getter>} */ /** @type {any} */ (cache),
+		/** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */ (cache),
 		/** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
 		function (getter, typedArray) {
 			if (!found) {
 				try {
-				// @ts-expect-error TODO: fix
+					// @ts-expect-error a throw is fine here
 					if ('$' + getter(value) === typedArray) {
-						found = $slice(typedArray, 1);
+						found = /** @type {import('.').TypedArrayName} */ ($slice(typedArray, 1));
 					}
 				} catch (e) { /**/ }
 			}
@@ -93382,14 +93393,13 @@ var tryTypedArrays = function tryAllTypedArrays(value) {
 var trySlices = function tryAllSlices(value) {
 	/** @type {ReturnType<typeof tryAllSlices>} */ var found = false;
 	forEach(
-		// eslint-disable-next-line no-extra-parens
-		/** @type {Record<`\$${TypedArrayName}`, Getter>} */ /** @type {any} */ (cache),
-		/** @type {(getter: typeof cache, name: `\$${import('.').TypedArrayName}`) => void} */ function (getter, name) {
+		/** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */(cache),
+		/** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */ function (getter, name) {
 			if (!found) {
 				try {
-					// @ts-expect-error TODO: fix
+					// @ts-expect-error a throw is fine here
 					getter(value);
-					found = $slice(name, 1);
+					found = /** @type {import('.').TypedArrayName} */ ($slice(name, 1));
 				} catch (e) { /**/ }
 			}
 		}
@@ -101168,6 +101178,7 @@ __webpack_require__.d(client_helper_namespaceObject, {
   booleanEnv: () => (client_booleanEnv),
   bufferToArrayBuffer: () => (client_bufferToArrayBuffer),
   checkableGenerator: () => (client_checkableGenerator),
+  crypto: () => (client_helper_crypto),
   debugPrintableObject: () => (client_debugPrintableObject),
   env: () => (client_env),
   internalLogger: () => (client_internalLogger),
@@ -101183,16 +101194,19 @@ __webpack_require__.d(client_helper_namespaceObject, {
 });
 
 // NAMESPACE OBJECT: ./src/lib/utils/buffer.ts
-var client_buffer_namespaceObject = {};
-__webpack_require__.r(client_buffer_namespaceObject);
-__webpack_require__.d(client_buffer_namespaceObject, {
+var client_utils_buffer_namespaceObject = {};
+__webpack_require__.r(client_utils_buffer_namespaceObject);
+__webpack_require__.d(client_utils_buffer_namespaceObject, {
+  Buffer: () => (client_node_modules_buffer.Buffer),
   BufferStorage: () => (src_client_BufferStorage),
   DecodeBase32: () => (client_DecodeBase32),
   DecodeBase64: () => (client_DecodeBase64),
   EncodeBase32: () => (client_EncodeBase32),
   EncodeBase64: () => (client_EncodeBase64),
   ZlibDeflate: () => (client_ZlibDeflate),
-  ZlibInflate: () => (client_ZlibInflate)
+  ZlibDeflateAsync: () => (client_ZlibDeflateAsync),
+  ZlibInflate: () => (client_ZlibInflate),
+  ZlibInflateAsync: () => (client_ZlibInflateAsync)
 });
 
 // NAMESPACE OBJECT: ./node_modules/asn1js/src/asn1.js
@@ -101256,6 +101270,7 @@ __webpack_require__.d(client_utils_asn1_namespaceObject, {
   ValidateASN1: () => (client_ValidateASN1),
   _Testing: () => (client_Testing),
   asn1: () => (client_asn1),
+  isASN1Object: () => (client_isASN1Object),
   isValidSequenceSchema: () => (client_isValidSequenceSchema)
 });
 
@@ -105293,6 +105308,83 @@ function client_hash_Hash(data) {
 }
 client_hash_Hash.functionName = client_HashFunctionName;
 client_hash_Hash.functionLength = client_HashFunctionLength;
+;// ./node_modules/uuid/dist/esm-browser/native.js
+const client_randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+/* harmony default export */ const client_esm_browser_native = ({ randomUUID: client_randomUUID });
+
+;// ./node_modules/uuid/dist/esm-browser/rng.js
+let client_getRandomValues;
+const client_rnds8 = new Uint8Array(16);
+function client_rng() {
+    if (!client_getRandomValues) {
+        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
+            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+        }
+        client_getRandomValues = crypto.getRandomValues.bind(crypto);
+    }
+    return client_getRandomValues(client_rnds8);
+}
+
+;// ./node_modules/uuid/dist/esm-browser/stringify.js
+
+const client_byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+    client_byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+function client_unsafeStringify(arr, offset = 0) {
+    return (client_byteToHex[arr[offset + 0]] +
+        client_byteToHex[arr[offset + 1]] +
+        client_byteToHex[arr[offset + 2]] +
+        client_byteToHex[arr[offset + 3]] +
+        '-' +
+        client_byteToHex[arr[offset + 4]] +
+        client_byteToHex[arr[offset + 5]] +
+        '-' +
+        client_byteToHex[arr[offset + 6]] +
+        client_byteToHex[arr[offset + 7]] +
+        '-' +
+        client_byteToHex[arr[offset + 8]] +
+        client_byteToHex[arr[offset + 9]] +
+        '-' +
+        client_byteToHex[arr[offset + 10]] +
+        client_byteToHex[arr[offset + 11]] +
+        client_byteToHex[arr[offset + 12]] +
+        client_byteToHex[arr[offset + 13]] +
+        client_byteToHex[arr[offset + 14]] +
+        client_byteToHex[arr[offset + 15]]).toLowerCase();
+}
+function client_stringify(arr, offset = 0) {
+    const uuid = client_unsafeStringify(arr, offset);
+    if (!validate(uuid)) {
+        throw TypeError('Stringified UUID is invalid');
+    }
+    return uuid;
+}
+/* harmony default export */ const client_esm_browser_stringify = ((/* unused pure expression or super */ null && (client_stringify)));
+
+;// ./node_modules/uuid/dist/esm-browser/v4.js
+
+
+
+function client_v4(options, buf, offset) {
+    if (client_esm_browser_native.randomUUID && !buf && !options) {
+        return client_esm_browser_native.randomUUID();
+    }
+    options = options || {};
+    const rnds = options.random || (options.rng || client_rng)();
+    rnds[6] = (rnds[6] & 0x0f) | 0x40;
+    rnds[8] = (rnds[8] & 0x3f) | 0x80;
+    if (buf) {
+        offset = offset || 0;
+        for (let i = 0; i < 16; ++i) {
+            buf[offset + i] = rnds[i];
+        }
+        return buf;
+    }
+    return client_unsafeStringify(rnds);
+}
+/* harmony default export */ const client_esm_browser_v4 = (client_v4);
+
 ;// ./src/lib/utils/helper.ts
 /* provided dependency */ var client_process = __webpack_require__(5606);
 /* provided dependency */ var src_client_Buffer = __webpack_require__(8287)["Buffer"];
@@ -105309,9 +105401,14 @@ function src_client_assertClassBrand(e, t, n) { if ("function" == typeof e ? e =
 
 
 
+
 const client_loggingLevels = ['debug', 'error'];
 const client_configuredLoggingLevel = (client_process$env$KEETANET = client_process.env['KEETANET_DEBUG']) === null || client_process$env$KEETANET === void 0 ? void 0 : client_process$env$KEETANET.toLowerCase();
 const client_configuredLoggingFilter = new RegExp((client_process$env$KEETANET2 = client_process.env['KEETANET_DEBUG_FILTER']) !== null && client_process$env$KEETANET2 !== void 0 ? client_process$env$KEETANET2 : '', 'i');
+const client_helper_randomBytes = client_crypto_default().randomBytes.bind((client_crypto_default()));
+const client_helper_randomUUID = (client_crypto_default()).randomUUID ? client_crypto_default().randomUUID.bind((client_crypto_default())) : function () {
+  return client_esm_browser_v4();
+};
 function client_bufferToArrayBuffer(input) {
   const out = new ArrayBuffer(input.length);
   const view = new Uint8Array(out);
@@ -105403,7 +105500,7 @@ function client_randomString() {
   }
 
   // Generate bytes and convert to hex string
-  let generated = client_crypto_default().randomBytes(bytesToGen).toString('hex');
+  let generated = client_helper_randomBytes(bytesToGen).toString('hex');
 
   // If you requested an odd length, remove last character
   // This is one byte is 2 characters, so we cannot directly generate odd lengths
@@ -105810,6 +105907,12 @@ function client_setGenerator(parent, rawEncode, rawDecode) {
     }
   };
 }
+const client_helper_crypto = {
+  randomUUID: client_helper_randomUUID,
+  randomBytes: client_helper_randomBytes,
+  createCipheriv: client_crypto_default().createCipheriv.bind((client_crypto_default())),
+  createDecipheriv: client_crypto_default().createDecipheriv.bind((client_crypto_default()))
+};
 ;// ./node_modules/rfc4648/lib/rfc4648.js
 /* eslint-disable @typescript-eslint/strict-boolean-expressions */
 
@@ -105841,7 +105944,7 @@ var client_base16 = {
     return client_parse(string.toUpperCase(), client_base16Encoding, opts);
   },
   stringify: function stringify(data, opts) {
-    return client_stringify(data, client_base16Encoding, opts);
+    return src_client_stringify(data, client_base16Encoding, opts);
   }
 };
 var client_base32 = {
@@ -105852,7 +105955,7 @@ var client_base32 = {
     return client_parse(opts.loose ? string.toUpperCase().replace(/0/g, 'O').replace(/1/g, 'L').replace(/8/g, 'B') : string, client_base32Encoding, opts);
   },
   stringify: function stringify(data, opts) {
-    return client_stringify(data, client_base32Encoding, opts);
+    return src_client_stringify(data, client_base32Encoding, opts);
   }
 };
 var client_base32hex = {
@@ -105860,7 +105963,7 @@ var client_base32hex = {
     return client_parse(string, client_base32HexEncoding, opts);
   },
   stringify: function stringify(data, opts) {
-    return client_stringify(data, client_base32HexEncoding, opts);
+    return src_client_stringify(data, client_base32HexEncoding, opts);
   }
 };
 var client_base64 = {
@@ -105868,7 +105971,7 @@ var client_base64 = {
     return client_parse(string, client_base64Encoding, opts);
   },
   stringify: function stringify(data, opts) {
-    return client_stringify(data, client_base64Encoding, opts);
+    return src_client_stringify(data, client_base64Encoding, opts);
   }
 };
 var client_base64url = {
@@ -105876,7 +105979,7 @@ var client_base64url = {
     return client_parse(string, client_base64UrlEncoding, opts);
   },
   stringify: function stringify(data, opts) {
-    return client_stringify(data, client_base64UrlEncoding, opts);
+    return src_client_stringify(data, client_base64UrlEncoding, opts);
   }
 };
 
@@ -105886,7 +105989,7 @@ var client_base64url = {
 
 var client_codec = {
   parse: client_parse,
-  stringify: client_stringify
+  stringify: src_client_stringify
 };
 function client_parse(string, encoding, opts) {
   var _opts$out;
@@ -105948,7 +106051,7 @@ function client_parse(string, encoding, opts) {
   }
   return out;
 }
-function client_stringify(data, encoding, opts) {
+function src_client_stringify(data, encoding, opts) {
   if (opts === void 0) {
     opts = {};
   }
@@ -105987,11 +106090,12 @@ function client_stringify(data, encoding, opts) {
 
 
 
+// EXTERNAL MODULE: ./node_modules/buffer/index.js
+var client_node_modules_buffer = __webpack_require__(8287);
 // EXTERNAL MODULE: ./node_modules/browserify-zlib/lib/index.js
 var src_client_lib = __webpack_require__(8559);
 var client_lib_default = /*#__PURE__*/__webpack_require__.n(src_client_lib);
 ;// ./src/lib/utils/buffer.ts
-/* provided dependency */ var client_buffer_Buffer = __webpack_require__(8287)["Buffer"];
 var client_BufferStorage;
 function client_buffer_defineProperty(e, r, t) { return (r = client_buffer_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function client_buffer_toPropertyKey(t) { var i = client_buffer_toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
@@ -106005,6 +106109,10 @@ function client_buffer_assertClassBrand(e, t, n) { if ("function" == typeof e ?
 
 
 
+
+const client_inflateAsync = (0,client_util.promisify)((client_lib_default()).inflate);
+const client_deflateAsync = (0,client_util.promisify)((client_lib_default()).deflate);
+
 /**
  * RFC 4648 Base32 Decoder
  */
@@ -106028,16 +106136,26 @@ function client_EncodeBase32(data) {
   }).toLowerCase();
 }
 function client_DecodeBase64(data) {
-  return client_bufferToArrayBuffer(client_buffer_Buffer.from(data, 'base64'));
+  return client_bufferToArrayBuffer(client_node_modules_buffer.Buffer.from(data, 'base64'));
 }
 function client_EncodeBase64(data) {
-  return client_buffer_Buffer.from(data).toString('base64');
+  return client_node_modules_buffer.Buffer.from(data).toString('base64');
 }
 function client_ZlibInflate(data, options) {
-  return client_bufferToArrayBuffer(client_lib_default().inflateSync(client_buffer_Buffer.from(data), options));
+  return client_bufferToArrayBuffer(client_lib_default().inflateSync(client_node_modules_buffer.Buffer.from(data), options));
 }
 function client_ZlibDeflate(data, options) {
-  return client_bufferToArrayBuffer(client_lib_default().deflateSync(client_buffer_Buffer.from(data), options));
+  return client_bufferToArrayBuffer(client_lib_default().deflateSync(client_node_modules_buffer.Buffer.from(data), options));
+}
+async function client_ZlibInflateAsync(data) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const buffer = await client_inflateAsync(client_node_modules_buffer.Buffer.from(data), options);
+  return client_bufferToArrayBuffer(buffer);
+}
+async function client_ZlibDeflateAsync(data) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const buffer = await client_deflateAsync(client_node_modules_buffer.Buffer.from(data), options);
+  return client_bufferToArrayBuffer(buffer);
 }
 var client_key = /*#__PURE__*/new WeakMap();
 class src_client_BufferStorage {
@@ -106048,7 +106166,7 @@ class src_client_BufferStorage {
       /*
        * Convert from a hex-encoded string into a buffer
        */
-      const buffer_key = client_buffer_Buffer.from(key, 'hex');
+      const buffer_key = client_node_modules_buffer.Buffer.from(key, 'hex');
       if (buffer_key.length !== length) {
         throw new Error(`When decoding buffer we got different number of bytes than expected (${buffer_key.length} expected ${length})`);
       }
@@ -106060,10 +106178,10 @@ class src_client_BufferStorage {
       }
       value = '0'.repeat(length * 2) + value;
       value = value.slice(length * 2 * -1);
-      client_buffer_classPrivateFieldSet(client_key, this, client_buffer_Buffer.from(value, 'hex'));
+      client_buffer_classPrivateFieldSet(client_key, this, client_node_modules_buffer.Buffer.from(value, 'hex'));
     } else {
-      if (client_buffer_Buffer.from(key).length !== length) {
-        throw new Error(`When storing buffer we got different number of bytes than expected (${client_buffer_Buffer.from(key).length} expected ${length})`);
+      if (client_node_modules_buffer.Buffer.from(key).length !== length) {
+        throw new Error(`When storing buffer we got different number of bytes than expected (${client_node_modules_buffer.Buffer.from(key).length} expected ${length})`);
       }
       client_buffer_classPrivateFieldSet(client_key, this, key);
     }
@@ -106075,15 +106193,15 @@ class src_client_BufferStorage {
     return client_buffer_classPrivateFieldGet(client_key, this).byteLength;
   }
   getBuffer() {
-    return client_buffer_Buffer.from(client_buffer_classPrivateFieldGet(client_key, this));
+    return client_node_modules_buffer.Buffer.from(client_buffer_classPrivateFieldGet(client_key, this));
   }
   toString() {
     let encoding = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'hex';
     switch (encoding) {
       case 'hex':
-        return client_buffer_Buffer.from(client_buffer_classPrivateFieldGet(client_key, this)).toString(encoding).toUpperCase();
+        return client_node_modules_buffer.Buffer.from(client_buffer_classPrivateFieldGet(client_key, this)).toString(encoding).toUpperCase();
       case 'base64':
-        return client_buffer_Buffer.from(client_buffer_classPrivateFieldGet(client_key, this)).toString(encoding);
+        return client_node_modules_buffer.Buffer.from(client_buffer_classPrivateFieldGet(client_key, this)).toString(encoding);
       case 'base32':
         return client_EncodeBase32(client_buffer_classPrivateFieldGet(client_key, this));
       default:
@@ -106108,17 +106226,18 @@ class src_client_BufferStorage {
       return false;
     }
     if (typeof compareWith === 'string') {
-      const asBuf = client_buffer_Buffer.from(compareWith, 'hex');
+      const asBuf = client_node_modules_buffer.Buffer.from(compareWith, 'hex');
       if (asBuf.length !== this.length) {
         return false;
       }
-      compareWith = new src_client_BufferStorage(client_buffer_Buffer.from(compareWith, 'hex'), this.length);
+      compareWith = new src_client_BufferStorage(client_node_modules_buffer.Buffer.from(compareWith, 'hex'), this.length);
     }
     return this.toString('hex') === compareWith.toString('hex');
   }
 }
 client_BufferStorage = src_client_BufferStorage;
 client_buffer_defineProperty(src_client_BufferStorage, "isInstance", client_checkableGenerator(client_BufferStorage));
+
 ;// ./node_modules/pvutils/build/utils.es.js
 /*!
  Copyright (c) Peculiar Ventures, LLC
@@ -112985,20 +113104,29 @@ function client_jsIntegerToBigInt(value) {
   }
   return BigInt(valueStr);
 }
+function client_isASN1Object(input) {
+  if (input === null || input === undefined || typeof input !== 'object') {
+    return false;
+  }
+  if (!('type' in input) || typeof input.type !== 'string') {
+    return false;
+  }
+  return true;
+}
 function client_isASN1OID(input) {
-  if (typeof input !== 'object') {
+  if (!client_isASN1Object(input)) {
     return false;
   }
   if (input.type !== 'oid') {
     return false;
   }
-  if (typeof input.oid !== 'string') {
+  if (!('oid' in input) || typeof input.oid !== 'string') {
     return false;
   }
   return true;
 }
 function client_isASN1String(input) {
-  if (typeof input !== 'object' || input === null) {
+  if (!client_isASN1Object(input)) {
     return false;
   }
   if (!('type' in input) || input.type !== 'string') {
@@ -113021,13 +113149,16 @@ function client_isASN1String(input) {
   return true;
 }
 function client_isASN1Set(input) {
-  if (typeof input !== 'object') {
+  if (!client_isASN1Object(input)) {
     return false;
   }
   if (input.type !== 'set') {
     return false;
   }
-  if (!client_isASN1OID(input.name)) {
+  if (!('name' in input) || !client_isASN1OID(input.name)) {
+    return false;
+  }
+  if (!('value' in input)) {
     return false;
   }
   if (typeof input.value !== 'string') {
@@ -113038,7 +113169,7 @@ function client_isASN1Set(input) {
   return true;
 }
 function client_isASN1ContextTag(input) {
-  if (typeof input !== 'object' || input === null) {
+  if (!client_isASN1Object(input)) {
     return false;
   }
   if (!('type' in input) || input.type !== 'context') {
@@ -113053,19 +113184,19 @@ function client_isASN1ContextTag(input) {
   return true;
 }
 function client_isASN1BitString(input) {
-  if (typeof input !== 'object') {
+  if (!client_isASN1Object(input)) {
     return false;
   }
   if (input.type !== 'bitstring') {
     return false;
   }
-  if (!client_isBuffer(input.value)) {
+  if (!('value' in input) || !client_isBuffer(input.value)) {
     return false;
   }
   return true;
 }
 function client_isASN1Date(input) {
-  if (typeof input !== 'object' || input === null) {
+  if (!client_isASN1Object(input)) {
     return false;
   }
   if (!('type' in input) || input.type !== 'date') {
@@ -113972,17 +114103,39 @@ class client_ValidateASN1 {
         if (input.length < minLength || input.length > maxLength) {
           throw new Error(`Expected Array length between [${minLength}, ${maxLength}], got ${input.length}`);
         }
+        const output = [];
+        for (let i = 0; i < schema.length; i++) {
+          // If the schema is optional, we check two paths, if the value is present or not.
+          // This will break the loop and leave the rest of the validation to the recursive call.
+          if (typeof schema[i] === 'object' && 'optional' in schema[i]) {
+            // We only need to take two paths for optional values when we are before the last value, and the value is not undefined
+            if (i < schema.length - 1 && input[i] !== undefined) {
+              const remainingSchema = schema.slice(i + 1);
+              try {
+                // Try to validate against schema assuming optional is present
+                // @ts-ignore
+                output.push(...client_ValidateASN1.againstSchema(input.slice(i), [schema[i].optional, ...remainingSchema]));
+              } catch {
+                /* ignore error because we are going to try without the optional value */
+
+                // @ts-ignore
+                output.push(undefined, ...client_ValidateASN1.againstSchema(input.slice(i), remainingSchema));
+              }
+              break;
+            }
+          }
 
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return schema.map(function (item, i) {
-          /*
-           * We need to cast to "any" to avoid
-           * typing errors with TypeScript's
-           * validation with recursive types
-           */
           // @ts-ignore
-          return client_ValidateASN1.againstSchema(input[i], item);
-        });
+          output.push(client_ValidateASN1.againstSchema(input[i], schema[i]));
+        }
+
+        // If the end of the output is only optional values, exclude undefined values.
+        while (output.length > 0 && output.at(-1) === undefined) {
+          output.pop();
+        }
+
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return output;
       } else {
         throw new Error(`Internal error: Unsupported schema type ${JSON.stringify(schema)}`);
       }
@@ -115125,7 +115278,7 @@ client_KeetaNetCertificateError = src_client_KeetaNetCertificateError;
 client_certificate_defineProperty(src_client_KeetaNetCertificateError, "isInstance", client_checkableGenerator(client_KeetaNetCertificateError));
 ;// ./src/lib/utils/certificate.ts
 /* provided dependency */ var client_certificate_Buffer = __webpack_require__(8287)["Buffer"];
-var client_CertificateHash, client_Certificate, client_CertificateBundle;
+var client_CertificateHash, client_CertificateBundle, client_Certificate;
 function client_certificate_classPrivateMethodInitSpec(e, a) { client_certificate_checkPrivateRedeclaration(e, a), a.add(e); }
 function client_utils_certificate_defineProperty(e, r, t) { return (r = client_utils_certificate_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function client_utils_certificate_toPropertyKey(t) { var i = client_utils_certificate_toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
@@ -115557,7 +115710,85 @@ client_utils_certificate_defineProperty(src_client_CertificateHash, "Set", clien
 }, function (value) {
   return new client_CertificateHash(client_certificate_Buffer.from(value, 'hex'));
 }));
+const client_CertificateBundleSchemaInternal = {
+  sequenceOf: client_CertificateSchemaInternal
+};
 var client_raw = /*#__PURE__*/new WeakMap();
+var client_contents = /*#__PURE__*/new WeakMap();
+class src_client_CertificateBundle {
+  constructor(input) {
+    client_certificate_classPrivateFieldInitSpec(this, client_raw, void 0);
+    client_certificate_classPrivateFieldInitSpec(this, client_contents, void 0);
+    if (src_client_CertificateBundle.isInstance(input)) {
+      client_certificate_classPrivateFieldSet(client_raw, this, input.getDER());
+    } else if (Array.isArray(input) || input instanceof Set) {
+      if (input instanceof Set) {
+        input = Array.from(input);
+      }
+      const decodedInput = input.map(function (certificate) {
+        let decoded;
+
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        if (src_client_Certificate.isCertificate(certificate)) {
+          decoded = new client_BufferStorageASN1(certificate.toDER());
+        } else {
+          // eslint-disable-next-line @typescript-eslint/no-use-before-define
+          decoded = new client_BufferStorageASN1(new src_client_Certificate(certificate).toDER());
+        }
+        // For some reason the typescript compiler cannot understand this, but we do not care about it being typed because we are validating it right after.
+        // @ts-ignore
+        const output = decoded.getASN1();
+        return output;
+      });
+      client_certificate_classPrivateFieldSet(client_raw, this, new client_BufferStorageASN1(decodedInput, client_CertificateBundleSchemaInternal).getDER());
+    } else {
+      if (typeof input === 'string') {
+        input = client_certificate_Buffer.from(input, 'base64');
+      }
+      if (client_certificate_Buffer.isBuffer(input)) {
+        input = client_bufferToArrayBuffer(input);
+      }
+      client_certificate_classPrivateFieldSet(client_raw, this, input);
+    }
+    const decoded = new client_BufferStorageASN1(client_certificate_classPrivateFieldGet(client_raw, this), client_CertificateBundleSchemaInternal);
+    client_certificate_classPrivateFieldSet(client_contents, this, []);
+    const seenHashes = new src_client_CertificateHash.Set();
+    for (const item of decoded.getASN1()) {
+      const certificateValue = new client_BufferStorageASN1(item, client_CertificateSchemaInternal);
+
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      const certificate = new src_client_Certificate(certificateValue.getDER());
+      const hash = certificate.hash();
+      if (seenHashes.has(hash)) {
+        throw new src_client_KeetaNetCertificateError('CERTIFICATE_DUPLICATE_INCLUDED', `Duplicate certificate ${hash} within certificate bundle`);
+      }
+      seenHashes.add(hash);
+      client_certificate_classPrivateFieldGet(client_contents, this).push(certificate);
+    }
+  }
+  get bundleSize() {
+    return client_certificate_classPrivateFieldGet(client_contents, this).length;
+  }
+  getDER() {
+    return client_certificate_classPrivateFieldGet(client_raw, this);
+  }
+  getDERBuffer() {
+    return client_certificate_Buffer.from(this.getDER());
+  }
+  getCertificates() {
+    return client_certificate_classPrivateFieldGet(client_contents, this);
+  }
+  toJSON() {
+    return {
+      certificates: this.getCertificates().map(function (certificate) {
+        return certificate.toPEM();
+      })
+    };
+  }
+}
+client_CertificateBundle = src_client_CertificateBundle;
+client_utils_certificate_defineProperty(src_client_CertificateBundle, "isInstance", client_checkableGenerator(client_CertificateBundle));
+var client_raw2 = /*#__PURE__*/new WeakMap();
 var client_hash = /*#__PURE__*/new WeakMap();
 var client_extensionsRaw = /*#__PURE__*/new WeakMap();
 var client_extensionsProcessed = /*#__PURE__*/new WeakMap();
@@ -115590,7 +115821,7 @@ class src_client_Certificate {
     /**
      * The raw certificate (DER encoded)
      */
-    client_certificate_classPrivateFieldInitSpec(this, client_raw, void 0);
+    client_certificate_classPrivateFieldInitSpec(this, client_raw2, void 0);
     client_certificate_classPrivateFieldInitSpec(this, client_hash, void 0);
     /**
      * Raw extensions, which can be processed by subclasses
@@ -115644,7 +115875,7 @@ class src_client_Certificate {
       input = client_bufferToArrayBuffer(input);
     }
     const data = new client_BufferStorageASN1(input, client_CertificateSchemaInternal);
-    client_certificate_classPrivateFieldSet(client_raw, this, data.getDER());
+    client_certificate_classPrivateFieldSet(client_raw2, this, data.getDER());
     const parts = data.getASN1();
     const tbsCertificate = parts[0];
     const [version, serialNumber, signatureAlgorithmSigned, _issuer, [notBefore, notAfter], subject, subjectPublicKey, _extensions] = tbsCertificate;
@@ -115682,8 +115913,10 @@ class src_client_Certificate {
     this.notAfter = notAfter.date;
     this.subject = client_fromDNSequenceToString(subject);
     this.issuer = client_fromDNSequenceToString(_issuer);
-    this.subjectDN = subject;
-    this.issuerDN = _issuer;
+    this.subjectDN = client_fromDNSequence(subject);
+    this.issuerDN = client_fromDNSequence(_issuer);
+    this.subjectDNSet = subject;
+    this.issuerDNSet = _issuer;
 
     /*
      * Compare the signature algorithm in the certificate with
@@ -115796,7 +116029,7 @@ class src_client_Certificate {
     if (src_client_Certificate.isCertificate(account)) {
       account = account.subjectPublicKey;
     }
-    const data = new client_BufferStorageASN1(client_certificate_classPrivateFieldGet(client_raw, this), client_CertificateSchemaInternal);
+    const data = new client_BufferStorageASN1(client_certificate_classPrivateFieldGet(client_raw2, this), client_CertificateSchemaInternal);
     const [tbsCertificate, signatureAlgorithmObject, signatureObject] = data.getASN1();
     const signatureAlgorithm = signatureAlgorithmObject[0].oid;
     const tbsCertificateToVerify = new client_BufferStorageASN1(tbsCertificate).getDER();
@@ -116053,11 +116286,11 @@ class src_client_Certificate {
    */
   equals(other) {
     this.assertConstructed();
-    if (client_certificate_classPrivateFieldGet(client_raw, this).byteLength !== client_certificate_classPrivateFieldGet(client_raw, other).byteLength) {
+    if (client_certificate_classPrivateFieldGet(client_raw2, this).byteLength !== client_certificate_classPrivateFieldGet(client_raw2, other).byteLength) {
       return false;
     }
-    const thisBuffer = client_certificate_Buffer.from(client_certificate_classPrivateFieldGet(client_raw, this));
-    const otherBuffer = client_certificate_Buffer.from(client_certificate_classPrivateFieldGet(client_raw, other));
+    const thisBuffer = client_certificate_Buffer.from(client_certificate_classPrivateFieldGet(client_raw2, this));
+    const otherBuffer = client_certificate_Buffer.from(client_certificate_classPrivateFieldGet(client_raw2, other));
     return thisBuffer.equals(otherBuffer);
   }
 
@@ -116074,7 +116307,7 @@ class src_client_Certificate {
    */
   toDER() {
     this.assertConstructed();
-    return client_certificate_classPrivateFieldGet(client_raw, this);
+    return client_certificate_classPrivateFieldGet(client_raw2, this);
   }
 
   /**
@@ -116082,20 +116315,31 @@ class src_client_Certificate {
    */
   toPEM() {
     this.assertConstructed();
-    const certificatePEMLines = client_certificate_Buffer.from(client_certificate_classPrivateFieldGet(client_raw, this)).toString('base64').split(/(.{64})/g).filter(function (line) {
+    const certificatePEMLines = client_certificate_Buffer.from(client_certificate_classPrivateFieldGet(client_raw2, this)).toString('base64').split(/(.{64})/g).filter(function (line) {
       return line.length > 0;
     });
     const certificatePEM = ['-----BEGIN CERTIFICATE-----', ...certificatePEMLines, '-----END CERTIFICATE-----'].join('\n') + '\n';
     return certificatePEM;
   }
 
+  /**
+   * The string representation of the certificate
+   * is a PEM encoded certificate -- this misses
+   * some of the internal details like chain
+   * and verified, but is usually what someone
+   * wants to see when they call toString()
+   */
+  toString() {
+    return this.toPEM();
+  }
+
   /**
    * Compute a hash of the certificate
    */
   hash() {
     this.assertConstructed();
     if (!client_certificate_classPrivateFieldGet(client_hash, this)) {
-      client_certificate_classPrivateFieldSet(client_hash, this, src_client_CertificateHash.fromData(client_certificate_Buffer.from(client_certificate_classPrivateFieldGet(client_raw, this))));
+      client_certificate_classPrivateFieldSet(client_hash, this, src_client_CertificateHash.fromData(client_certificate_Buffer.from(client_certificate_classPrivateFieldGet(client_raw2, this))));
     }
     return client_certificate_classPrivateFieldGet(client_hash, this);
   }
@@ -116128,8 +116372,8 @@ class src_client_Certificate {
       issuer: this.issuer,
       subjectPublicKey: this.subjectPublicKey,
       baseExtensions: this.baseExtensions,
-      subjectDN: client_fromDNSequence(this.subjectDN),
-      issuerDN: client_fromDNSequence(this.issuerDN),
+      subjectDN: client_fromDNSequence(this.subjectDNSet),
+      issuerDN: client_fromDNSequence(this.issuerDNSet),
       $hash: this.hash(),
       ...additionalFields
     };
@@ -116282,8 +116526,8 @@ function client_checkIssued(issuer) {
   /**
    * Compare the issuerDN and the subjectDN byte-for-byte
    */
-  const issuerDN = new client_BufferStorageASN1(issuer.subjectDN);
-  const subjectIssuerDN = new client_BufferStorageASN1(this.issuerDN);
+  const issuerDN = new client_BufferStorageASN1(issuer.subjectDNSet);
+  const subjectIssuerDN = new client_BufferStorageASN1(this.issuerDNSet);
   const issuerDER = issuerDN.getDERBuffer();
   const subjectIssuerDER = subjectIssuerDN.getDERBuffer();
   if (!issuerDER.equals(subjectIssuerDER)) {
@@ -116354,83 +116598,18 @@ function client_checkIssued(issuer) {
  * The Certificate Builder
  */
 client_utils_certificate_defineProperty(src_client_Certificate, "Builder", client_CertificateBuilder);
+/**
+ * The certificate bundle
+ */
+client_utils_certificate_defineProperty(src_client_Certificate, "Bundle", src_client_CertificateBundle);
+/**
+ * The certificate hash information
+ */
+client_utils_certificate_defineProperty(src_client_Certificate, "Hash", src_client_CertificateHash);
 /**
  * Object type ID for {@link Certificate.isCertificate}
  */
 client_utils_certificate_defineProperty(src_client_Certificate, "certificateObjectTypeID", '8d05dca5-5f42-4dc9-8bf9-f534c6570994:CERTIFICATE');
-const client_CertificateBundleSchemaInternal = {
-  sequenceOf: client_CertificateSchemaInternal
-};
-var client_raw2 = /*#__PURE__*/new WeakMap();
-var client_contents = /*#__PURE__*/new WeakMap();
-class src_client_CertificateBundle {
-  constructor(input) {
-    client_certificate_classPrivateFieldInitSpec(this, client_raw2, void 0);
-    client_certificate_classPrivateFieldInitSpec(this, client_contents, void 0);
-    if (src_client_CertificateBundle.isInstance(input)) {
-      client_certificate_classPrivateFieldSet(client_raw2, this, input.getDER());
-    } else if (Array.isArray(input) || input instanceof Set) {
-      if (input instanceof Set) {
-        input = Array.from(input);
-      }
-      const decodedInput = input.map(function (certificate) {
-        let decoded;
-        if (src_client_Certificate.isCertificate(certificate)) {
-          decoded = new client_BufferStorageASN1(certificate.toDER());
-        } else {
-          decoded = new client_BufferStorageASN1(new src_client_Certificate(certificate).toDER());
-        }
-        // For some reason the typescript compiler cannot understand this, but we do not care about it being typed because we are validating it right after.
-        // @ts-ignore
-        const output = decoded.getASN1();
-        return output;
-      });
-      client_certificate_classPrivateFieldSet(client_raw2, this, new client_BufferStorageASN1(decodedInput, client_CertificateBundleSchemaInternal).getDER());
-    } else {
-      if (typeof input === 'string') {
-        input = client_certificate_Buffer.from(input, 'base64');
-      }
-      if (client_certificate_Buffer.isBuffer(input)) {
-        input = client_bufferToArrayBuffer(input);
-      }
-      client_certificate_classPrivateFieldSet(client_raw2, this, input);
-    }
-    const decoded = new client_BufferStorageASN1(client_certificate_classPrivateFieldGet(client_raw2, this), client_CertificateBundleSchemaInternal);
-    client_certificate_classPrivateFieldSet(client_contents, this, []);
-    const seenHashes = new src_client_CertificateHash.Set();
-    for (const item of decoded.getASN1()) {
-      const certificateValue = new client_BufferStorageASN1(item, client_CertificateSchemaInternal);
-      const certificate = new src_client_Certificate(certificateValue.getDER());
-      const hash = certificate.hash();
-      if (seenHashes.has(hash)) {
-        throw new src_client_KeetaNetCertificateError('CERTIFICATE_DUPLICATE_INCLUDED', `Duplicate certificate ${hash} within certificate bundle`);
-      }
-      seenHashes.add(hash);
-      client_certificate_classPrivateFieldGet(client_contents, this).push(certificate);
-    }
-  }
-  get bundleSize() {
-    return client_certificate_classPrivateFieldGet(client_contents, this).length;
-  }
-  getDER() {
-    return client_certificate_classPrivateFieldGet(client_raw2, this);
-  }
-  getDERBuffer() {
-    return client_certificate_Buffer.from(this.getDER());
-  }
-  getCertificates() {
-    return client_certificate_classPrivateFieldGet(client_contents, this);
-  }
-  toJSON() {
-    return {
-      certificates: this.getCertificates().map(function (certificate) {
-        return certificate.toPEM();
-      })
-    };
-  }
-}
-client_CertificateBundle = src_client_CertificateBundle;
-client_utils_certificate_defineProperty(src_client_CertificateBundle, "isInstance", client_checkableGenerator(client_CertificateBundle));
 ;// ./src/lib/error/ledger.ts
 var client_KeetaNetLedgerError;
 function client_ledger_defineProperty(e, r, t) { return (r = client_ledger_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
@@ -121207,13 +121386,15 @@ const client_VoteErrorCodes = [
  */
 
 // Errors from constructing a vote
-'MALFORMED_WRAPPER', 'MALFORMED_VOTE_WRAPPER', 'MALFORMED_VOTE_CONTENT', 'MALFORMED_VOTE_CONTENT_EXTRA_DATA', 'MALFORMED_VOTE_VERSION', 'MALFORMED_VOTE_SERIAL', 'MALFORMED_VOTE_SIGNATURE_INFORMATION', 'MALFORMED_VOTE_ISSUER_INFORMATION', 'MALFORMED_VOTE_SUBJECT_INFORMATION', 'MALFORMED_VOTE_VALIDITY_INFORMATION', 'MALFORMED_VOTE_SERIAL', 'MALFORMED_VOTE_EXTENSIONS', 'MALFORMED_VOTE_EXTENSIONS_VALUE', 'MALFORMED_VOTE_EXTENSIONS_VALUE_OID', 'MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL', 'MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL_TYPE', 'MALFORMED_VOTE_EXTENSIONS_VALUE_HASH_DATA', 'MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_ISSUER', 'MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_WRAPPER', 'MALFORMED_VOTE_SIGNATURE_SCHEME_ECDSA_INVALID_CURVE', 'MALFORMED_VOTE_SIGNATURE_UNSUPPORTED_SCHEME', 'MALFORMED_VOTE_SUBJECT_PUBLIC_KEY_INFORMATION', 'MALFORMED_VOTE_SIGNATURE_VALUE', 'MALFORMED_VOTE_NO_BLOCKS_FOUND',
+'MALFORMED_WRAPPER', 'MALFORMED_VOTE_WRAPPER', 'MALFORMED_VOTE_CONTENT', 'MALFORMED_VOTE_CONTENT_EXTRA_DATA', 'MALFORMED_VOTE_VERSION', 'MALFORMED_VOTE_SERIAL', 'MALFORMED_VOTE_SIGNATURE_INFORMATION', 'MALFORMED_VOTE_ISSUER_INFORMATION', 'MALFORMED_VOTE_SUBJECT_INFORMATION', 'MALFORMED_VOTE_VALIDITY_INFORMATION', 'MALFORMED_VOTE_SERIAL', 'MALFORMED_VOTE_EXTENSIONS', 'MALFORMED_VOTE_EXTENSIONS_DATA', 'MALFORMED_VOTE_EXTENSIONS_VALUE', 'MALFORMED_VOTE_EXTENSIONS_VALUE_OID', 'MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL', 'MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL_TYPE', 'MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_ISSUER', 'MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_WRAPPER', 'MALFORMED_VOTE_SIGNATURE_SCHEME_ECDSA_INVALID_CURVE', 'MALFORMED_VOTE_SIGNATURE_UNSUPPORTED_SCHEME', 'MALFORMED_VOTE_SUBJECT_PUBLIC_KEY_INFORMATION', 'MALFORMED_VOTE_SIGNATURE_VALUE', 'MALFORMED_VOTE_NO_BLOCKS_FOUND',
 // Errors from constructing a staple
 'MALFORMED_STAPLE', 'MALFORMED_STAPLE_BLOCKS', 'MALFORMED_STAPLE_BLOCKS_AT_LEAST_ONE', 'MALFORMED_STAPLE_VOTES', 'MALFORMED_STAPLE_VOTES_AT_LEAST_ONE',
 // Errors created from the findRDN function
 'MALFORMED_FIND_RDN_INVALID_TYPE', 'MALFORMED_FIND_RDN_MUST_HAVE_ONE', 'MALFORMED_FIND_RDN_PART_WELL_FORMED', 'MALFORMED_FIND_RDN_MUST_BE_SET', 'MALFORMED_FIND_RDN_TYPE_MUST_BE_OID',
 // Errors from the blockHashesFromVote function
-'MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT', 'MALFORMED_HASHES_FROM_VOTE_INVALID_TYPE', 'MALFORMED_HASHES_FROM_VOTE_INVALID_CONTEXT_SPECIFIC', 'MALFORMED_HASHES_FROM_VOTE_DATA_NEEDS_OID', 'MALFORMED_HASHES_FROM_VOTE_DATA_HASH_DATA_MUST_BE_SEQUENCE', 'MALFORMED_HASHES_FROM_VOTE_DATA_NOT_TWO_ITEMS', 'MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_FUNC', 'MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_TYPE', 'MALFORMED_HASHES_FROM_VOTE_DATA_SECOND_MUST_BE_SEQUENCE'];
+'MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT', 'MALFORMED_HASHES_FROM_VOTE_INVALID_TYPE', 'MALFORMED_HASHES_FROM_VOTE_INVALID_CONTEXT_SPECIFIC', 'MALFORMED_HASHES_FROM_VOTE_DATA_NEEDS_OID', 'MALFORMED_HASHES_FROM_VOTE_DATA_HASH_DATA_MUST_BE_SEQUENCE', 'MALFORMED_HASHES_FROM_VOTE_DATA_NOT_TWO_ITEMS', 'MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_FUNC', 'MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_TYPE', 'MALFORMED_HASHES_FROM_VOTE_DATA_SECOND_MUST_BE_SEQUENCE',
+// Errors from the feesFromVote function
+'MALFORMED_FEES_AMOUNT', 'MALFORMED_FEES_FROM_VOTE_INVALID_INPUT', 'MALFORMED_FEES_IN_PERMANENT_VOTE', 'MALFORMED_FEES_PAY_TO_INVALID', 'MALFORMED_FEES_TOKEN_NOT_TOKEN'];
 class src_client_KeetaNetVoteError extends src_client_KeetaNetError {
   constructor(code, message) {
     super(code, message, {
@@ -121253,6 +121434,10 @@ function client_lib_vote_toPrimitive(t, r) { if ("object" != typeof t || !t) ret
 
 
 
+/**
+ * Representation of the expected fee for this vote
+ */
+
 /**
  * Representation of the vote
  */
@@ -121265,6 +121450,26 @@ class src_client_VoteHash extends src_client_BufferStorage {
 }
 client_VoteHash = src_client_VoteHash;
 client_lib_vote_defineProperty(src_client_VoteHash, "isInstance", client_checkableGenerator(client_VoteHash));
+const client_feeExtensionSchema = {
+  type: 'context',
+  value: 0,
+  kind: 'explicit',
+  contains: [client_ValidateASN1.IsInteger, {
+    optional: {
+      type: 'context',
+      value: 0,
+      kind: 'implicit',
+      contains: client_ValidateASN1.IsOctetString
+    }
+  }, {
+    optional: {
+      type: 'context',
+      value: 1,
+      kind: 'implicit',
+      contains: client_ValidateASN1.IsOctetString
+    }
+  }]
+};
 /**
  * Parse a set of distinguished names
  */
@@ -121305,14 +121510,8 @@ function client_findRDN(input, findOID) {
 }
 function client_blockHashesFromVote(input) {
   const blockHashInformation = client_ASN1toJS(input.buffer);
-  if (blockHashInformation === undefined || blockHashInformation === null) {
-    throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT', 'internal error: hashData extension contains Null or unknown tag');
-  }
-  if (typeof blockHashInformation === 'bigint' || typeof blockHashInformation !== 'object') {
-    throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT', 'internal error: hashData extension contains bigint or non object value');
-  }
-  if (client_vote_Buffer.isBuffer(blockHashInformation) || client_util.types.isDate(blockHashInformation) || Array.isArray(blockHashInformation)) {
-    throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT', 'internal error: hashData extension contains incorrect data type');
+  if (!client_isASN1Object(blockHashInformation)) {
+    throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT', 'internal error: hashData extensions is not valid asn1 object');
   }
   if (blockHashInformation.type !== 'context') {
     throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_HASHES_FROM_VOTE_INVALID_TYPE', 'internal error: hashData extension does not contain a context-specific tag');
@@ -121350,6 +121549,47 @@ function client_blockHashesFromVote(input) {
   }
   return output;
 }
+function client_feeFromVote(input) {
+  const feeInformationAnyJS = client_ASN1toJS(input.buffer);
+  const feeSchemaChecker = new client_ValidateASN1(client_feeExtensionSchema);
+  const feeInformation = function () {
+    try {
+      return feeSchemaChecker.validate(feeInformationAnyJS);
+    } catch (asn1ValidateError) {
+      let message = 'internal error: fee asn1 schema is not the right format';
+      if (asn1ValidateError instanceof Error) {
+        message = `${message}: ${asn1ValidateError.message}`;
+      }
+      throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_FEES_FROM_VOTE_INVALID_INPUT', message);
+    }
+  }();
+  const feeData = feeInformation.contains;
+  const retval = {
+    amount: feeData[0]
+  };
+  const payToAsn1 = feeData[1];
+  if (payToAsn1 !== undefined) {
+    const payTo = client_lib_account.fromPublicKeyAndType(client_vote_Buffer.from(payToAsn1.contains));
+    if (payTo.isStorage()) {
+      retval.payTo = payTo;
+    } else {
+      try {
+        retval.payTo = payTo.assertAccount();
+      } catch {
+        throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_FEES_PAY_TO_INVALID', 'internal error: payTo is not an Account or Storage Address');
+      }
+    }
+  }
+  const tokenAsn1 = feeData[2];
+  if (tokenAsn1 !== undefined) {
+    const token = client_lib_account.fromPublicKeyAndType(client_vote_Buffer.from(tokenAsn1.contains));
+    if (!token.isToken()) {
+      throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_FEES_TOKEN_NOT_TOKEN', 'internal error: fees extension token is not a valid token');
+    }
+    retval.token = token;
+  }
+  return retval;
+}
 
 /**
  * Convert an ASN1Date to a Date
@@ -121489,6 +121729,9 @@ class src_client_VoteBlockHash extends src_client_BufferStorage {
 client_VoteBlockHash = src_client_VoteBlockHash;
 client_lib_vote_defineProperty(src_client_VoteBlockHash, "isInstance", client_checkableGenerator(client_VoteBlockHash));
 client_lib_vote_defineProperty(src_client_VoteBlockHash, "Map", client_VoteBlockHashMap);
+/**
+ * Options for Vote Builder
+ */
 var client_vote = /*#__PURE__*/new WeakMap();
 var client_options = /*#__PURE__*/new WeakMap();
 var client_vote_hash = /*#__PURE__*/new WeakMap();
@@ -121500,6 +121743,21 @@ class src_client_PossiblyExpiredVote {
         return false;
       }
     }
+    if ('fee' in voteJSON) {
+      const fee = voteJSON['fee'];
+      if (fee === undefined) {
+        return false;
+      }
+      if (fee['amount'] === undefined) {
+        return false;
+      }
+      if ('payTo' in fee && fee['payTo'] === undefined) {
+        return false;
+      }
+      if ('token' in fee && fee['token'] === undefined) {
+        return false;
+      }
+    }
     return true;
   }
   static fromJSON(voteJSON) {
@@ -121522,6 +121780,9 @@ class src_client_PossiblyExpiredVote {
     const validTo = new Date(voteJSON.validityTo);
     const validFrom = new Date(voteJSON.validityFrom);
     const signatureStorage = new src_client_BufferStorage(signature, signature.byteLength);
+    if (voteJSON.fee !== undefined) {
+      voteBuilder.addFee(voteJSON.fee);
+    }
     const {
       voteData,
       tbsCertificate,
@@ -121548,6 +121809,7 @@ class src_client_PossiblyExpiredVote {
       this.validityFrom = vote.validityFrom;
       this.validityTo = vote.validityTo;
       this.signature = vote.signature;
+      this.fee = vote.fee;
       this.$trusted = vote.$trusted;
       this.$permanent = vote.$permanent;
       this.$uid = vote.$uid;
@@ -121761,6 +122023,7 @@ class src_client_PossiblyExpiredVote {
       throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_VOTE_EXTENSIONS', 'internal error: Expected extensions to be a Sequence');
     }
     let blocks;
+    let fee;
     for (const extensionInfo of extensions) {
       if (!Array.isArray(extensionInfo)) {
         throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_VOTE_EXTENSIONS_VALUE', 'internal error: Expected each extension to be a Sequence');
@@ -121784,13 +122047,18 @@ class src_client_PossiblyExpiredVote {
         critical = criticalCheck;
       }
       const extensionData = extensionInfo.shift();
+      if (!client_vote_Buffer.isBuffer(extensionData)) {
+        throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_VOTE_EXTENSIONS_DATA', `internal error: ${extensionOID.oid} extensions are always Octet String`);
+      }
       switch (extensionOID.oid) {
         case 'hashData':
-          if (!client_vote_Buffer.isBuffer(extensionData)) {
-            throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_VOTE_EXTENSIONS_VALUE_HASH_DATA', 'internal error: hashData extensions are always Octet String');
-          }
           blocks = client_blockHashesFromVote(extensionData);
           break;
+        case '1.3.6.1.4.1.62675.0.1.0':
+        case 'fees':
+          // replace with fees 1.3.6.1.4.1.62675.0.1.0
+          fee = client_feeFromVote(extensionData);
+          break;
         default:
           if (critical) {
             throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL_TYPE', `internal error: Unknown critical extension ${extensionOID.oid}`);
@@ -121804,6 +122072,12 @@ class src_client_PossiblyExpiredVote {
       throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_VOTE_NO_BLOCKS_FOUND', 'No block hashes found within vote');
     }
     this.blocks = blocks;
+    if (fee !== undefined) {
+      if (this.$permanent) {
+        throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_FEES_IN_PERMANENT_VOTE', 'Permanent Vote cannot have fees');
+      }
+      this.fee = fee;
+    }
 
     /**
      * Get the signature data
@@ -121918,6 +122192,9 @@ class src_client_PossiblyExpiredVote {
     if (options !== null && options !== void 0 && options.addBinary) {
       additionalFields['$binary'] = client_vote_Buffer.from(this.toBytes()).toString('base64');
     }
+    if (this.fee !== undefined) {
+      additionalFields['fee'] = this.fee;
+    }
     return {
       issuer: this.issuer,
       serial: this.serial,
@@ -122422,16 +122699,20 @@ client_VoteStaple = src_client_VoteStaple;
 client_lib_vote_defineProperty(src_client_VoteStaple, "isInstance", client_checkableGenerator(client_VoteStaple));
 var client_account = /*#__PURE__*/new WeakMap();
 var client_blocks = /*#__PURE__*/new WeakMap();
+var client_fee = /*#__PURE__*/new WeakMap();
 class src_client_VoteBuilder {
   constructor(account) {
     let blocks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    let options = arguments.length > 2 ? arguments[2] : undefined;
     client_vote_classPrivateFieldInitSpec(this, client_account, void 0);
     client_vote_classPrivateFieldInitSpec(this, client_blocks, void 0);
+    client_vote_classPrivateFieldInitSpec(this, client_fee, undefined);
     if (!client_lib_account.isInstance(account)) {
       throw new src_client_KeetaNetVoteError('VOTE_BUILDER_INVALID_CONSTRUCTION', 'internal error: account must be an Account');
     }
     client_vote_classPrivateFieldSet(client_account, this, account);
     client_vote_classPrivateFieldSet(client_blocks, this, []);
+    client_vote_classPrivateFieldSet(client_fee, this, options === null || options === void 0 ? void 0 : options.fee);
     this.addBlocks(blocks);
   }
   addBlocks(blocks) {
@@ -122453,6 +122734,27 @@ class src_client_VoteBuilder {
   addBlock(block) {
     this.addBlocks([block]);
   }
+  addFee(feeInput) {
+    const fee = {
+      amount: BigInt(feeInput.amount)
+    };
+    const payTo = client_lib_account.toAccount(feeInput.payTo);
+    if (payTo !== undefined) {
+      if (payTo.isStorage()) {
+        fee.payTo = payTo;
+      } else {
+        fee.payTo = payTo.assertAccount();
+      }
+    }
+    const token = client_lib_account.toAccount(fee.token);
+    if (token !== undefined) {
+      if (token.isToken()) {
+        fee.token = token;
+      }
+      throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_FEES_TOKEN_NOT_TOKEN', 'Fee Token should be of type TOKEN');
+    }
+    client_vote_classPrivateFieldSet(client_fee, this, fee);
+  }
   generateVoteData(serial, validTo, validFrom) {
     /**
      * Signature algorithm identifier
@@ -122494,6 +122796,45 @@ class src_client_VoteBuilder {
       type: 'oid',
       oid: signatureInfoOID
     }];
+    let feeExtension = undefined;
+    if (client_vote_classPrivateFieldGet(client_fee, this) !== undefined) {
+      var _classPrivateFieldGet2, _classPrivateFieldGet3;
+      /** Amount for this vote */
+      const feeData = [client_vote_classPrivateFieldGet(client_fee, this).amount];
+
+      /** Account to pay the fee too */
+      const payToPublicKey = (_classPrivateFieldGet2 = client_vote_classPrivateFieldGet(client_fee, this).payTo) === null || _classPrivateFieldGet2 === void 0 ? void 0 : _classPrivateFieldGet2.publicKeyAndType;
+      if (payToPublicKey !== undefined) {
+        feeData.push({
+          type: 'context',
+          value: 0,
+          kind: 'implicit',
+          contains: payToPublicKey
+        });
+      }
+
+      /** Token in which to pay the fee */
+      const tokenPublicKey = (_classPrivateFieldGet3 = client_vote_classPrivateFieldGet(client_fee, this).token) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.publicKeyAndType;
+      if (tokenPublicKey !== undefined) {
+        feeData.push({
+          type: 'context',
+          value: 1,
+          kind: 'implicit',
+          contains: tokenPublicKey
+        });
+      }
+      feeExtension = [{
+        type: 'oid',
+        oid: '1.3.6.1.4.1.62675.0.1.0'
+      },
+      // replace with 'fees' - 1.3.6.1.4.1.62675.0.1.0
+      true, client_vote_Buffer.from(client_JStoASN1({
+        type: 'context',
+        value: 0,
+        kind: 'explicit',
+        contains: feeData
+      }).toBER(false))];
+    }
 
     /*
      * Certificate to be signed
@@ -122572,7 +122913,7 @@ class src_client_VoteBuilder {
         client_vote_classPrivateFieldGet(client_blocks, this).map(function (blockhash) {
           return blockhash.getBuffer();
         })]
-      }).toBER(false))]]
+      }).toBER(false))], ...(feeExtension ? [feeExtension] : [])]
     }];
     let toSign;
     const tbsCertificateDER = client_vote_Buffer.from(client_JStoASN1(tbsCertificate).toBER(false));
@@ -122622,6 +122963,9 @@ class src_client_VoteBuilder {
     if (typeof serial !== 'bigint') {
       throw new src_client_KeetaNetVoteError('VOTE_BUILDER_INVALID_SERIAL', `internal error: serial must be a bigint, instead got ${serial}`);
     }
+    if (validTo === null && client_vote_classPrivateFieldGet(client_fee, this) !== undefined) {
+      throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_FEES_IN_PERMANENT_VOTE', 'internal error: permanent votes should not have fees');
+    }
     if (validTo === null) {
       /**
        * Issue a permanent vote
@@ -122655,7 +122999,8 @@ src_client_PossiblyExpiredVote.Builder = src_client_VoteBuilder;
 /** @internal */
 const src_client_Testing = {
   findRDN: client_findRDN,
-  blockHashesFromVote: client_blockHashesFromVote
+  blockHashesFromVote: client_blockHashesFromVote,
+  feeFromVote: client_feeFromVote
 };
 ;// ./src/lib/ledger/effects.ts
 
@@ -125324,83 +125669,6 @@ function client_getDurationRange(duration) {
   return range;
 }
 /* harmony default export */ const client_stats = (client_Stats);
-;// ./node_modules/uuid/dist/esm-browser/native.js
-const client_randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-/* harmony default export */ const client_esm_browser_native = ({ randomUUID: client_randomUUID });
-
-;// ./node_modules/uuid/dist/esm-browser/rng.js
-let client_getRandomValues;
-const client_rnds8 = new Uint8Array(16);
-function client_rng() {
-    if (!client_getRandomValues) {
-        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
-            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
-        }
-        client_getRandomValues = crypto.getRandomValues.bind(crypto);
-    }
-    return client_getRandomValues(client_rnds8);
-}
-
-;// ./node_modules/uuid/dist/esm-browser/stringify.js
-
-const client_byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-    client_byteToHex.push((i + 0x100).toString(16).slice(1));
-}
-function client_unsafeStringify(arr, offset = 0) {
-    return (client_byteToHex[arr[offset + 0]] +
-        client_byteToHex[arr[offset + 1]] +
-        client_byteToHex[arr[offset + 2]] +
-        client_byteToHex[arr[offset + 3]] +
-        '-' +
-        client_byteToHex[arr[offset + 4]] +
-        client_byteToHex[arr[offset + 5]] +
-        '-' +
-        client_byteToHex[arr[offset + 6]] +
-        client_byteToHex[arr[offset + 7]] +
-        '-' +
-        client_byteToHex[arr[offset + 8]] +
-        client_byteToHex[arr[offset + 9]] +
-        '-' +
-        client_byteToHex[arr[offset + 10]] +
-        client_byteToHex[arr[offset + 11]] +
-        client_byteToHex[arr[offset + 12]] +
-        client_byteToHex[arr[offset + 13]] +
-        client_byteToHex[arr[offset + 14]] +
-        client_byteToHex[arr[offset + 15]]).toLowerCase();
-}
-function src_client_stringify(arr, offset = 0) {
-    const uuid = client_unsafeStringify(arr, offset);
-    if (!validate(uuid)) {
-        throw TypeError('Stringified UUID is invalid');
-    }
-    return uuid;
-}
-/* harmony default export */ const client_esm_browser_stringify = ((/* unused pure expression or super */ null && (src_client_stringify)));
-
-;// ./node_modules/uuid/dist/esm-browser/v4.js
-
-
-
-function client_v4(options, buf, offset) {
-    if (client_esm_browser_native.randomUUID && !buf && !options) {
-        return client_esm_browser_native.randomUUID();
-    }
-    options = options || {};
-    const rnds = options.random || (options.rng || client_rng)();
-    rnds[6] = (rnds[6] & 0x0f) | 0x40;
-    rnds[8] = (rnds[8] & 0x3f) | 0x80;
-    if (buf) {
-        offset = offset || 0;
-        for (let i = 0; i < 16; ++i) {
-            buf[offset + i] = rnds[i];
-        }
-        return buf;
-    }
-    return client_unsafeStringify(rnds);
-}
-/* harmony default export */ const client_esm_browser_v4 = (client_v4);
-
 // EXTERNAL MODULE: ws (ignored)
 var client_ws_ignored_ = __webpack_require__(4708);
 ;// ./src/lib/p2p.ts
@@ -127718,7 +127986,7 @@ async function client_generateInitialVoteStaple(options) {
   Utils: {
     ASN1: client_utils_asn1_namespaceObject,
     Bloom: client_bloom_namespaceObject,
-    Buffer: client_buffer_namespaceObject,
+    Buffer: client_utils_buffer_namespaceObject,
     Hash: client_hash_namespaceObject,
     Helper: client_helper_namespaceObject,
     Initial: client_initial_namespaceObject,
@@ -127727,7 +127995,7 @@ async function client_generateInitialVoteStaple(options) {
   }
 });
 ;// ./src/version.ts
-const client_version = '0.12.0+g0baa5ce2aac600e17a0fe832eadebcacebe23bf1';
+const client_version = '0.12.2+g77a8a16ada9dfab5604b605cbe69d373a414d204';
 /* harmony default export */ const client_src_version = ((/* unused pure expression or super */ null && (client_version)));
 ;// ./src/lib/error/client.ts
 var client_KeetaNetClientError;