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

package/dist/node_modules/.pnpm/@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

@@ -0,0 +1,49 @@
+const require_init = require('./init.cjs');
+
+//#region ../../node_modules/.pnpm/@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.js
+/**
+* @internal
+* @description
+* This create an extenal interface function from the signature, all the while checking
+* the actual bridge wasm interface to ensure it has been initialized.
+*
+* This means that we can call it
+*
+*   withWasm(wasm: WasmCryptoInstance, a: number, b: string) => Uint8Array
+*
+* and in this case it will create an interface function with the signarure
+*
+*   (a: number, b: string) => Uint8Array
+*/
+function withWasm(fn) {
+	return (...params) => {
+		if (!require_init.bridge.wasm) throw new Error("The WASM interface has not been initialized. Ensure that you wait for the initialization Promise with waitReady() from @polkadot/wasm-crypto (or cryptoWaitReady() from @polkadot/util-crypto) before attempting to use WASM-only interfaces.");
+		return fn(require_init.bridge.wasm, ...params);
+	};
+}
+const secp256k1Expand = /* @__PURE__ */ withWasm((wasm, pubkey) => {
+	wasm.ext_secp_pub_expand(8, ...require_init.bridge.allocU8a(pubkey));
+	return require_init.bridge.resultU8a();
+});
+const blake2b = /* @__PURE__ */ withWasm((wasm, data, key, size) => {
+	wasm.ext_blake2b(8, ...require_init.bridge.allocU8a(data), ...require_init.bridge.allocU8a(key), size);
+	return require_init.bridge.resultU8a();
+});
+const keccak256 = /* @__PURE__ */ withWasm((wasm, data) => {
+	wasm.ext_keccak256(8, ...require_init.bridge.allocU8a(data));
+	return require_init.bridge.resultU8a();
+});
+const keccak512 = /* @__PURE__ */ withWasm((wasm, data) => {
+	wasm.ext_keccak512(8, ...require_init.bridge.allocU8a(data));
+	return require_init.bridge.resultU8a();
+});
+function isReady() {
+	return !!require_init.bridge.wasm;
+}
+
+//#endregion
+exports.blake2b = blake2b;
+exports.isReady = isReady;
+exports.keccak256 = keccak256;
+exports.keccak512 = keccak512;
+exports.secp256k1Expand = secp256k1Expand;

package/dist/node_modules/.pnpm/@polkadot_wasm-crypto@7.5.4_@polkadot_util@14.0.1_@polkadot_x-randomvalues@14.0.1_@polk_66de4b6310fb21b1adaa456362dbc346/node_modules/@polkadot/wasm-crypto/init.cjs

