@chainflip/processor 2.1.0-alpha.3 → 2.1.0-alpha.4

package/dist/node_modules/.pnpm/@polkadot_util-crypto@14.0.1_@polkadot_util@14.0.1/node_modules/@polkadot/util-crypto/ethereum/encode.cjs

@@ -0,0 +1,28 @@
+const require_toU8a = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/u8a/toU8a.cjs');
+const require_toHex = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/u8a/toHex.cjs');
+const require_asU8a = require('../keccak/asU8a.cjs');
+const require_expand = require('../secp256k1/expand.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util-crypto@14.0.1_@polkadot+util@14.0.1/node_modules/@polkadot/util-crypto/ethereum/encode.js
+function getH160(u8a) {
+	if ([33, 65].includes(u8a.length)) u8a = require_asU8a.keccakAsU8a(require_expand.secp256k1Expand(u8a));
+	return u8a.slice(-20);
+}
+function ethereumEncode(addressOrPublic) {
+	if (!addressOrPublic) return "0x";
+	const u8aAddress = require_toU8a.u8aToU8a(addressOrPublic);
+	if (![
+		20,
+		32,
+		33,
+		65
+	].includes(u8aAddress.length)) throw new Error(`Invalid address or publicKey provided, received ${u8aAddress.length} bytes input`);
+	const address = require_toHex.u8aToHex(getH160(u8aAddress), -1, false);
+	const hash = require_toHex.u8aToHex(require_asU8a.keccakAsU8a(address), -1, false);
+	let result = "";
+	for (let i = 0; i < 40; i++) result = `${result}${parseInt(hash[i], 16) > 7 ? address[i].toUpperCase() : address[i]}`;
+	return `0x${result}`;
+}
+
+//#endregion
+exports.ethereumEncode = ethereumEncode;

package/dist/node_modules/.pnpm/@polkadot_util-crypto@14.0.1_@polkadot_util@14.0.1/node_modules/@polkadot/util-crypto/ethereum/isAddress.cjs

@@ -0,0 +1,12 @@
+const require_hex = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/hex.cjs');
+const require_isChecksum = require('./isChecksum.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util-crypto@14.0.1_@polkadot+util@14.0.1/node_modules/@polkadot/util-crypto/ethereum/isAddress.js
+function isEthereumAddress(address) {
+	if (!address || address.length !== 42 || !require_hex.isHex(address)) return false;
+	else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) return true;
+	return require_isChecksum.isEthereumChecksum(address);
+}
+
+//#endregion
+exports.isEthereumAddress = isEthereumAddress;

package/dist/node_modules/.pnpm/@polkadot_util-crypto@14.0.1_@polkadot_util@14.0.1/node_modules/@polkadot/util-crypto/ethereum/isChecksum.cjs

@@ -0,0 +1,16 @@
+const require_toHex = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/u8a/toHex.cjs');
+const require_asU8a = require('../keccak/asU8a.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util-crypto@14.0.1_@polkadot+util@14.0.1/node_modules/@polkadot/util-crypto/ethereum/isChecksum.js
+function isInvalidChar(char, byte) {
+	return char !== (byte > 7 ? char.toUpperCase() : char.toLowerCase());
+}
+function isEthereumChecksum(_address) {
+	const address = _address.replace("0x", "");
+	const hash = require_toHex.u8aToHex(require_asU8a.keccakAsU8a(address.toLowerCase()), -1, false);
+	for (let i = 0; i < 40; i++) if (isInvalidChar(address[i], parseInt(hash[i], 16))) return false;
+	return true;
+}
+
+//#endregion
+exports.isEthereumChecksum = isEthereumChecksum;

package/dist/node_modules/.pnpm/@polkadot_util-crypto@14.0.1_@polkadot_util@14.0.1/node_modules/@polkadot/util-crypto/helpers.cjs

@@ -0,0 +1,15 @@
+const require_has = require('../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/has.cjs');
+const require_toU8a = require('../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/u8a/toU8a.cjs');
+const require_bundle = require('../../../../@polkadot_wasm-crypto@7.5.4_@polkadot_util@14.0.1_@polkadot_x-randomvalues@14.0.1_@polk_66de4b6310fb21b1adaa456362dbc346/node_modules/@polkadot/wasm-crypto/bundle.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util-crypto@14.0.1_@polkadot+util@14.0.1/node_modules/@polkadot/util-crypto/helpers.js
+/** @internal */
+function createDualHasher(wa, js) {
+	return (value, bitLength = 256, onlyJs) => {
+		const u8a = require_toU8a.u8aToU8a(value);
+		return !require_has.hasBigInt || !onlyJs && require_bundle.isReady() ? wa[bitLength](u8a) : js[bitLength](u8a);
+	};
+}
+
+//#endregion
+exports.createDualHasher = createDualHasher;

package/dist/node_modules/.pnpm/@polkadot_util-crypto@14.0.1_@polkadot_util@14.0.1/node_modules/@polkadot/util-crypto/keccak/asU8a.cjs

@@ -0,0 +1,29 @@
+const require_bundle = require('../../../../../@polkadot_wasm-crypto@7.5.4_@polkadot_util@14.0.1_@polkadot_x-randomvalues@14.0.1_@polk_66de4b6310fb21b1adaa456362dbc346/node_modules/@polkadot/wasm-crypto/bundle.cjs');
+const require_helpers = require('../helpers.cjs');
+const require_sha3 = require('../../../../../@noble_hashes@1.8.0/node_modules/@noble/hashes/esm/sha3.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util-crypto@14.0.1_@polkadot+util@14.0.1/node_modules/@polkadot/util-crypto/keccak/asU8a.js
+/**
+* @name keccakAsU8a
+* @summary Creates a keccak Uint8Array from the input.
+* @description
+* From either a `string` or a `Buffer` input, create the keccak and return the result as a `Uint8Array`.
+* @example
+* <BR>
+*
+* ```javascript
+* import { keccakAsU8a } from '@polkadot/util-crypto';
+*
+* keccakAsU8a('123'); // => Uint8Array
+* ```
+*/
+const keccakAsU8a = /* @__PURE__ */ require_helpers.createDualHasher({
+	256: require_bundle.keccak256,
+	512: require_bundle.keccak512
+}, {
+	256: require_sha3.keccak_256,
+	512: require_sha3.keccak_512
+});
+
+//#endregion
+exports.keccakAsU8a = keccakAsU8a;

package/dist/node_modules/.pnpm/@polkadot_util-crypto@14.0.1_@polkadot_util@14.0.1/node_modules/@polkadot/util-crypto/secp256k1/expand.cjs

@@ -0,0 +1,18 @@
+const require_has = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/has.cjs');
+const require_concat = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/u8a/concat.cjs');
+const require_toU8a = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/bn/toU8a.cjs');
+const require_bundle = require('../../../../../@polkadot_wasm-crypto@7.5.4_@polkadot_util@14.0.1_@polkadot_x-randomvalues@14.0.1_@polk_66de4b6310fb21b1adaa456362dbc346/node_modules/@polkadot/wasm-crypto/bundle.cjs');
+const require_bn = require('../bn.cjs');
+const require_secp256k1 = require('../../../../../@noble_curves@1.9.7/node_modules/@noble/curves/esm/secp256k1.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util-crypto@14.0.1_@polkadot+util@14.0.1/node_modules/@polkadot/util-crypto/secp256k1/expand.js
+function secp256k1Expand(publicKey, onlyJs) {
+	if (![33, 65].includes(publicKey.length)) throw new Error(`Invalid publicKey provided, received ${publicKey.length} bytes input`);
+	if (publicKey.length === 65) return publicKey.subarray(1);
+	if (!require_has.hasBigInt || !onlyJs && require_bundle.isReady()) return require_bundle.secp256k1Expand(publicKey).subarray(1);
+	const { px, py } = require_secp256k1.secp256k1.ProjectivePoint.fromHex(publicKey);
+	return require_concat.u8aConcat(require_toU8a.bnToU8a(px, require_bn.BN_BE_256_OPTS), require_toU8a.bnToU8a(py, require_bn.BN_BE_256_OPTS));
+}
+
+//#endregion
+exports.secp256k1Expand = secp256k1Expand;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/assert.cjs

@@ -0,0 +1,41 @@
+const require_function = require('./is/function.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/assert.js
+/**
+* @name assert
+* @summary Checks for a valid test, if not Error is thrown.
+* @description
+* Checks that `test` is a truthy value. If value is falsy (`null`, `undefined`, `false`, ...), it throws an Error with the supplied `message`. When `test` passes, `true` is returned.
+* @example
+* <BR>
+*
+* ```javascript
+* const { assert } from '@polkadot/util';
+*
+* assert(true, 'True should be true'); // passes
+* assert(false, 'False should not be true'); // Error thrown
+* assert(false, () => 'message'); // Error with 'message'
+* ```
+*/
+function assert(condition, message) {
+	if (!condition) throw new Error(require_function.isFunction(message) ? message() : message);
+}
+/**
+* @name assertReturn
+* @description Returns when the value is not undefined/null, otherwise throws assertion error
+*/
+function assertReturn(value, message) {
+	assert(value !== void 0 && value !== null, message);
+	return value;
+}
+/**
+* @name assertUnreachable
+* @description An assertion helper that ensures all codepaths are followed
+*/
+function assertUnreachable(x) {
+	throw new Error(`This codepath should be unreachable. Unhandled input: ${x}`);
+}
+
+//#endregion
+exports.assertReturn = assertReturn;
+exports.assertUnreachable = assertUnreachable;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/bn/bn.cjs

@@ -0,0 +1,13 @@
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.cjs');
+const require_bn$1 = require('../../../../../bn.js@5.2.2/node_modules/bn.js/lib/bn.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/bn/bn.js
+var import_bn = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_bn$1.default, 1);
+
+//#endregion
+Object.defineProperty(exports, 'import_bn', {
+  enumerable: true,
+  get: function () {
+    return import_bn;
+  }
+});

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/bn/consts.cjs

@@ -0,0 +1,46 @@
+const require_bn = require('./bn.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/bn/consts.js
+/**
+* @name BN_ONE
+* @summary BN constant for 1.
+*/
+const BN_ONE = /* @__PURE__ */ new require_bn.import_bn.default(1);
+/**
+* @name BN_TWO
+* @summary BN constant for 2.
+*/
+const BN_TWO = /* @__PURE__ */ new require_bn.import_bn.default(2);
+/**
+* @name BN_HUNDRED
+* @summary BN constant for 100.
+*/
+const BN_HUNDRED = /* @__PURE__ */ new require_bn.import_bn.default(100);
+/**
+* @name BN_MILLION
+* @summary BN constant for 1,000,000.
+*/
+const BN_MILLION = /* @__PURE__ */ new require_bn.import_bn.default(1e6);
+/**
+* @name BN_BILLION
+* @summary BN constant for 1,000,000,000.
+*/
+const BN_BILLION = /* @__PURE__ */ new require_bn.import_bn.default(1e9);
+/**
+* @name BN_QUINTILL
+* @summary BN constant for 1,000,000,000,000,000,000.
+*/
+const BN_QUINTILL = BN_BILLION.mul(BN_BILLION);
+/**
+* @name BN_MAX_INTEGER
+* @summary BN constant for MAX_SAFE_INTEGER
+*/
+const BN_MAX_INTEGER = /* @__PURE__ */ new require_bn.import_bn.default(Number.MAX_SAFE_INTEGER);
+
+//#endregion
+exports.BN_BILLION = BN_BILLION;
+exports.BN_HUNDRED = BN_HUNDRED;
+exports.BN_MILLION = BN_MILLION;
+exports.BN_ONE = BN_ONE;
+exports.BN_QUINTILL = BN_QUINTILL;
+exports.BN_TWO = BN_TWO;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/bn/toBn.cjs

@@ -0,0 +1,30 @@
+const require_bn = require('./bn.cjs');
+const require_hex = require('../is/hex.cjs');
+const require_toBigInt = require('../is/toBigInt.cjs');
+const require_toBn = require('../is/toBn.cjs');
+const require_toBn$1 = require('../hex/toBn.cjs');
+const require_bigInt = require('../is/bigInt.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/bn/toBn.js
+/**
+* @name bnToBn
+* @summary Creates a BN value from a BN, bigint, string (base 10 or hex) or number input.
+* @description
+* `null` inputs returns a `0x0` result, BN values returns the value, numbers returns a BN representation.
+* @example
+* <BR>
+*
+* ```javascript
+* import BN from 'bn.js';
+* import { bnToBn } from '@polkadot/util';
+*
+* bnToBn(0x1234); // => BN(0x1234)
+* bnToBn(new BN(0x1234)); // => BN(0x1234)
+* ```
+*/
+function bnToBn(value) {
+	return value ? require_bn.import_bn.default.isBN(value) ? value : require_hex.isHex(value) ? require_toBn$1.hexToBn(value.toString()) : require_bigInt.isBigInt(value) ? new require_bn.import_bn.default(value.toString()) : require_toBn.isToBn(value) ? value.toBn() : require_toBigInt.isToBigInt(value) ? new require_bn.import_bn.default(value.toBigInt().toString()) : new require_bn.import_bn.default(value) : new require_bn.import_bn.default(0);
+}
+
+//#endregion
+exports.bnToBn = bnToBn;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/bn/toHex.cjs

@@ -0,0 +1,29 @@
+const require_toHex = require('../u8a/toHex.cjs');
+const require_toU8a = require('./toU8a.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/bn/toHex.js
+/**
+* @name bnToHex
+* @summary Creates a hex value from a BN.js bignumber object.
+* @description
+* `null` inputs returns a `0x` result, BN values return the actual value as a `0x` prefixed hex value. Anything that is not a BN object throws an error. With `bitLength` set, it fixes the number to the specified length.
+* @example
+* <BR>
+*
+* ```javascript
+* import BN from 'bn.js';
+* import { bnToHex } from '@polkadot/util';
+*
+* bnToHex(new BN(0x123456)); // => '0x123456'
+* ```
+*/
+function bnToHex(value, { bitLength = -1, isLe = false, isNegative = false } = {}) {
+	return require_toHex.u8aToHex(require_toU8a.bnToU8a(value, {
+		bitLength,
+		isLe,
+		isNegative
+	}));
+}
+
+//#endregion
+exports.bnToHex = bnToHex;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/bn/toU8a.cjs

@@ -0,0 +1,34 @@
+const require_toBn = require('./toBn.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/bn/toU8a.js
+const DEFAULT_OPTS = {
+	bitLength: -1,
+	isLe: true,
+	isNegative: false
+};
+/**
+* @name bnToU8a
+* @summary Creates a Uint8Array object from a BN.
+* @description
+* `null`/`undefined`/`NaN` inputs returns an empty `Uint8Array` result. `BN` input values return the actual bytes value converted to a `Uint8Array`. Optionally convert using little-endian format if `isLE` is set.
+* @example
+* <BR>
+*
+* ```javascript
+* import { bnToU8a } from '@polkadot/util';
+*
+* bnToU8a(new BN(0x1234)); // => [0x12, 0x34]
+* ```
+*/
+function bnToU8a(value, { bitLength = -1, isLe = true, isNegative = false } = DEFAULT_OPTS) {
+	const valueBn = require_toBn.bnToBn(value);
+	const byteLength = bitLength === -1 ? Math.ceil(valueBn.bitLength() / 8) : Math.ceil((bitLength || 0) / 8);
+	if (!value) return bitLength === -1 ? new Uint8Array(1) : new Uint8Array(byteLength);
+	const output = new Uint8Array(byteLength);
+	const bn = isNegative ? valueBn.toTwos(byteLength * 8) : valueBn;
+	output.set(bn.toArray(isLe ? "le" : "be", byteLength), 0);
+	return output;
+}
+
+//#endregion
+exports.bnToU8a = bnToU8a;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/compact/addLength.cjs

@@ -0,0 +1,22 @@
+const require_concat = require('../u8a/concat.cjs');
+const require_toU8a = require('./toU8a.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/compact/addLength.js
+/**
+* @name compactAddLength
+* @description Adds a length prefix to the input value
+* @example
+* <BR>
+*
+* ```javascript
+* import { compactAddLength } from '@polkadot/util';
+*
+* console.log(compactAddLength(new Uint8Array([0xde, 0xad, 0xbe, 0xef]))); // Uint8Array([4 << 2, 0xde, 0xad, 0xbe, 0xef])
+* ```
+*/
+function compactAddLength(input) {
+	return require_concat.u8aConcatStrict([require_toU8a.compactToU8a(input.length), input]);
+}
+
+//#endregion
+exports.compactAddLength = compactAddLength;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/compact/fromU8a.cjs

@@ -0,0 +1,57 @@
+const require_bn = require('../bn/bn.cjs');
+const require_toU8a = require('../u8a/toU8a.cjs');
+const require_toBn = require('../u8a/toBn.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/compact/fromU8a.js
+/**
+* @name compactFromU8a
+* @description Retrives the offset and encoded length from a compact-prefixed value
+* @example
+* <BR>
+*
+* ```javascript
+* import { compactFromU8a } from '@polkadot/util';
+*
+* const [offset, length] = compactFromU8a(new Uint8Array([254, 255, 3, 0]));
+*
+* console.log('value offset=', offset, 'length=', length); // 4, 0xffff
+* ```
+*/
+function compactFromU8a(input) {
+	const u8a = require_toU8a.u8aToU8a(input);
+	switch (u8a[0] & 3) {
+		case 0: return [1, new require_bn.import_bn.default(u8a[0] >>> 2)];
+		case 1: return [2, new require_bn.import_bn.default(u8a[0] + (u8a[1] << 8) >>> 2)];
+		case 2: return [4, new require_bn.import_bn.default(u8a[0] + (u8a[1] << 8) + (u8a[2] << 16) + u8a[3] * 16777216 >>> 2)];
+		default: {
+			const offset = (u8a[0] >>> 2) + 5;
+			switch (offset) {
+				case 5: return [5, new require_bn.import_bn.default(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + u8a[4] * 16777216)];
+				case 6: return [6, new require_bn.import_bn.default(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + (u8a[4] + (u8a[5] << 8)) * 16777216)];
+				case 7: return [7, new require_bn.import_bn.default(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + (u8a[4] + (u8a[5] << 8) + (u8a[6] << 16)) * 16777216)];
+				default: return [offset, require_toBn.u8aToBn(u8a.subarray(1, offset))];
+			}
+		}
+	}
+}
+/**
+* @name compactFromU8aLim
+* @description A limited version of [[compactFromU8a]], accepting only Uint8Array inputs for values <= 48 bits
+*/
+function compactFromU8aLim(u8a) {
+	switch (u8a[0] & 3) {
+		case 0: return [1, u8a[0] >>> 2];
+		case 1: return [2, u8a[0] + (u8a[1] << 8) >>> 2];
+		case 2: return [4, u8a[0] + (u8a[1] << 8) + (u8a[2] << 16) + u8a[3] * 16777216 >>> 2];
+		default: switch ((u8a[0] >>> 2) + 5) {
+			case 5: return [5, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + u8a[4] * 16777216];
+			case 6: return [6, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + (u8a[4] + (u8a[5] << 8)) * 16777216];
+			case 7: return [7, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + (u8a[4] + (u8a[5] << 8) + (u8a[6] << 16)) * 16777216];
+			default: throw new Error("Compact input is > Number.MAX_SAFE_INTEGER");
+		}
+	}
+}
+
+//#endregion
+exports.compactFromU8a = compactFromU8a;
+exports.compactFromU8aLim = compactFromU8aLim;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/compact/stripLength.cjs

@@ -0,0 +1,23 @@
+const require_fromU8a = require('./fromU8a.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/compact/stripLength.js
+/**
+* @name compactStripLength
+* @description Removes the length prefix, returning both the total length (including the value + compact encoding) and the decoded value with the correct length
+* @example
+* <BR>
+*
+* ```javascript
+* import { compactStripLength } from '@polkadot/util';
+*
+* console.log(compactStripLength(new Uint8Array([2 << 2, 0xde, 0xad]))); // [2, Uint8Array[0xde, 0xad]]
+* ```
+*/
+function compactStripLength(input) {
+	const [offset, length] = require_fromU8a.compactFromU8a(input);
+	const total = offset + length.toNumber();
+	return [total, input.subarray(offset, total)];
+}
+
+//#endregion
+exports.compactStripLength = compactStripLength;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/compact/toU8a.cjs

@@ -0,0 +1,38 @@
+const require_bn = require('../bn/bn.cjs');
+const require_concat = require('../u8a/concat.cjs');
+const require_consts = require('../bn/consts.cjs');
+const require_toBn = require('../bn/toBn.cjs');
+const require_toU8a = require('../bn/toU8a.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/compact/toU8a.js
+const MAX_U8 = require_consts.BN_TWO.pow(new require_bn.import_bn.default(6)).isub(require_consts.BN_ONE);
+const MAX_U16 = require_consts.BN_TWO.pow(new require_bn.import_bn.default(14)).isub(require_consts.BN_ONE);
+const MAX_U32 = require_consts.BN_TWO.pow(new require_bn.import_bn.default(30)).isub(require_consts.BN_ONE);
+const BL_16 = { bitLength: 16 };
+const BL_32 = { bitLength: 32 };
+/**
+* @name compactToU8a
+* @description Encodes a number into a compact representation
+* @example
+* <BR>
+*
+* ```javascript
+* import { compactToU8a } from '@polkadot/util';
+*
+* console.log(compactToU8a(511, 32)); // Uint8Array([0b11111101, 0b00000111])
+* ```
+*/
+function compactToU8a(value) {
+	const bn = require_toBn.bnToBn(value);
+	if (bn.lte(MAX_U8)) return new Uint8Array([bn.toNumber() << 2]);
+	else if (bn.lte(MAX_U16)) return require_toU8a.bnToU8a(bn.shln(2).iadd(require_consts.BN_ONE), BL_16);
+	else if (bn.lte(MAX_U32)) return require_toU8a.bnToU8a(bn.shln(2).iadd(require_consts.BN_TWO), BL_32);
+	const u8a = require_toU8a.bnToU8a(bn);
+	let length = u8a.length;
+	while (u8a[length - 1] === 0) length--;
+	if (length < 4) throw new Error("Invalid length, previous checks match anything less than 2^30");
+	return require_concat.u8aConcatStrict([new Uint8Array([(length - 4 << 2) + 3]), u8a.subarray(0, length)]);
+}
+
+//#endregion
+exports.compactToU8a = compactToU8a;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/float/toU8a.cjs

@@ -0,0 +1,18 @@
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/float/toU8a.js
+/**
+* @name floatToU8a
+* @description Converts a float into a U8a representation (While we don't use BE in SCALE
+* we still allow for either representation, although, as elsewhere, isLe is default)
+*/
+function floatToU8a(value = 0, { bitLength = 32, isLe = true } = {}) {
+	if (bitLength !== 32 && bitLength !== 64) throw new Error("Invalid bitLength provided, expected 32 or 64");
+	const result = new Uint8Array(bitLength / 8);
+	const dv = new DataView(result.buffer, result.byteOffset);
+	if (bitLength === 32) dv.setFloat32(0, Number(value), isLe);
+	else dv.setFloat64(0, Number(value), isLe);
+	return result;
+}
+
+//#endregion
+exports.floatToU8a = floatToU8a;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/format/formatBalance.cjs

@@ -0,0 +1,55 @@
+const require_toBn = require('../bn/toBn.cjs');
+const require_boolean = require('../is/boolean.cjs');
+const require_formatDecimal = require('./formatDecimal.cjs');
+const require_getSeparator = require('./getSeparator.cjs');
+const require_si = require('./si.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/format/formatBalance.js
+const DEFAULT_DECIMALS = 0;
+const DEFAULT_UNIT = require_si.SI[require_si.SI_MID].text;
+let defaultDecimals = DEFAULT_DECIMALS;
+let defaultUnit = DEFAULT_UNIT;
+function _formatBalance(input, { decimals = defaultDecimals, forceUnit, locale = "en", withAll = false, withSi = true, withSiFull = false, withUnit = true, withZero = true } = {}) {
+	let text = require_toBn.bnToBn(input).toString();
+	if (text.length === 0 || text === "0") return "0";
+	let sign = "";
+	if (text[0].startsWith("-")) {
+		sign = "-";
+		text = text.substring(1);
+	}
+	const si = require_si.calcSi(text, decimals, forceUnit);
+	const mid = text.length - (decimals + si.power);
+	const pre = mid <= 0 ? "0" : text.substring(0, mid);
+	let post = text.padStart(mid < 0 ? decimals : 1, "0").substring(mid < 0 ? 0 : mid).padEnd(withAll ? Math.max(decimals, 4) : 4, "0").substring(0, withAll ? Math.max(4, decimals + si.power) : 4);
+	if (!withZero) {
+		let end = post.length - 1;
+		do
+			if (post[end] === "0") end--;
+		while (post[end] === "0");
+		post = post.substring(0, end + 1);
+	}
+	const unit = require_boolean.isBoolean(withUnit) ? require_si.SI[require_si.SI_MID].text : withUnit;
+	const units = withSi || withSiFull ? si.value === "-" ? withUnit ? ` ${unit}` : "" : ` ${withSiFull ? `${si.text}${withUnit ? " " : ""}` : si.value}${withUnit ? unit : ""}` : "";
+	const { decimal, thousand } = require_getSeparator.getSeparator(locale);
+	return `${sign}${require_formatDecimal.formatDecimal(pre, thousand)}${post && `${decimal}${post}`}${units}`;
+}
+const formatBalance = _formatBalance;
+formatBalance.calcSi = (text, decimals = defaultDecimals) => require_si.calcSi(text, decimals);
+formatBalance.findSi = require_si.findSi;
+formatBalance.getDefaults = () => {
+	return {
+		decimals: defaultDecimals,
+		unit: defaultUnit
+	};
+};
+formatBalance.getOptions = (decimals = defaultDecimals) => {
+	return require_si.SI.filter(({ power }) => power < 0 ? decimals + power >= 0 : true);
+};
+formatBalance.setDefaults = ({ decimals, unit }) => {
+	defaultDecimals = (Array.isArray(decimals) ? decimals[0] : decimals) ?? defaultDecimals;
+	defaultUnit = (Array.isArray(unit) ? unit[0] : unit) ?? defaultUnit;
+	require_si.SI[require_si.SI_MID].text = defaultUnit;
+};
+
+//#endregion
+exports.formatBalance = formatBalance;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/format/formatDate.cjs

@@ -0,0 +1,16 @@
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/format/formatDate.js
+/** @internal */
+function zeroPad(value) {
+	return value.toString().padStart(2, "0");
+}
+/**
+* @name formatDate
+* @description Formats a date in CCYY-MM-DD HH:MM:SS format
+*/
+function formatDate(date) {
+	return `${date.getFullYear().toString()}-${zeroPad(date.getMonth() + 1)}-${zeroPad(date.getDate())} ${zeroPad(date.getHours())}:${zeroPad(date.getMinutes())}:${zeroPad(date.getSeconds())}`;
+}
+
+//#endregion
+exports.formatDate = formatDate;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/format/formatDecimal.cjs

@@ -0,0 +1,15 @@
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/format/formatDecimal.js
+const NUMBER_REGEX = /* @__PURE__ */ new RegExp("(\\d+?)(?=(\\d{3})+(?!\\d)|$)", "g");
+/**
+* @name formatDecimal
+* @description Formats a number into string format with thousand separators
+*/
+function formatDecimal(value, separator = ",") {
+	const isNegative = value[0].startsWith("-");
+	const matched = isNegative ? value.substring(1).match(NUMBER_REGEX) : value.match(NUMBER_REGEX);
+	return matched ? `${isNegative ? "-" : ""}${matched.join(separator)}` : value;
+}
+
+//#endregion
+exports.formatDecimal = formatDecimal;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/format/formatNumber.cjs

@@ -0,0 +1,16 @@
+const require_toBn = require('../bn/toBn.cjs');
+const require_formatDecimal = require('./formatDecimal.cjs');
+const require_getSeparator = require('./getSeparator.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/format/formatNumber.js
+/**
+* @name formatNumber
+* @description Formats a number into string format with thousand separators
+*/
+function formatNumber(value, { locale = "en" } = {}) {
+	const { thousand } = require_getSeparator.getSeparator(locale);
+	return require_formatDecimal.formatDecimal(require_toBn.bnToBn(value).toString(), thousand);
+}
+
+//#endregion
+exports.formatNumber = formatNumber;

package/dist/node_modules/.pnpm/@polkadot_util@14.0.1/node_modules/@polkadot/util/format/getSeparator.cjs

@@ -0,0 +1,16 @@
+
+//#region ../../node_modules/.pnpm/@polkadot+util@14.0.1/node_modules/@polkadot/util/format/getSeparator.js
+/**
+* Get the decimal and thousand separator of a locale
+* @param locale
+* @returns {decimal: string, thousand: string}
+*/
+function getSeparator(locale) {
+	return {
+		decimal: .1.toLocaleString(locale, { useGrouping: false }).charAt(1),
+		thousand: 1e3.toLocaleString(locale, { useGrouping: true }).replace(/\d/g, "").charAt(0)
+	};
+}
+
+//#endregion
+exports.getSeparator = getSeparator;