@@ -0,0 +1,14 @@
+const require_bridge = require('../../../../@polkadot_wasm-bridge@7.5.4_@polkadot_util@14.0.1_@polkadot_x-randomvalues@14.0.1_@polk_9fba5ec88721cce0cc66dfcd9960a838/node_modules/@polkadot/wasm-bridge/bridge.cjs');
+const require_wasm = require('../../../../@polkadot_wasm-crypto-init@7.5.4_@polkadot_util@14.0.1_@polkadot_x-randomvalues@14.0.1__02e742fd5476f0471e29709e28965abf/node_modules/@polkadot/wasm-crypto-init/wasm.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+wasm-crypto@7.5.4_@polkadot+util@14.0.1_@polkadot+x-randomvalues@14.0.1_@polk_66de4b6310fb21b1adaa456362dbc346/node_modules/@polkadot/wasm-crypto/init.js
+/**
+* @name bridge
+* @description
+* The JS <-> WASM bridge that is in operation. For the specific package
+* it is a global, i.e. all operations happens on this specific bridge
+*/
+const bridge = new require_bridge.Bridge(require_wasm.createWasm);
+
+//#endregion
+exports.bridge = bridge;

package/dist/node_modules/.pnpm/@polkadot_wasm-util@7.5.4_@polkadot_util@14.0.1/node_modules/@polkadot/wasm-util/base64.cjs

@@ -0,0 +1,29 @@
+
+//#region ../../node_modules/.pnpm/@polkadot+wasm-util@7.5.4_@polkadot+util@14.0.1/node_modules/@polkadot/wasm-util/base64.js
+const CHR = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const map = new Array(256);
+for (let i = 0, count = 64; i < count; i++) map[CHR.charCodeAt(i)] = i;
+/**
+* @name base64Decode
+* @description
+* A base64 decoding function that operates in all environments. Unlike decoding
+* from Buffer (Node.js only) or atob (browser-only) this implementation is
+* slightly slower, but it is platform independent.
+*
+* For our usage, since we have access to the static final size, so we decode
+* to a specified output buffer. This also means we have applied a number of
+* optimizations based on this - checking output position instead of chars.
+*/
+function base64Decode(data, out) {
+	let byte = 0;
+	let bits = 0;
+	let pos = -1;
+	for (let i = 0, last = out.length - 1; pos !== last; i++) {
+		byte = byte << 6 | map[data.charCodeAt(i)];
+		if ((bits += 6) >= 8) out[++pos] = byte >>> (bits -= 8) & 255;
+	}
+	return out;
+}
+
+//#endregion
+exports.base64Decode = base64Decode;

package/dist/node_modules/.pnpm/@polkadot_wasm-util@7.5.4_@polkadot_util@14.0.1/node_modules/@polkadot/wasm-util/fflate.cjs

@@ -0,0 +1,287 @@
+
+//#region ../../node_modules/.pnpm/@polkadot+wasm-util@7.5.4_@polkadot+util@14.0.1/node_modules/@polkadot/wasm-util/fflate.js
+const u8 = Uint8Array, u16 = Uint16Array, u32 = Uint32Array;
+const clim = new u8([
+	16,
+	17,
+	18,
+	0,
+	8,
+	7,
+	9,
+	6,
+	10,
+	5,
+	11,
+	4,
+	12,
+	3,
+	13,
+	2,
+	14,
+	1,
+	15
+]);
+const fleb = new u8([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	2,
+	2,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	0,
+	0,
+	0,
+	0
+]);
+const fdeb = new u8([
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	2,
+	2,
+	3,
+	3,
+	4,
+	4,
+	5,
+	5,
+	6,
+	6,
+	7,
+	7,
+	8,
+	8,
+	9,
+	9,
+	10,
+	10,
+	11,
+	11,
+	12,
+	12,
+	13,
+	13,
+	0,
+	0
+]);
+const freb = (eb, start) => {
+	const b = new u16(31);
+	for (let i = 0; i < 31; ++i) b[i] = start += 1 << eb[i - 1];
+	const r = new u32(b[30]);
+	for (let i = 1; i < 30; ++i) for (let j = b[i]; j < b[i + 1]; ++j) r[j] = j - b[i] << 5 | i;
+	return [b, r];
+};
+const [fl, revfl] = freb(fleb, 2);
+fl[28] = 258, revfl[258] = 28;
+const [fd] = freb(fdeb, 0);
+const rev = new u16(32768);
+for (let i = 0; i < 32768; ++i) {
+	let x = (i & 43690) >>> 1 | (i & 21845) << 1;
+	x = (x & 52428) >>> 2 | (x & 13107) << 2;
+	x = (x & 61680) >>> 4 | (x & 3855) << 4;
+	rev[i] = ((x & 65280) >>> 8 | (x & 255) << 8) >>> 1;
+}
+const hMap = ((cd, mb, r) => {
+	const s = cd.length;
+	let i = 0;
+	const l = new u16(mb);
+	for (; i < s; ++i) if (cd[i]) ++l[cd[i] - 1];
+	const le = new u16(mb);
+	for (i = 1; i < mb; ++i) le[i] = le[i - 1] + l[i - 1] << 1;
+	let co;
+	if (r) {
+		co = new u16(1 << mb);
+		const rvb = 15 - mb;
+		for (i = 0; i < s; ++i) if (cd[i]) {
+			const sv = i << 4 | cd[i];
+			const r = mb - cd[i];
+			let v = le[cd[i] - 1]++ << r;
+			for (const m = v | (1 << r) - 1; v <= m; ++v) co[rev[v] >> rvb] = sv;
+		}
+	} else {
+		co = new u16(s);
+		for (i = 0; i < s; ++i) if (cd[i]) co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+	}
+	return co;
+});
+const flt = new u8(288);
+for (let i = 0; i < 144; ++i) flt[i] = 8;
+for (let i = 144; i < 256; ++i) flt[i] = 9;
+for (let i = 256; i < 280; ++i) flt[i] = 7;
+for (let i = 280; i < 288; ++i) flt[i] = 8;
+const fdt = new u8(32);
+for (let i = 0; i < 32; ++i) fdt[i] = 5;
+const flrm = hMap(flt, 9, 1);
+const fdrm = hMap(fdt, 5, 1);
+const bits = (d, p, m) => {
+	const o = p >>> 3;
+	return (d[o] | d[o + 1] << 8) >>> (p & 7) & m;
+};
+const bits16 = (d, p) => {
+	const o = p >>> 3;
+	return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >>> (p & 7);
+};
+const shft = (p) => (p >>> 3) + (p & 7 && 1);
+const slc = (v, s, e) => {
+	if (s == null || s < 0) s = 0;
+	if (e == null || e > v.length) e = v.length;
+	const n = new (v instanceof u16 ? u16 : v instanceof u32 ? u32 : u8)(e - s);
+	n.set(v.subarray(s, e));
+	return n;
+};
+const max = (a) => {
+	let m = a[0];
+	for (let i = 1, count = a.length; i < count; ++i) if (a[i] > m) m = a[i];
+	return m;
+};
+const inflt = (dat, buf, st) => {
+	const noSt = !st || st.i;
+	if (!st) st = {};
+	const sl = dat.length;
+	const noBuf = !buf || !noSt;
+	if (!buf) buf = new u8(sl * 3);
+	const cbuf = (l) => {
+		let bl = buf.length;
+		if (l > bl) {
+			const nbuf = new u8(Math.max(bl << 1, l));
+			nbuf.set(buf);
+			buf = nbuf;
+		}
+	};
+	let final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+	if (final && !lm) return buf;
+	const tbts = sl << 3;
+	do {
+		if (!lm) {
+			st.f = final = bits(dat, pos, 1);
+			const type = bits(dat, pos + 1, 3);
+			pos += 3;
+			if (!type) {
+				const s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+				if (t > sl) {
+					if (noSt) throw "unexpected EOF";
+					break;
+				}
+				if (noBuf) cbuf(bt + l);
+				buf.set(dat.subarray(s, t), bt);
+				st.b = bt += l, st.p = pos = t << 3;
+				continue;
+			} else if (type == 1) lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+			else if (type == 2) {
+				const hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+				const tl = hLit + bits(dat, pos + 5, 31) + 1;
+				pos += 14;
+				const ldt = new u8(tl);
+				const clt = new u8(19);
+				for (let i = 0; i < hcLen; ++i) clt[clim[i]] = bits(dat, pos + i * 3, 7);
+				pos += hcLen * 3;
+				const clb = max(clt), clbmsk = (1 << clb) - 1;
+				if (!noSt && pos + tl * (clb + 7) > tbts) break;
+				const clm = hMap(clt, clb, 1);
+				for (let i = 0; i < tl;) {
+					const r = clm[bits(dat, pos, clbmsk)];
+					pos += r & 15;
+					const s = r >>> 4;
+					if (s < 16) ldt[i++] = s;
+					else {
+						let c = 0, n = 0;
+						if (s == 16) n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+						else if (s == 17) n = 3 + bits(dat, pos, 7), pos += 3;
+						else if (s == 18) n = 11 + bits(dat, pos, 127), pos += 7;
+						while (n--) ldt[i++] = c;
+					}
+				}
+				const lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+				lbt = max(lt);
+				dbt = max(dt);
+				lm = hMap(lt, lbt, 1);
+				dm = hMap(dt, dbt, 1);
+			} else throw "invalid block type";
+			if (pos > tbts) throw "unexpected EOF";
+		}
+		if (noBuf) cbuf(bt + 131072);
+		const lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+		const mxa = lbt + dbt + 18;
+		while (noSt || pos + mxa < tbts) {
+			const c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
+			pos += c & 15;
+			if (pos > tbts) throw "unexpected EOF";
+			if (!c) throw "invalid length/literal";
+			if (sym < 256) buf[bt++] = sym;
+			else if (sym == 256) {
+				lm = void 0;
+				break;
+			} else {
+				let add = sym - 254;
+				if (sym > 264) {
+					const i = sym - 257, b = fleb[i];
+					add = bits(dat, pos, (1 << b) - 1) + fl[i];
+					pos += b;
+				}
+				const d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
+				if (!d) throw "invalid distance";
+				pos += d & 15;
+				let dt = fd[dsym];
+				if (dsym > 3) {
+					const b = fdeb[dsym];
+					dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+				}
+				if (pos > tbts) throw "unexpected EOF";
+				if (noBuf) cbuf(bt + 131072);
+				const end = bt + add;
+				for (; bt < end; bt += 4) {
+					buf[bt] = buf[bt - dt];
+					buf[bt + 1] = buf[bt + 1 - dt];
+					buf[bt + 2] = buf[bt + 2 - dt];
+					buf[bt + 3] = buf[bt + 3 - dt];
+				}
+				bt = end;
+			}
+		}
+		st.l = lm, st.p = pos, st.b = bt;
+		if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+	} while (!final);
+	return bt == buf.length ? buf : slc(buf, 0, bt);
+};
+const zlv = (d) => {
+	if ((d[0] & 15) != 8 || d[0] >>> 4 > 7 || (d[0] << 8 | d[1]) % 31) throw "invalid zlib data";
+	if (d[1] & 32) throw "invalid zlib data: preset dictionaries not supported";
+};
+/**
+* Expands Zlib data
+* @param data The data to decompress
+* @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.
+* @returns The decompressed version of the data
+*/
+function unzlibSync(data, out) {
+	return inflt((zlv(data), data.subarray(2, -4)), out);
+}
+
+//#endregion
+exports.unzlibSync = unzlibSync;

package/dist/node_modules/.pnpm/@polkadot_x-bigint@14.0.1/node_modules/@polkadot/x-bigint/index.cjs

@@ -0,0 +1,20 @@
+const require_index = require('../../../../@polkadot_x-global@14.0.1/node_modules/@polkadot/x-global/index.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+x-bigint@14.0.1/node_modules/@polkadot/x-bigint/index.js
+/**
+* @internal
+*
+* There are _still_ some older environments (specifically RN < 0.70), that does
+* not have proper BigInt support - a non-working fallback is provided for those.
+*
+* We detect availability of BigInt upon usage, so this is purely to allow functional
+* compilation & bundling. Since we have operators such as *+-/ top-level, a number-ish
+* result is used here.
+*/
+function invalidFallback() {
+	return NaN;
+}
+const BigInt = /* @__PURE__ */ require_index.extractGlobal("BigInt", invalidFallback);
+
+//#endregion
+exports.BigInt = BigInt;

package/dist/node_modules/.pnpm/@polkadot_x-global@14.0.1/node_modules/@polkadot/x-global/index.cjs

@@ -0,0 +1,20 @@
+
+//#region ../../node_modules/.pnpm/@polkadot+x-global@14.0.1/node_modules/@polkadot/x-global/index.js
+/** @internal Last-resort "this", if it gets here it probably would fail anyway */
+function evaluateThis(fn) {
+	return fn("return this");
+}
+/**
+* A cross-environment implementation for globalThis
+*/
+const xglobal = typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : evaluateThis(Function);
+/**
+* Extracts a known global from the environment, applying a fallback if not found
+*/
+function extractGlobal(name, fallback) {
+	return typeof xglobal[name] === "undefined" ? fallback : xglobal[name];
+}
+
+//#endregion
+exports.extractGlobal = extractGlobal;
+exports.xglobal = xglobal;

package/dist/node_modules/.pnpm/@polkadot_x-randomvalues@14.0.1_@polkadot_util@14.0.1_@polkadot_wasm-util@7.5.4_@polkadot_util@14.0.1_/node_modules/@polkadot/x-randomvalues/node.cjs

@@ -0,0 +1,13 @@
+const require_rolldown_runtime = require('../../../../../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../../../@polkadot_x-global@14.0.1/node_modules/@polkadot/x-global/index.cjs');
+let node_crypto = require("node:crypto");
+node_crypto = require_rolldown_runtime.__toESM(node_crypto);
+
+//#region ../../node_modules/.pnpm/@polkadot+x-randomvalues@14.0.1_@polkadot+util@14.0.1_@polkadot+wasm-util@7.5.4_@polkadot+util@14.0.1_/node_modules/@polkadot/x-randomvalues/node.js
+const crypto = /* @__PURE__ */ require_index.extractGlobal("crypto", node_crypto.default.webcrypto);
+function getRandomValues(output) {
+	return crypto.getRandomValues(output);
+}
+
+//#endregion
+exports.getRandomValues = getRandomValues;

package/dist/node_modules/.pnpm/@polkadot_x-textdecoder@14.0.1/node_modules/@polkadot/x-textdecoder/node.cjs

@@ -0,0 +1,10 @@
+const require_rolldown_runtime = require('../../../../../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../../../@polkadot_x-global@14.0.1/node_modules/@polkadot/x-global/index.cjs');
+let node_util = require("node:util");
+node_util = require_rolldown_runtime.__toESM(node_util);
+
+//#region ../../node_modules/.pnpm/@polkadot+x-textdecoder@14.0.1/node_modules/@polkadot/x-textdecoder/node.js
+const TextDecoder = /* @__PURE__ */ require_index.extractGlobal("TextDecoder", node_util.default.TextDecoder);
+
+//#endregion
+exports.TextDecoder = TextDecoder;

package/dist/node_modules/.pnpm/@polkadot_x-textencoder@14.0.1/node_modules/@polkadot/x-textencoder/node.cjs

@@ -0,0 +1,19 @@
+const require_rolldown_runtime = require('../../../../../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../../../@polkadot_x-global@14.0.1/node_modules/@polkadot/x-global/index.cjs');
+let node_util = require("node:util");
+node_util = require_rolldown_runtime.__toESM(node_util);
+
+//#region ../../node_modules/.pnpm/@polkadot+x-textencoder@14.0.1/node_modules/@polkadot/x-textencoder/node.js
+var Fallback = class {
+	#encoder;
+	constructor() {
+		this.#encoder = new node_util.default.TextEncoder();
+	}
+	encode(value) {
+		return Uint8Array.from(this.#encoder.encode(value));
+	}
+};
+const TextEncoder = /* @__PURE__ */ require_index.extractGlobal("TextEncoder", Fallback);
+
+//#endregion
+exports.TextEncoder = TextEncoder;