@aboutcircles/sdk 0.1.32 → 0.1.34

package/dist/index.js

@@ -1063,10 +1063,10 @@ function o0(J, $) {
 }
 function p$(J) {
   let { event: $, values: Q } = J, Y = { $event: $, blockNumber: Q.blockNumber ? Q$(Q.blockNumber) : 0, timestamp: Q.timestamp ? Q$(Q.timestamp) : undefined, transactionIndex: Q.transactionIndex ? Q$(Q.transactionIndex) : 0, logIndex: Q.logIndex ? Q$(Q.logIndex) : 0, transactionHash: Q.transactionHash };
-  for (let [M3, G] of Object.entries(Q)) {
-    if (["blockNumber", "timestamp", "transactionIndex", "logIndex", "transactionHash"].includes(M3))
+  for (let [G, M3] of Object.entries(Q)) {
+    if (["blockNumber", "timestamp", "transactionIndex", "logIndex", "transactionHash"].includes(G))
       continue;
-    Y[M3] = o0(M3, G);
+    Y[G] = o0(G, M3);
   }
   return Y;
 }
@@ -1162,12 +1162,12 @@ class VJ {
       let Y = await fetch(this.rpcUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(Q) });
       if (!Y.ok)
         throw c3.connectionFailed(this.rpcUrl, Error(`HTTP ${Y.status}: ${Y.statusText}`));
-      let M3 = await Y.json();
-      if (M3.error)
-        throw c3.fromJsonRpcError(M3.error);
-      if (M3.result === undefined)
-        throw c3.invalidResponse(J, M3);
-      return M3.result;
+      let G = await Y.json();
+      if (G.error)
+        throw c3.fromJsonRpcError(G.error);
+      if (G.result === undefined)
+        throw c3.invalidResponse(J, G);
+      return G.result;
     } catch (Y) {
       if (Y instanceof c3)
         throw Y;
@@ -1190,9 +1190,9 @@ class VJ {
       this.websocket = new WebSocket(Q), this.websocket.onopen = () => {
         console.log("WebSocket connected"), this.websocketConnected = true, this.reconnectAttempt = 0, J();
       }, this.websocket.onmessage = (Y) => {
-        let M3 = JSON.parse(Y.data), { id: G, method: Z, params: K } = M3;
-        if (G !== undefined && this.pendingResponses[G])
-          this.pendingResponses[G].resolve(M3), delete this.pendingResponses[G];
+        let G = JSON.parse(Y.data), { id: M3, method: Z, params: K } = G;
+        if (M3 !== undefined && this.pendingResponses[M3])
+          this.pendingResponses[M3].resolve(G), delete this.pendingResponses[M3];
         if (Z === "circles_subscription" && K?.result)
           Object.values(this.subscriptionListeners).forEach((X) => {
             X.forEach((q) => q(K.result));
@@ -1229,10 +1229,10 @@ class VJ {
     this.activeSubscriptions = [];
     for (let $ of J)
       try {
-        let Q = $.address ? { address: $.address } : {}, M3 = (await this.sendMessage("circles_subscribe", Q)).result, G = this.subscriptionListeners[$.id];
-        if (G)
-          this.subscriptionListeners[M3] = G, delete this.subscriptionListeners[$.id];
-        this.activeSubscriptions.push({ id: M3, address: $.address });
+        let Q = $.address ? { address: $.address } : {}, G = (await this.sendMessage("circles_subscribe", Q)).result, M3 = this.subscriptionListeners[$.id];
+        if (M3)
+          this.subscriptionListeners[G] = M3, delete this.subscriptionListeners[$.id];
+        this.activeSubscriptions.push({ id: G, address: $.address });
       } catch (Q) {
         console.error("Failed to re-issue circles_subscribe after reconnect:", Q), this.activeSubscriptions.push($);
       }
@@ -1240,9 +1240,9 @@ class VJ {
   sendMessage(J, $, Q = 5000) {
     if (!this.websocket || this.websocket.readyState !== WebSocket.OPEN)
       return Promise.reject(c3.connectionFailed(this.rpcUrl));
-    let Y = this.requestId++, M3 = { jsonrpc: "2.0", method: J, params: $, id: Y };
-    return new Promise((G, Z) => {
-      this.pendingResponses[Y] = { resolve: G, reject: Z }, this.websocket.send(JSON.stringify(M3)), setTimeout(() => {
+    let Y = this.requestId++, G = { jsonrpc: "2.0", method: J, params: $, id: Y };
+    return new Promise((M3, Z) => {
+      this.pendingResponses[Y] = { resolve: M3, reject: Z }, this.websocket.send(JSON.stringify(G)), setTimeout(() => {
         if (this.pendingResponses[Y])
           this.pendingResponses[Y].reject(c3.timeout(J, Q)), delete this.pendingResponses[Y];
       }, Q);
@@ -1252,12 +1252,12 @@ class VJ {
     let $ = J?.toLowerCase();
     if (!this.websocketConnected)
       await this.connect();
-    let Q = lJ.create(), Y = $ ? { address: $ } : {}, G = (await this.sendMessage("circles_subscribe", Y)).result;
-    if (!this.subscriptionListeners[G])
-      this.subscriptionListeners[G] = [];
-    return this.subscriptionListeners[G].push((Z) => {
+    let Q = lJ.create(), Y = $ ? { address: $ } : {}, M3 = (await this.sendMessage("circles_subscribe", Y)).result;
+    if (!this.subscriptionListeners[M3])
+      this.subscriptionListeners[M3] = [];
+    return this.subscriptionListeners[M3].push((Z) => {
       I$(Z).forEach((K) => Q.emit(K));
-    }), this.activeSubscriptions.push({ id: G, address: $ }), Q.property;
+    }), this.activeSubscriptions.push({ id: M3, address: $ }), Q.property;
   }
 }
 var H$ = BigInt(4294967295);
@@ -1268,12 +1268,12 @@ function s0(J, $ = false) {
   return { h: Number(J >> g8 & H$) | 0, l: Number(J & H$) | 0 };
 }
 function v8(J, $ = false) {
-  let Q = J.length, Y = new Uint32Array(Q), M3 = new Uint32Array(Q);
-  for (let G = 0;G < Q; G++) {
-    let { h: Z, l: K } = s0(J[G], $);
-    [Y[G], M3[G]] = [Z, K];
+  let Q = J.length, Y = new Uint32Array(Q), G = new Uint32Array(Q);
+  for (let M3 = 0;M3 < Q; M3++) {
+    let { h: Z, l: K } = s0(J[M3], $);
+    [Y[M3], G[M3]] = [Z, K];
   }
-  return [Y, M3];
+  return [Y, G];
 }
 var u8 = (J, $, Q) => J << Q | $ >>> 32 - Q;
 var m8 = (J, $, Q) => $ << Q | J >>> 32 - Q;
@@ -1290,9 +1290,9 @@ function d$(J, $ = "") {
   }
 }
 function S$(J, $, Q = "") {
-  let Y = r0(J), M3 = J?.length, G = $ !== undefined;
-  if (!Y || G && M3 !== $) {
-    let Z = Q && `"${Q}" `, K = G ? ` of length ${$}` : "", X = Y ? `length=${M3}` : `type=${typeof J}`;
+  let Y = r0(J), G = J?.length, M3 = $ !== undefined;
+  if (!Y || M3 && G !== $) {
+    let Z = Q && `"${Q}" `, K = M3 ? ` of length ${$}` : "", X = Y ? `length=${G}` : `type=${typeof J}`;
     throw Error(Z + "expected Uint8Array" + K + ", got " + X);
   }
   return J;
@@ -1327,25 +1327,25 @@ function $Q(J) {
 }
 var t$ = e0 ? (J) => J : $Q;
 function d8(J, $ = {}) {
-  let Q = (M3, G) => J(G).update(M3).digest(), Y = J(undefined);
-  return Q.outputLen = Y.outputLen, Q.blockLen = Y.blockLen, Q.create = (M3) => J(M3), Object.assign(Q, $), Object.freeze(Q);
+  let Q = (G, M3) => J(M3).update(G).digest(), Y = J(undefined);
+  return Q.outputLen = Y.outputLen, Q.blockLen = Y.blockLen, Q.create = (G) => J(G), Object.assign(Q, $), Object.freeze(Q);
 }
 var QQ = BigInt(0);
-var M$ = BigInt(1);
+var G$ = BigInt(1);
 var YQ = BigInt(2);
-var MQ = BigInt(7);
-var GQ = BigInt(256);
+var GQ = BigInt(7);
+var MQ = BigInt(256);
 var ZQ = BigInt(113);
 var t8 = [];
 var o8 = [];
 var a8 = [];
-for (let J = 0, $ = M$, Q = 1, Y = 0;J < 24; J++) {
+for (let J = 0, $ = G$, Q = 1, Y = 0;J < 24; J++) {
   [Q, Y] = [Y, (2 * Q + 3 * Y) % 5], t8.push(2 * (5 * Y + Q)), o8.push((J + 1) * (J + 2) / 2 % 64);
-  let M3 = QQ;
-  for (let G = 0;G < 7; G++)
-    if ($ = ($ << M$ ^ ($ >> MQ) * ZQ) % GQ, $ & YQ)
-      M3 ^= M$ << (M$ << BigInt(G)) - M$;
-  a8.push(M3);
+  let G = QQ;
+  for (let M3 = 0;M3 < 7; M3++)
+    if ($ = ($ << G$ ^ ($ >> GQ) * ZQ) % MQ, $ & YQ)
+      G ^= G$ << (G$ << BigInt(M3)) - G$;
+  a8.push(G);
 }
 var s8 = v8(a8, true);
 var XQ = s8[0];
@@ -1362,10 +1362,10 @@ function qQ(J, $ = 24) {
       for (let O3 = 0;O3 < 50; O3 += 10)
         J[Z + O3] ^= D3, J[Z + O3 + 1] ^= V;
     }
-    let M3 = J[2], G = J[3];
+    let G = J[2], M3 = J[3];
     for (let Z = 0;Z < 24; Z++) {
-      let K = o8[Z], X = n8(M3, G, K), q = i8(M3, G, K), U = t8[Z];
-      M3 = J[U], G = J[U + 1], J[U] = X, J[U + 1] = q;
+      let K = o8[Z], X = n8(G, M3, K), q = i8(G, M3, K), U = t8[Z];
+      G = J[U], M3 = J[U + 1], J[U] = X, J[U + 1] = q;
     }
     for (let Z = 0;Z < 50; Z += 10) {
       for (let K = 0;K < 10; K++)
@@ -1390,8 +1390,8 @@ class o$ {
   outputLen;
   enableXOF = false;
   rounds;
-  constructor(J, $, Q, Y = false, M3 = 24) {
-    if (this.blockLen = J, this.suffix = $, this.outputLen = Q, this.enableXOF = Y, this.rounds = M3, d$(Q, "outputLen"), !(0 < J && J < 200))
+  constructor(J, $, Q, Y = false, G = 24) {
+    if (this.blockLen = J, this.suffix = $, this.outputLen = Q, this.enableXOF = Y, this.rounds = G, d$(Q, "outputLen"), !(0 < J && J < 200))
       throw Error("only keccak-f1600 function is supported");
     this.state = new Uint8Array(200), this.state32 = p8(this.state);
   }
@@ -1404,10 +1404,10 @@ class o$ {
   update(J) {
     n$(this), S$(J);
     let { blockLen: $, state: Q } = this, Y = J.length;
-    for (let M3 = 0;M3 < Y; ) {
-      let G = Math.min($ - this.pos, Y - M3);
-      for (let Z = 0;Z < G; Z++)
-        Q[this.pos++] ^= J[M3++];
+    for (let G = 0;G < Y; ) {
+      let M3 = Math.min($ - this.pos, Y - G);
+      for (let Z = 0;Z < M3; Z++)
+        Q[this.pos++] ^= J[G++];
       if (this.pos === $)
         this.keccak();
     }
@@ -1425,11 +1425,11 @@ class o$ {
   writeInto(J) {
     n$(this, false), S$(J), this.finish();
     let $ = this.state, { blockLen: Q } = this;
-    for (let Y = 0, M3 = J.length;Y < M3; ) {
+    for (let Y = 0, G = J.length;Y < G; ) {
       if (this.posOut >= Q)
         this.keccak();
-      let G = Math.min(Q - this.posOut, M3 - Y);
-      J.set($.subarray(this.posOut, this.posOut + G), Y), this.posOut += G, Y += G;
+      let M3 = Math.min(Q - this.posOut, G - Y);
+      J.set($.subarray(this.posOut, this.posOut + M3), Y), this.posOut += M3, Y += M3;
     }
     return J;
   }
@@ -1453,8 +1453,8 @@ class o$ {
     this.destroyed = true, i$(this.state);
   }
   _cloneInto(J) {
-    let { blockLen: $, suffix: Q, outputLen: Y, rounds: M3, enableXOF: G } = this;
-    return J ||= new o$($, Q, Y, G, M3), J.state32.set(this.state32), J.pos = this.pos, J.posOut = this.posOut, J.finished = this.finished, J.rounds = M3, J.suffix = Q, J.outputLen = Y, J.enableXOF = G, J.destroyed = this.destroyed, J;
+    let { blockLen: $, suffix: Q, outputLen: Y, rounds: G, enableXOF: M3 } = this;
+    return J ||= new o$($, Q, Y, M3, G), J.state32.set(this.state32), J.pos = this.pos, J.posOut = this.posOut, J.finished = this.finished, J.rounds = G, J.suffix = Q, J.outputLen = Y, J.enableXOF = M3, J.destroyed = this.destroyed, J;
   }
 }
 var UQ = (J, $, Q, Y = {}) => d8(() => new o$($, J, Q), Y);
@@ -1477,16 +1477,16 @@ function y$(J) {
 var g3 = 64;
 var w$ = 32;
 var A$ = (J) => J.startsWith("0x") ? J.slice(2) : J;
-var GJ = (J) => J.toString(16).padStart(g3, "0");
+var MJ = (J) => J.toString(16).padStart(g3, "0");
 function OJ(J) {
   let $ = J.toLowerCase().replace("0x", ""), Q = _$(cJ(new TextEncoder().encode($))).slice(2), Y = "0x";
-  for (let M3 = 0;M3 < $.length; M3++)
-    Y += parseInt(Q[M3], 16) >= 8 ? $[M3].toUpperCase() : $[M3];
+  for (let G = 0;G < $.length; G++)
+    Y += parseInt(Q[G], 16) >= 8 ? $[G].toUpperCase() : $[G];
   return Y;
 }
 function a$(J, $) {
   if (J === "tuple" && $)
-    return `(${$.map((M3) => a$(M3.type, M3.components)).join(",")})`;
+    return `(${$.map((G) => a$(G.type, G.components)).join(",")})`;
   let Q = J.match(/^tuple(\[\d*\])$/);
   if (Q && $)
     return `${a$("tuple", $)}${Q[1]}`;
@@ -1526,34 +1526,34 @@ function NJ(J, $, Q) {
   return VQ(J, $);
 }
 function zQ(J, $, Q) {
-  let Y = J.slice(0, J.indexOf("[")), M3 = J.endsWith("[]"), G = pJ(Y, Q), Z;
-  if (G) {
+  let Y = J.slice(0, J.indexOf("[")), G = J.endsWith("[]"), M3 = pJ(Y, Q), Z;
+  if (M3) {
     let K = $.map((U) => NJ(Y, U, Q)), X = $.length * w$;
     Z = K.map((U) => {
       let D3 = X;
-      return X += U.length / 2, GJ(D3);
+      return X += U.length / 2, MJ(D3);
     }).join("") + K.join("");
   } else
     Z = $.map((K) => NJ(Y, K, Q)).join("");
-  return M3 ? GJ($.length) + Z : Z;
+  return G ? MJ($.length) + Z : Z;
 }
 function DQ(J, $) {
-  let Q = Array.isArray($), Y = [], M3 = [], G = [];
+  let Q = Array.isArray($), Y = [], G = [], M3 = [];
   for (let Z = 0;Z < J.length; Z++) {
     let K = J[Z], X = Q ? $[Z] : $[K.name || ""], q = pJ(K.type, K.components);
-    if (G.push(q), q)
-      Y.push(""), M3.push(NJ(K.type, X, K.components));
+    if (M3.push(q), q)
+      Y.push(""), G.push(NJ(K.type, X, K.components));
     else
       Y.push(NJ(K.type, X, K.components));
   }
-  if (M3.length > 0) {
-    let Z = Y.reduce((q, U, D3) => q + (G[D3] ? w$ : U.length / 2), 0), K = "", X = 0;
+  if (G.length > 0) {
+    let Z = Y.reduce((q, U, D3) => q + (M3[D3] ? w$ : U.length / 2), 0), K = "", X = 0;
     for (let q = 0;q < J.length; q++)
-      if (G[q])
-        K += GJ(Z), Z += M3[X].length / 2, X++;
+      if (M3[q])
+        K += MJ(Z), Z += G[X].length / 2, X++;
       else
         K += Y[q];
-    return K + M3.join("");
+    return K + G.join("");
   }
   return Y.join("");
 }
@@ -1561,10 +1561,10 @@ function VQ(J, $) {
   if (J === "address")
     return A$($).toLowerCase().padStart(g3, "0");
   if (J === "bool")
-    return GJ($ ? 1 : 0);
+    return MJ($ ? 1 : 0);
   if (J.startsWith("uint")) {
     let Q = typeof $ === "bigint" ? $ : BigInt($);
-    return GJ(Q);
+    return MJ(Q);
   }
   if (J.startsWith("int")) {
     let Q = typeof $ === "bigint" ? $ : BigInt($);
@@ -1572,33 +1572,33 @@ function VQ(J, $) {
       let Y = J === "int" ? 256 : parseInt(J.slice(3));
       Q = (1n << BigInt(Y)) + Q;
     }
-    return GJ(Q);
+    return MJ(Q);
   }
   if (J.startsWith("bytes") && J !== "bytes")
     return A$($).padEnd(g3, "0");
   if (J === "bytes") {
-    let Q = A$($), Y = GJ(Q.length / 2), M3 = Q.padEnd(Math.ceil(Q.length / g3) * g3, "0");
-    return Y + M3;
+    let Q = A$($), Y = MJ(Q.length / 2), G = Q.padEnd(Math.ceil(Q.length / g3) * g3, "0");
+    return Y + G;
   }
   if (J === "string") {
-    let Q = Array.from(new TextEncoder().encode($)).map((G) => G.toString(16).padStart(2, "0")).join(""), Y = GJ(Q.length / 2), M3 = Q.padEnd(Math.ceil(Q.length / g3) * g3, "0");
-    return Y + M3;
+    let Q = Array.from(new TextEncoder().encode($)).map((M3) => M3.toString(16).padStart(2, "0")).join(""), Y = MJ(Q.length / 2), G = Q.padEnd(Math.ceil(Q.length / g3) * g3, "0");
+    return Y + G;
   }
   throw Error(`Unsupported type: ${J}`);
 }
-function G$(J, $, Q = 0, Y) {
+function M$(J, $, Q = 0, Y) {
   if (J === "tuple" && Y)
     return OQ(Y, $, Q);
   if (J.includes("["))
     return NQ(J, $, Q, Y);
-  return CQ(J, $, Q);
+  return RQ(J, $, Q);
 }
 function NQ(J, $, Q, Y) {
-  let M3 = J.slice(0, J.indexOf("[")), G = $.slice(Q, Q + g3);
+  let G = J.slice(0, J.indexOf("[")), M3 = $.slice(Q, Q + g3);
   if (J.endsWith("[]")) {
-    let K = parseInt(G, 16) * 2, X = parseInt($.slice(K, K + g3), 16), q = [], U = K + g3;
+    let K = parseInt(M3, 16) * 2, X = parseInt($.slice(K, K + g3), 16), q = [], U = K + g3;
     for (let D3 = 0;D3 < X; D3++) {
-      let V = G$(M3, $, U, Y);
+      let V = M$(G, $, U, Y);
       q.push(V.value), U += V.consumed;
     }
     return { value: q, consumed: g3 };
@@ -1607,7 +1607,7 @@ function NQ(J, $, Q, Y) {
   if (Z) {
     let K = parseInt(Z[1]), X = [], q = 0;
     for (let U = 0;U < K; U++) {
-      let D3 = G$(M3, $, Q + q, Y);
+      let D3 = M$(G, $, Q + q, Y);
       X.push(D3.value), q += D3.consumed;
     }
     return { value: X, consumed: q };
@@ -1615,14 +1615,14 @@ function NQ(J, $, Q, Y) {
   throw Error(`Invalid array type: ${J}`);
 }
 function OQ(J, $, Q) {
-  let Y = [], M3 = Q;
-  for (let G of J) {
-    let Z = G$(G.type, $, M3, G.components);
-    Y.push(Z.value), M3 += Z.consumed;
+  let Y = [], G = Q;
+  for (let M3 of J) {
+    let Z = M$(M3.type, $, G, M3.components);
+    Y.push(Z.value), G += Z.consumed;
   }
-  return { value: Y, consumed: M3 - Q };
+  return { value: Y, consumed: G - Q };
 }
-function CQ(J, $, Q) {
+function RQ(J, $, Q) {
   let Y = $.slice(Q, Q + g3);
   if (J === "address")
     return { value: OJ("0x" + Y.slice(24)), consumed: g3 };
@@ -1631,30 +1631,30 @@ function CQ(J, $, Q) {
   if (J.startsWith("uint"))
     return { value: BigInt("0x" + Y), consumed: g3 };
   if (J.startsWith("int")) {
-    let M3 = BigInt("0x" + Y), G = J === "int" ? 256 : parseInt(J.slice(3)), Z = 1n << BigInt(G - 1);
-    return { value: M3 >= Z ? M3 - (1n << BigInt(G)) : M3, consumed: g3 };
+    let G = BigInt("0x" + Y), M3 = J === "int" ? 256 : parseInt(J.slice(3)), Z = 1n << BigInt(M3 - 1);
+    return { value: G >= Z ? G - (1n << BigInt(M3)) : G, consumed: g3 };
   }
   if (J.startsWith("bytes") && J !== "bytes") {
-    let M3 = parseInt(J.match(/^bytes(\d+)$/)[1]);
-    return { value: "0x" + Y.slice(0, M3 * 2), consumed: g3 };
+    let G = parseInt(J.match(/^bytes(\d+)$/)[1]);
+    return { value: "0x" + Y.slice(0, G * 2), consumed: g3 };
   }
   if (J === "bytes") {
-    let M3 = parseInt(Y, 16) * 2, G = parseInt($.slice(M3, M3 + g3), 16) * 2;
-    return { value: "0x" + $.slice(M3 + g3, M3 + g3 + G), consumed: g3 };
+    let G = parseInt(Y, 16) * 2, M3 = parseInt($.slice(G, G + g3), 16) * 2;
+    return { value: "0x" + $.slice(G + g3, G + g3 + M3), consumed: g3 };
   }
   if (J === "string") {
-    let M3 = parseInt(Y, 16) * 2, G = parseInt($.slice(M3, M3 + g3), 16) * 2, Z = $.slice(M3 + g3, M3 + g3 + G), K = new Uint8Array(Z.match(/.{2}/g)?.map((X) => parseInt(X, 16)) || []);
+    let G = parseInt(Y, 16) * 2, M3 = parseInt($.slice(G, G + g3), 16) * 2, Z = $.slice(G + g3, G + g3 + M3), K = new Uint8Array(Z.match(/.{2}/g)?.map((X) => parseInt(X, 16)) || []);
     return { value: new TextDecoder().decode(K), consumed: g3 };
   }
   throw Error(`Unsupported type: ${J}`);
 }
 function TJ(J) {
-  let { abi: $, functionName: Q, args: Y = [] } = J, M3 = $.find((O3) => O3.type === "function" && O3.name === Q);
-  if (!M3)
+  let { abi: $, functionName: Q, args: Y = [] } = J, G = $.find((O3) => O3.type === "function" && O3.name === Q);
+  if (!G)
     throw Error(`Function "${Q}" not found in ABI`);
-  let G = jQ(M3), Z = M3.inputs || [];
+  let M3 = jQ(G), Z = G.inputs || [];
   if (Z.length === 0)
-    return G;
+    return M3;
   if (Y.length !== Z.length)
     throw Error(`Expected ${Z.length} arguments, got ${Y.length}`);
   let K = [], X = [], q = [];
@@ -1666,28 +1666,28 @@ function TJ(J) {
       K.push(NJ(L2.type, Y[O3], N2));
   }
   if (X.length === 0)
-    return G + K.join("");
+    return M3 + K.join("");
   let U = K.reduce((O3, L2, N2) => O3 + (q[N2] ? w$ : L2.length / 2), 0), D3 = "", V = 0;
   for (let O3 = 0;O3 < Z.length; O3++)
     if (q[O3])
-      D3 += GJ(U), U += X[V].length / 2, V++;
+      D3 += MJ(U), U += X[V].length / 2, V++;
     else
       D3 += K[O3];
-  return G + D3 + X.join("");
+  return M3 + D3 + X.join("");
 }
 function Z$(J) {
-  let { abi: $, functionName: Q, data: Y } = J, M3 = $.find((q) => q.type === "function" && q.name === Q);
-  if (!M3)
+  let { abi: $, functionName: Q, data: Y } = J, G = $.find((q) => q.type === "function" && q.name === Q);
+  if (!G)
     throw Error(`Function "${Q}" not found in ABI`);
-  let G = M3.outputs || [];
-  if (G.length === 0)
+  let M3 = G.outputs || [];
+  if (M3.length === 0)
     return;
   let Z = A$(Y);
-  if (G.length === 1)
-    return G$(G[0].type, Z, 0, G[0].components).value;
+  if (M3.length === 1)
+    return M$(M3[0].type, Z, 0, M3[0].components).value;
   let K = [], X = 0;
-  for (let q of G) {
-    let U = G$(q.type, Z, X, q.components);
+  for (let q of M3) {
+    let U = M$(q.type, Z, X, q.components);
     K.push(U.value), X += U.consumed;
   }
   return K;
@@ -1695,31 +1695,31 @@ function Z$(J) {
 function r3(J, $) {
   if (J.length !== $.length)
     throw Error(`Type/value length mismatch: ${J.length} types, ${$.length} values`);
-  let Q = [], Y = [], M3 = [];
+  let Q = [], Y = [], G = [];
   for (let X = 0;X < J.length; X++) {
     let q = J[X], U = pJ(q);
-    if (M3.push(U), U)
+    if (G.push(U), U)
       Q.push(""), Y.push(NJ(q, $[X]));
     else
       Q.push(NJ(q, $[X]));
   }
   if (Y.length === 0)
     return "0x" + Q.join("");
-  let G = Q.reduce((X, q, U) => X + (M3[U] ? w$ : q.length / 2), 0), Z = "", K = 0;
+  let M3 = Q.reduce((X, q, U) => X + (G[U] ? w$ : q.length / 2), 0), Z = "", K = 0;
   for (let X = 0;X < J.length; X++)
-    if (M3[X])
-      Z += GJ(G), G += Y[K].length / 2, K++;
+    if (G[X])
+      Z += MJ(M3), M3 += Y[K].length / 2, K++;
     else
       Z += Q[X];
   return "0x" + Z + Y.join("");
 }
-function C3(J) {
+function R3(J) {
   return J.toLowerCase();
 }
-function RQ(J) {
+function CQ(J) {
   return OJ(J);
 }
-function BQ(J) {
+function PQ(J) {
   if (typeof J !== "string")
     return false;
   let $ = J.replace("0x", "");
@@ -1728,8 +1728,8 @@ function BQ(J) {
 function H(J) {
   if (J === null || J === undefined)
     return J;
-  if (BQ(J))
-    return RQ(J);
+  if (PQ(J))
+    return CQ(J);
   if (Array.isArray(J))
     return J.map(($) => H($));
   if (typeof J === "object" && J !== null) {
@@ -1742,7 +1742,7 @@ function H(J) {
   return J;
 }
 function J0(J) {
-  return { Source: C3(J.from), Sink: C3(J.to), TargetFlow: J.targetFlow.toString(), WithWrap: J.useWrappedBalances, FromTokens: J.fromTokens?.map(C3), ToTokens: J.toTokens?.map(C3), ExcludedFromTokens: J.excludeFromTokens?.map(C3), ExcludedToTokens: J.excludeToTokens?.map(C3), SimulatedBalances: J.simulatedBalances?.map(($) => ({ Holder: C3($.holder), Token: C3($.token), Amount: $.amount.toString(), IsWrapped: $.isWrapped, IsStatic: $.isStatic })), SimulatedTrusts: J.simulatedTrusts?.map(($) => ({ Truster: C3($.truster), Trustee: C3($.trustee) })), MaxTransfers: J.maxTransfers };
+  return { Source: R3(J.from), Sink: R3(J.to), TargetFlow: J.targetFlow.toString(), WithWrap: J.useWrappedBalances, FromTokens: J.fromTokens?.map(R3), ToTokens: J.toTokens?.map(R3), ExcludedFromTokens: J.excludeFromTokens?.map(R3), ExcludedToTokens: J.excludeToTokens?.map(R3), SimulatedBalances: J.simulatedBalances?.map(($) => ({ Holder: R3($.holder), Token: R3($.token), Amount: $.amount.toString(), IsWrapped: $.isWrapped, IsStatic: $.isStatic })), SimulatedTrusts: J.simulatedTrusts?.map(($) => ({ Truster: R3($.truster), Trustee: R3($.trustee) })), MaxTransfers: J.maxTransfers };
 }
 function XJ(J) {
   let $ = {};
@@ -1755,7 +1755,7 @@ function XJ(J) {
     else if (typeof Y === "object" && !Array.isArray(Y))
       $[Q] = XJ(Y);
     else if (Array.isArray(Y))
-      $[Q] = Y.map((M3) => typeof M3 === "object" && M3 !== null ? XJ(M3) : M3);
+      $[Q] = Y.map((G) => typeof G === "object" && G !== null ? XJ(G) : G);
     else
       $[Q] = Y;
   }
@@ -1791,23 +1791,23 @@ class K$ {
     this.client = J;
   }
   async query(J) {
-    let $ = await this.client.call("circles_query", [J]), { columns: Q, rows: Y } = $, M3 = Y.map((G) => {
+    let $ = await this.client.call("circles_query", [J]), { columns: Q, rows: Y } = $, G = Y.map((M3) => {
       let Z = {};
       return Q.forEach((K, X) => {
-        Z[K] = G[X];
+        Z[K] = M3[X];
       }), Z;
     });
-    return H(M3);
+    return H(G);
   }
   async tables() {
     return this.client.call("circles_tables", []);
   }
-  async events(J = null, $ = null, Q = null, Y = null, M3 = null, G = false, Z = 100, K = null) {
-    let X = await this.client.call("circles_events_paginated", [J, $, Q, Y, M3, G, Z, K]);
+  async events(J = null, $ = null, Q = null, Y = null, G = null, M3 = false, Z = 100, K = null) {
+    let X = await this.client.call("circles_events_paginated", [J, $, Q, Y, G, M3, Z, K]);
     return { events: H(X.events), hasMore: X.hasMore, nextCursor: X.nextCursor };
   }
 }
-var PQ = [{ name: "blockNumber", sortOrder: "DESC" }, { name: "transactionIndex", sortOrder: "DESC" }, { name: "logIndex", sortOrder: "DESC" }];
+var BQ = [{ name: "blockNumber", sortOrder: "DESC" }, { name: "transactionIndex", sortOrder: "DESC" }, { name: "logIndex", sortOrder: "DESC" }];
 
 class SJ {
   params;
@@ -1823,7 +1823,7 @@ class SJ {
     this.client = J, this.params = $, this.rowTransformer = Q || $.rowTransformer, this.orderColumns = $.orderColumns, this.cursorColumns = $.cursorColumns || this.buildEventCursorColumns();
   }
   buildEventCursorColumns() {
-    let J = PQ.map(($) => ({ ...$, sortOrder: this.params.sortOrder }));
+    let J = BQ.map(($) => ({ ...$, sortOrder: this.params.sortOrder }));
     if (this.params.table === "TransferBatch")
       J.push({ name: "batchIndex", sortOrder: this.params.sortOrder });
     return J;
@@ -1836,10 +1836,10 @@ class SJ {
   rowsToObjects(J) {
     let { columns: $, rows: Q } = J;
     return Q.map((Y) => {
-      let M3 = {};
-      return $.forEach((G, Z) => {
-        M3[G] = Y[Z];
-      }), this.rowTransformer ? this.rowTransformer(M3) : M3;
+      let G = {};
+      return $.forEach((M3, Z) => {
+        G[M3] = Y[Z];
+      }), this.rowTransformer ? this.rowTransformer(G) : G;
     });
   }
   async queryNextPage() {
@@ -1859,44 +1859,44 @@ class _J {
   transformQueryResponse(J) {
     let { columns: $, rows: Q } = J;
     return Q.map((Y) => {
-      let M3 = {};
-      return $.forEach((G, Z) => {
-        M3[G] = Y[Z];
-      }), M3;
+      let G = {};
+      return $.forEach((M3, Z) => {
+        G[M3] = Y[Z];
+      }), G;
     });
   }
   async getCommonTrust(J, $) {
-    let Q = await this.client.call("circles_getCommonTrust", [C3(J), C3($)]);
+    let Q = await this.client.call("circles_getCommonTrust", [R3(J), R3($)]);
     return H(Q);
   }
   getTrustRelations(J, $ = 100, Q = "DESC") {
-    let Y = C3(J), M3 = [{ Type: "Conjunction", ConjunctionType: "And", Predicates: [{ Type: "FilterPredicate", FilterType: "Equals", Column: "version", Value: 2 }, { Type: "Conjunction", ConjunctionType: "Or", Predicates: [{ Type: "FilterPredicate", FilterType: "Equals", Column: "trustee", Value: Y }, { Type: "FilterPredicate", FilterType: "Equals", Column: "truster", Value: Y }] }] }];
-    return new SJ(this.client, { namespace: "V_Crc", table: "TrustRelations", sortOrder: Q, columns: ["blockNumber", "timestamp", "transactionIndex", "logIndex", "transactionHash", "version", "trustee", "truster", "expiryTime"], filter: M3, limit: $ }, (G) => H(G));
+    let Y = R3(J), G = [{ Type: "Conjunction", ConjunctionType: "And", Predicates: [{ Type: "FilterPredicate", FilterType: "Equals", Column: "version", Value: 2 }, { Type: "Conjunction", ConjunctionType: "Or", Predicates: [{ Type: "FilterPredicate", FilterType: "Equals", Column: "trustee", Value: Y }, { Type: "FilterPredicate", FilterType: "Equals", Column: "truster", Value: Y }] }] }];
+    return new SJ(this.client, { namespace: "V_Crc", table: "TrustRelations", sortOrder: Q, columns: ["blockNumber", "timestamp", "transactionIndex", "logIndex", "transactionHash", "version", "trustee", "truster", "expiryTime"], filter: G, limit: $ }, (M3) => H(M3));
   }
   async getAggregatedTrustRelations(J) {
-    let $ = C3(J), Q = await this.client.call("circles_getAggregatedTrustRelations", [$]);
+    let $ = R3(J), Q = await this.client.call("circles_getAggregatedTrustRelations", [$]);
     return H(Q);
   }
   async getTrustedBy(J) {
-    let $ = C3(J), Y = (await this.getAggregatedTrustRelations($)).filter((M3) => M3.relation === "trustedBy");
+    let $ = R3(J), Y = (await this.getAggregatedTrustRelations($)).filter((G) => G.relation === "trustedBy");
     return H(Y);
   }
   async getTrusts(J) {
-    let $ = C3(J), Y = (await this.getAggregatedTrustRelations($)).filter((M3) => M3.relation === "trusts");
+    let $ = R3(J), Y = (await this.getAggregatedTrustRelations($)).filter((G) => G.relation === "trusts");
     return H(Y);
   }
   async getMutualTrusts(J) {
-    let $ = C3(J), Y = (await this.getAggregatedTrustRelations($)).filter((M3) => M3.relation === "mutuallyTrusts");
+    let $ = R3(J), Y = (await this.getAggregatedTrustRelations($)).filter((G) => G.relation === "mutuallyTrusts");
     return H(Y);
   }
   async getTrustNetworkSummary(J, $ = 2) {
-    return this.client.call("circles_getTrustNetworkSummary", [C3(J), $]);
+    return this.client.call("circles_getTrustNetworkSummary", [R3(J), $]);
   }
   async getAggregatedTrustRelationsEnriched(J) {
-    return this.client.call("circles_getAggregatedTrustRelationsEnriched", [C3(J)]);
+    return this.client.call("circles_getAggregatedTrustRelationsEnriched", [R3(J)]);
   }
   async getValidInviters(J, $) {
-    let Q = [C3(J)];
+    let Q = [R3(J)];
     if ($)
       Q.push($);
     return this.client.call("circles_getValidInviters", Q);
@@ -1922,13 +1922,13 @@ class nJ {
     return J * $ >> 64n;
   }
   static pow64(J, $) {
-    let Q = J, Y = $, M3 = this.ONE_64;
+    let Q = J, Y = $, G = this.ONE_64;
     while (Y > 0n) {
       if ((Y & 1n) === 1n)
-        M3 = this.mul64(M3, Q);
+        G = this.mul64(G, Q);
       Q = this.mul64(Q, Q), Y >>= 1n;
     }
-    return M3;
+    return G;
   }
   static ONE_36 = 1000000000000000000000000000000000000000n;
   static GAMMA_36 = 999801332008598957430613406568191166n;
@@ -1937,11 +1937,11 @@ class nJ {
     return J * $ / this.ONE_36;
   }
   static pow36(J, $) {
-    let Q = this.ONE_36, Y = J, M3 = $;
-    while (M3 > 0n) {
-      if ((M3 & 1n) === 1n)
+    let Q = this.ONE_36, Y = J, G = $;
+    while (G > 0n) {
+      if ((G & 1n) === 1n)
         Q = this.mul36(Q, Y);
-      Y = this.mul36(Y, Y), M3 >>= 1n;
+      Y = this.mul36(Y, Y), G >>= 1n;
     }
     return Q;
   }
@@ -2003,16 +2003,16 @@ class nJ {
     return this.V1_ACCURACY * this.V1_INFLATION_PCT_NUM ** J / this.V1_INFLATION_PCT_DEN ** J;
   }
   static attoCrcToAttoCircles(J, $) {
-    let Q = $ - this.INFLATION_DAY_ZERO_UNIX, Y = Q / this.PERIOD_SEC, M3 = Q % this.PERIOD_SEC, G = this.v1InflateFactor(Y), Z = this.v1InflateFactor(Y + 1n);
-    return this.v1ToDemurrage(J, G, Z, M3, this.PERIOD_SEC);
+    let Q = $ - this.INFLATION_DAY_ZERO_UNIX, Y = Q / this.PERIOD_SEC, G = Q % this.PERIOD_SEC, M3 = this.v1InflateFactor(Y), Z = this.v1InflateFactor(Y + 1n);
+    return this.v1ToDemurrage(J, M3, Z, G, this.PERIOD_SEC);
   }
   static attoCirclesToAttoCrc(J, $) {
-    let Q = $ - this.INFLATION_DAY_ZERO_UNIX, Y = Q / this.PERIOD_SEC, M3 = Q % this.PERIOD_SEC, G = this.v1InflateFactor(Y), Z = this.v1InflateFactor(Y + 1n), K = G * (this.PERIOD_SEC - M3) + Z * M3;
+    let Q = $ - this.INFLATION_DAY_ZERO_UNIX, Y = Q / this.PERIOD_SEC, G = Q % this.PERIOD_SEC, M3 = this.v1InflateFactor(Y), Z = this.v1InflateFactor(Y + 1n), K = M3 * (this.PERIOD_SEC - G) + Z * G;
     return J * 3n * this.V1_ACCURACY * this.PERIOD_SEC / K;
   }
-  static v1ToDemurrage(J, $, Q, Y, M3) {
-    let G = $ * (M3 - Y) + Q * Y;
-    return J * 3n * this.V1_ACCURACY * M3 / G;
+  static v1ToDemurrage(J, $, Q, Y, G) {
+    let M3 = $ * (G - Y) + Q * Y;
+    return J * 3n * this.V1_ACCURACY * G / M3;
   }
 }
 
@@ -2022,11 +2022,11 @@ class yJ {
     this.client = J;
   }
   async getTotalBalance(J, $ = true) {
-    let Q = await this.client.call("circlesV2_getTotalBalance", [C3(J), $]);
+    let Q = await this.client.call("circlesV2_getTotalBalance", [R3(J), $]);
     return nJ.circlesToAttoCircles(Q);
   }
   async getTokenBalances(J) {
-    let Q = (await this.client.call("circles_getTokenBalances", [C3(J)])).map((Y) => XJ(Y));
+    let Q = (await this.client.call("circles_getTokenBalances", [R3(J)])).map((Y) => XJ(Y));
     return H(Q);
   }
 }
@@ -2043,7 +2043,7 @@ class q$ {
   async getAvatarInfoBatch(J) {
     if (J.length === 0)
       return [];
-    let $ = J.map((Y) => C3(Y)), Q = await this.client.call("circles_getAvatarInfoBatch", [$]);
+    let $ = J.map((Y) => R3(Y)), Q = await this.client.call("circles_getAvatarInfoBatch", [$]);
     return H(Q);
   }
   async getNetworkSnapshot() {
@@ -2064,10 +2064,10 @@ class U$ {
     return this.client.call("circles_getProfileByCidBatch", [J]);
   }
   async getProfileByAddress(J) {
-    return this.client.call("circles_getProfileByAddress", [C3(J)]);
+    return this.client.call("circles_getProfileByAddress", [R3(J)]);
   }
   async getProfileByAddressBatch(J) {
-    return this.client.call("circles_getProfileByAddressBatch", [J.map(($) => $ === null ? null : C3($))]);
+    return this.client.call("circles_getProfileByAddressBatch", [J.map(($) => $ === null ? null : R3($))]);
   }
   async searchProfiles(J, $ = 10, Q = 0, Y) {
     return this.client.call("circles_searchProfiles", [J.toLowerCase(), $, Q, Y]);
@@ -2076,7 +2076,7 @@ class U$ {
     return this.client.call("circles_searchProfileByAddressOrName", Y ? [J, $, Q ?? null, Y] : [J, $, Q ?? null]);
   }
   async getProfileView(J) {
-    return this.client.call("circles_getProfileView", [C3(J)]);
+    return this.client.call("circles_getProfileView", [R3(J)]);
   }
 }
 
@@ -2092,11 +2092,11 @@ class AJ {
   async getTokenInfoBatch(J) {
     if (J.length === 0)
       return [];
-    let $ = J.map((M3) => C3(M3)), Y = (await this.client.call("circles_getTokenInfoBatch", [$])).map((M3) => XJ(M3));
+    let $ = J.map((G) => R3(G)), Y = (await this.client.call("circles_getTokenInfoBatch", [$])).map((G) => XJ(G));
     return H(Y);
   }
   async getTokenHolders(J, $ = 100, Q) {
-    let Y = await this.client.call("circles_getTokenHolders", [C3(J), $, Q ?? null]);
+    let Y = await this.client.call("circles_getTokenHolders", [R3(J), $, Q ?? null]);
     return { hasMore: Y.hasMore, nextCursor: Y.nextCursor, results: H(Y.results) };
   }
 }
@@ -2107,7 +2107,7 @@ class W$ {
     this.client = J;
   }
   async getInvitationOrigin(J) {
-    let $ = C3(J), Q = await this.client.call("circles_getInvitationOrigin", [$]);
+    let $ = R3(J), Q = await this.client.call("circles_getInvitationOrigin", [$]);
     return Q ? H(Q) : null;
   }
   async getInvitedBy(J) {
@@ -2117,31 +2117,31 @@ class W$ {
     return;
   }
   async getTrustInvitations(J, $) {
-    let Q = C3(J), Y = await this.client.call("circles_getTrustInvitations", $ ? [Q, $] : [Q]);
+    let Q = R3(J), Y = await this.client.call("circles_getTrustInvitations", $ ? [Q, $] : [Q]);
     return H(Y);
   }
   async getInvitations(J, $) {
-    let Y = (await this.getValidInviters(J, $)).results.map((M3) => M3.avatarInfo).filter((M3) => M3 !== undefined && M3 !== null);
+    let Y = (await this.getValidInviters(J, $)).results.map((G) => G.avatarInfo).filter((G) => G !== undefined && G !== null);
     return H(Y);
   }
   async getValidInviters(J, $) {
-    let Q = C3(J), Y = await this.client.call("circles_getValidInviters", $ ? [Q, $] : [Q]);
+    let Q = R3(J), Y = await this.client.call("circles_getValidInviters", $ ? [Q, $] : [Q]);
     return H(Y);
   }
   async getInvitationsFrom(J, $ = false) {
-    let Q = C3(J), Y = await this.client.call("circles_getInvitationsFrom", [Q, $]);
+    let Q = R3(J), Y = await this.client.call("circles_getInvitationsFrom", [Q, $]);
     return H(Y);
   }
   async getEscrowInvitations(J) {
-    let $ = C3(J), Q = await this.client.call("circles_getEscrowInvitations", [$]);
+    let $ = R3(J), Q = await this.client.call("circles_getEscrowInvitations", [$]);
     return H(Q);
   }
   async getAtScaleInvitations(J) {
-    let $ = C3(J), Q = await this.client.call("circles_getAtScaleInvitations", [$]);
+    let $ = R3(J), Q = await this.client.call("circles_getAtScaleInvitations", [$]);
     return H(Q);
   }
   async getAllInvitations(J, $) {
-    let Q = C3(J), Y = await this.client.call("circles_getAllInvitations", $ ? [Q, $] : [Q]);
+    let Q = R3(J), Y = await this.client.call("circles_getAllInvitations", $ ? [Q, $] : [Q]);
     return H(Y);
   }
 }
@@ -2152,12 +2152,12 @@ class j$ {
     this.client = J;
   }
   async getTransactionHistory(J, $ = 50, Q) {
-    let Y = await this.client.call("circles_getTransactionHistory", [C3(J), $, Q ?? null]);
+    let Y = await this.client.call("circles_getTransactionHistory", [R3(J), $, Q ?? null]);
     return { hasMore: Y.hasMore, nextCursor: Y.nextCursor, results: H(Y.results) };
   }
-  async getTransactionHistoryEnriched(J, $ = 0, Q = null, Y = 20, M3) {
-    let G = await this.client.call("circles_getTransactionHistoryEnriched", [C3(J), $, Q, Y, M3 ?? null]);
-    return { hasMore: G.hasMore, nextCursor: G.nextCursor, results: H(G.results) };
+  async getTransactionHistoryEnriched(J, $ = 0, Q = null, Y = 20, G) {
+    let M3 = await this.client.call("circles_getTransactionHistoryEnriched", [R3(J), $, Q, Y, G ?? null]);
+    return { hasMore: M3.hasMore, nextCursor: M3.nextCursor, results: H(M3.results) };
   }
 }
 
@@ -2167,20 +2167,20 @@ class wJ {
     this.client = J;
   }
   async findGroups(J = 50, $, Q) {
-    let Y = $ ? { nameStartsWith: $.nameStartsWith, symbolStartsWith: $.symbolStartsWith, ownerIn: $.ownerIn?.map((Z) => C3(Z)) } : undefined, M3 = await this.client.call("circles_findGroups", [J, Y ?? null, Q ?? null]), G = H(M3.results).map((Z) => {
+    let Y = $ ? { nameStartsWith: $.nameStartsWith, symbolStartsWith: $.symbolStartsWith, ownerIn: $.ownerIn?.map((Z) => R3(Z)) } : undefined, G = await this.client.call("circles_findGroups", [J, Y ?? null, Q ?? null]), M3 = H(G.results).map((Z) => {
       let K = Z;
       if (!K.owner && K.mint)
         return { ...K, owner: K.mint };
       return K;
     });
-    return { hasMore: M3.hasMore, nextCursor: M3.nextCursor, results: G };
+    return { hasMore: G.hasMore, nextCursor: G.nextCursor, results: M3 };
   }
   async getGroupMemberships(J, $ = 50, Q) {
-    let Y = await this.client.call("circles_getGroupMemberships", [C3(J), $, Q ?? null]);
+    let Y = await this.client.call("circles_getGroupMemberships", [R3(J), $, Q ?? null]);
     return { hasMore: Y.hasMore, nextCursor: Y.nextCursor, results: H(Y.results) };
   }
   async getGroupMembers(J, $ = 100, Q) {
-    let Y = await this.client.call("circles_getGroupMembers", [C3(J), $, Q ?? null]);
+    let Y = await this.client.call("circles_getGroupMembers", [R3(J), $, Q ?? null]);
     return { hasMore: Y.hasMore, nextCursor: Y.nextCursor, results: H(Y.results) };
   }
   getGroups(J = 50, $, Q = "DESC") {
@@ -2191,36 +2191,36 @@ class wJ {
       if ($.symbolStartsWith)
         Y.push({ Type: "FilterPredicate", FilterType: "Like", Column: "symbol", Value: $.symbolStartsWith + "%" });
       if ($.groupAddressIn && $.groupAddressIn.length > 0) {
-        let G = $.groupAddressIn.map((Z) => ({ Type: "FilterPredicate", FilterType: "Equals", Column: "group", Value: C3(Z) }));
-        if (G.length === 1)
-          Y.push(G[0]);
+        let M3 = $.groupAddressIn.map((Z) => ({ Type: "FilterPredicate", FilterType: "Equals", Column: "group", Value: R3(Z) }));
+        if (M3.length === 1)
+          Y.push(M3[0]);
         else
-          Y.push({ Type: "Conjunction", ConjunctionType: "Or", Predicates: G });
+          Y.push({ Type: "Conjunction", ConjunctionType: "Or", Predicates: M3 });
       }
       if ($.groupTypeIn && $.groupTypeIn.length > 0) {
-        let G = $.groupTypeIn.map((Z) => ({ Type: "FilterPredicate", FilterType: "Equals", Column: "type", Value: Z }));
-        if (G.length === 1)
-          Y.push(G[0]);
+        let M3 = $.groupTypeIn.map((Z) => ({ Type: "FilterPredicate", FilterType: "Equals", Column: "type", Value: Z }));
+        if (M3.length === 1)
+          Y.push(M3[0]);
         else
-          Y.push({ Type: "Conjunction", ConjunctionType: "Or", Predicates: G });
+          Y.push({ Type: "Conjunction", ConjunctionType: "Or", Predicates: M3 });
       }
       if ($.ownerIn && $.ownerIn.length > 0) {
-        let G = $.ownerIn.map((Z) => ({ Type: "FilterPredicate", FilterType: "Equals", Column: "owner", Value: C3(Z) }));
-        if (G.length === 1)
-          Y.push(G[0]);
+        let M3 = $.ownerIn.map((Z) => ({ Type: "FilterPredicate", FilterType: "Equals", Column: "owner", Value: R3(Z) }));
+        if (M3.length === 1)
+          Y.push(M3[0]);
         else
-          Y.push({ Type: "Conjunction", ConjunctionType: "Or", Predicates: G });
+          Y.push({ Type: "Conjunction", ConjunctionType: "Or", Predicates: M3 });
       }
       if ($.mintHandlerEquals)
-        Y.push({ Type: "FilterPredicate", FilterType: "Equals", Column: "mintHandler", Value: C3($.mintHandlerEquals) });
+        Y.push({ Type: "FilterPredicate", FilterType: "Equals", Column: "mintHandler", Value: R3($.mintHandlerEquals) });
       if ($.treasuryEquals)
-        Y.push({ Type: "FilterPredicate", FilterType: "Equals", Column: "treasury", Value: C3($.treasuryEquals) });
+        Y.push({ Type: "FilterPredicate", FilterType: "Equals", Column: "treasury", Value: R3($.treasuryEquals) });
     }
-    let M3 = Y.length > 1 ? [{ Type: "Conjunction", ConjunctionType: "And", Predicates: Y }] : Y;
-    return new SJ(this.client, { namespace: "V_CrcV2", table: "Groups", sortOrder: Q, columns: ["blockNumber", "timestamp", "transactionIndex", "logIndex", "transactionHash", "group", "type", "owner", "mintPolicy", "mintHandler", "treasury", "service", "feeCollection", "memberCount", "name", "symbol", "cidV0Digest", "erc20WrapperDemurraged", "erc20WrapperStatic"], filter: M3, limit: J }, (G) => H(G));
+    let G = Y.length > 1 ? [{ Type: "Conjunction", ConjunctionType: "And", Predicates: Y }] : Y;
+    return new SJ(this.client, { namespace: "V_CrcV2", table: "Groups", sortOrder: Q, columns: ["blockNumber", "timestamp", "transactionIndex", "logIndex", "transactionHash", "group", "type", "owner", "mintPolicy", "mintHandler", "treasury", "service", "feeCollection", "memberCount", "name", "symbol", "cidV0Digest", "erc20WrapperDemurraged", "erc20WrapperStatic"], filter: G, limit: J }, (M3) => H(M3));
   }
   getGroupHolders(J, $ = 100) {
-    let Q = C3(J);
+    let Q = R3(J);
     return new SJ(this.client, { namespace: "V_Crc", table: "TokenBalances", sortOrder: "DESC", columns: ["blockNumber", "timestamp", "transactionIndex", "logIndex", "transactionHash", "token", "account", "balance", "lastChangedAt"], filter: [{ Type: "FilterPredicate", FilterType: "Equals", Column: "token", Value: Q }], limit: $ }, (Y) => H(Y));
   }
 }
@@ -2231,23 +2231,23 @@ class E$ {
     this.client = J;
   }
   async getProfileView(J) {
-    let $ = C3(J);
+    let $ = R3(J);
     return this.client.call("circles_getProfileView", [$]);
   }
   async getTrustNetworkSummary(J, $ = 2) {
-    let Q = C3(J);
+    let Q = R3(J);
     return this.client.call("circles_getTrustNetworkSummary", [Q, $]);
   }
   async getAggregatedTrustRelations(J) {
-    let $ = C3(J);
+    let $ = R3(J);
     return this.client.call("circles_getAggregatedTrustRelations", [$]);
   }
   async getValidInviters(J, $) {
-    let Q = C3(J), Y = await this.client.call("circles_getValidInviters", $ ? [Q, $] : [Q]);
+    let Q = R3(J), Y = await this.client.call("circles_getValidInviters", $ ? [Q, $] : [Q]);
     return H(Y);
   }
-  async getTransactionHistoryEnriched(J, $ = 0, Q = null, Y = 50, M3) {
-    let G = C3(J), Z = await this.client.call("circles_getTransactionHistoryEnriched", [G, $, Q, Y, M3 ?? null]);
+  async getTransactionHistoryEnriched(J, $ = 0, Q = null, Y = 50, G) {
+    let M3 = R3(J), Z = await this.client.call("circles_getTransactionHistoryEnriched", [M3, $, Q, Y, G ?? null]);
     return { hasMore: Z.hasMore, nextCursor: Z.nextCursor, results: H(Z.results) };
   }
   async searchProfileByAddressOrName(J, $ = 20, Q, Y) {
@@ -2342,7 +2342,7 @@ class p2 {
     this.address = J.address, this.abi = J.abi, this.rpcUrl = J.rpcUrl;
   }
   async read(J, $, Q) {
-    let Y = TJ({ abi: this.abi, functionName: J, args: $ }), M3 = { to: this.address, data: Y, ...Q?.from && { from: Q.from } }, Z = await (await fetch(this.rpcUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_call", params: [M3, "latest"] }) })).json();
+    let Y = TJ({ abi: this.abi, functionName: J, args: $ }), G = { to: this.address, data: Y, ...Q?.from && { from: Q.from } }, Z = await (await fetch(this.rpcUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_call", params: [G, "latest"] }) })).json();
     if (Z.error)
       throw Error(`RPC Error: ${Z.error.message}`);
     if (!Z.result)
@@ -2355,7 +2355,7 @@ class p2 {
 }
 var $0 = [{ type: "function", name: "operateFlowMatrix", inputs: [{ name: "_flowVertices", type: "address[]" }, { name: "_flow", type: "tuple[]", components: [{ name: "streamSinkId", type: "uint16" }, { name: "amount", type: "uint192" }] }, { name: "_streams", type: "tuple[]", components: [{ name: "sourceCoordinate", type: "uint16" }, { name: "flowEdgeIds", type: "uint16[]" }, { name: "data", type: "bytes" }] }, { name: "_packedCoordinates", type: "bytes" }], outputs: [], stateMutability: "nonpayable" }, { type: "function", name: "isApprovedForAll", inputs: [{ name: "_account", type: "address" }, { name: "_operator", type: "address" }], outputs: [{ type: "bool" }], stateMutability: "view" }, { type: "function", name: "setApprovalForAll", inputs: [{ name: "_operator", type: "address" }, { name: "_approved", type: "bool" }], outputs: [], stateMutability: "nonpayable" }, { type: "function", name: "wrap", inputs: [{ name: "_avatar", type: "address" }, { name: "_amount", type: "uint256" }, { name: "_type", type: "uint8" }], outputs: [{ type: "address" }], stateMutability: "nonpayable" }, { type: "function", name: "trust", inputs: [{ name: "_trustReceiver", type: "address" }, { name: "_expiry", type: "uint96" }], outputs: [], stateMutability: "nonpayable" }, { type: "function", name: "isTrusted", inputs: [{ name: "_truster", type: "address" }, { name: "_trustee", type: "address" }], outputs: [{ type: "bool" }], stateMutability: "view" }, { type: "function", name: "toTokenId", inputs: [{ name: "_avatar", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "pure" }, { type: "function", name: "safeTransferFrom", inputs: [{ name: "_from", type: "address" }, { name: "_to", type: "address" }, { name: "_id", type: "uint256" }, { name: "_value", type: "uint256" }, { name: "_data", type: "bytes" }], outputs: [], stateMutability: "nonpayable" }, { type: "function", name: "isHuman", inputs: [{ name: "_human", type: "address" }], outputs: [{ type: "bool" }], stateMutability: "view" }, { type: "function", name: "safeBatchTransferFrom", inputs: [{ name: "_from", type: "address" }, { name: "_to", type: "address" }, { name: "_ids", type: "uint256[]" }, { name: "_values", type: "uint256[]" }, { name: "_data", type: "bytes" }], outputs: [], stateMutability: "nonpayable" }];
 
-class CJ extends p2 {
+class RJ extends p2 {
   constructor(J) {
     super({ address: J.address, abi: $0, rpcUrl: J.rpcUrl });
   }
@@ -2377,8 +2377,8 @@ class CJ extends p2 {
   wrap(J, $, Q) {
     return { to: this.address, data: this.encodeWrite("wrap", [J, $, Q]), value: 0n };
   }
-  safeTransferFrom(J, $, Q, Y, M3 = "0x") {
-    return { to: this.address, data: this.encodeWrite("safeTransferFrom", [J, $, Q, Y, M3]), value: 0n };
+  safeTransferFrom(J, $, Q, Y, G = "0x") {
+    return { to: this.address, data: this.encodeWrite("safeTransferFrom", [J, $, Q, Y, G]), value: 0n };
   }
   operateFlowMatrix(J, $, Q, Y) {
     return { to: this.address, data: this.encodeWrite("operateFlowMatrix", [J, $, Q, Y]), value: 0n };
@@ -2386,8 +2386,8 @@ class CJ extends p2 {
   async isHuman(J) {
     return this.read("isHuman", [J]);
   }
-  safeBatchTransferFrom(J, $, Q, Y, M3 = "0x") {
-    return { to: this.address, data: this.encodeWrite("safeBatchTransferFrom", [J, $, Q, Y, M3]), value: 0n };
+  safeBatchTransferFrom(J, $, Q, Y, G = "0x") {
+    return { to: this.address, data: this.encodeWrite("safeBatchTransferFrom", [J, $, Q, Y, G]), value: 0n };
   }
 }
 var Q0 = [{ type: "function", name: "erc20Circles", inputs: [{ name: "_circlesType", type: "uint8" }, { name: "_avatar", type: "address" }], outputs: [{ type: "address" }], stateMutability: "view" }];
@@ -2422,7 +2422,7 @@ class D$ extends p2 {
 var $8 = [{ type: "function", name: "createAccount", inputs: [{ name: "signer", type: "address" }], outputs: [{ name: "account", type: "address" }], stateMutability: "nonpayable" }, { type: "function", name: "createAccounts", inputs: [{ name: "signers", type: "address[]" }], outputs: [{ name: "_accounts", type: "address[]" }], stateMutability: "nonpayable" }];
 var Q8 = [{ type: "function", name: "claimInvite", inputs: [], outputs: [{ name: "id", type: "uint256" }], stateMutability: "nonpayable" }, { type: "function", name: "claimInvites", inputs: [{ name: "numberOfInvites", type: "uint256" }], outputs: [{ name: "ids", type: "uint256[]" }], stateMutability: "nonpayable" }, { type: "function", name: "inviterQuota", inputs: [{ name: "", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" }, { type: "function", name: "INVITATION_FEE", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" }, { type: "function", name: "invitationModule", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" }];
 var Y8 = [{ type: "function", name: "isModuleEnabled", inputs: [{ name: "module", type: "address" }], outputs: [{ name: "", type: "bool" }], stateMutability: "view" }, { type: "function", name: "enableModule", inputs: [{ name: "module", type: "address" }], outputs: [], stateMutability: "nonpayable" }];
-var M8 = [{ type: "function", name: "trustInviter", inputs: [{ name: "inviter", type: "address" }], outputs: [], stateMutability: "nonpayable" }];
+var G8 = [{ type: "function", name: "trustInviter", inputs: [{ name: "inviter", type: "address" }], outputs: [], stateMutability: "nonpayable" }];
 
 class iJ extends p2 {
   constructor(J) {
@@ -2471,7 +2471,7 @@ class b$ extends p2 {
 
 class F$ extends p2 {
   constructor(J) {
-    super({ address: J.address, abi: M8, rpcUrl: J.rpcUrl });
+    super({ address: J.address, abi: G8, rpcUrl: J.rpcUrl });
   }
   trustInviter(J) {
     return { to: this.address, data: this.encodeWrite("trustInviter", [J]), value: 0n };
@@ -2528,7 +2528,7 @@ function oJ(J, $ = true) {
   if ($ && J.finished)
     throw Error("Hash#digest() has already been called");
 }
-function M0(J, $) {
+function G0(J, $) {
   xJ(J);
   let Q = $.outputLen;
   if (J.length < Q)
@@ -2554,16 +2554,16 @@ function N$(J) {
     J = TQ(J);
   return xJ(J), J;
 }
-function G0(...J) {
+function M0(...J) {
   let $ = 0;
   for (let Y = 0;Y < J.length; Y++) {
-    let M3 = J[Y];
-    xJ(M3), $ += M3.length;
+    let G = J[Y];
+    xJ(G), $ += G.length;
   }
   let Q = new Uint8Array($);
-  for (let Y = 0, M3 = 0;Y < J.length; Y++) {
-    let G = J[Y];
-    Q.set(G, M3), M3 += G.length;
+  for (let Y = 0, G = 0;Y < J.length; Y++) {
+    let M3 = J[Y];
+    Q.set(M3, G), G += M3.length;
   }
   return Q;
 }
@@ -2584,7 +2584,7 @@ function X0(J = 32) {
 function IQ(J, $, Q, Y) {
   if (typeof J.setBigUint64 === "function")
     return J.setBigUint64($, Q, Y);
-  let M3 = BigInt(32), G = BigInt(4294967295), Z = Number(Q >> M3 & G), K = Number(Q & G), X = Y ? 4 : 0, q = Y ? 0 : 4;
+  let G = BigInt(32), M3 = BigInt(4294967295), Z = Number(Q >> G & M3), K = Number(Q & M3), X = Y ? 4 : 0, q = Y ? 0 : 4;
   J.setUint32($ + X, Z, Y), J.setUint32($ + q, K, Y);
 }
 function K0(J, $, Q) {
@@ -2594,35 +2594,35 @@ function q0(J, $, Q) {
   return J & $ ^ J & Q ^ $ & Q;
 }
 
-class G8 extends O$ {
+class M8 extends O$ {
   constructor(J, $, Q, Y) {
     super();
     this.finished = false, this.length = 0, this.pos = 0, this.destroyed = false, this.blockLen = J, this.outputLen = $, this.padOffset = Q, this.isLE = Y, this.buffer = new Uint8Array(J), this.view = g$(this.buffer);
   }
   update(J) {
     oJ(this), J = N$(J), xJ(J);
-    let { view: $, buffer: Q, blockLen: Y } = this, M3 = J.length;
-    for (let G = 0;G < M3; ) {
-      let Z = Math.min(Y - this.pos, M3 - G);
+    let { view: $, buffer: Q, blockLen: Y } = this, G = J.length;
+    for (let M3 = 0;M3 < G; ) {
+      let Z = Math.min(Y - this.pos, G - M3);
       if (Z === Y) {
         let K = g$(J);
-        for (;Y <= M3 - G; G += Y)
-          this.process(K, G);
+        for (;Y <= G - M3; M3 += Y)
+          this.process(K, M3);
         continue;
       }
-      if (Q.set(J.subarray(G, G + Z), this.pos), this.pos += Z, G += Z, this.pos === Y)
+      if (Q.set(J.subarray(M3, M3 + Z), this.pos), this.pos += Z, M3 += Z, this.pos === Y)
         this.process($, 0), this.pos = 0;
     }
     return this.length += J.length, this.roundClean(), this;
   }
   digestInto(J) {
-    oJ(this), M0(J, this), this.finished = true;
-    let { buffer: $, view: Q, blockLen: Y, isLE: M3 } = this, { pos: G } = this;
-    if ($[G++] = 128, kJ(this.buffer.subarray(G)), this.padOffset > Y - G)
-      this.process(Q, 0), G = 0;
-    for (let U = G;U < Y; U++)
+    oJ(this), G0(J, this), this.finished = true;
+    let { buffer: $, view: Q, blockLen: Y, isLE: G } = this, { pos: M3 } = this;
+    if ($[M3++] = 128, kJ(this.buffer.subarray(M3)), this.padOffset > Y - M3)
+      this.process(Q, 0), M3 = 0;
+    for (let U = M3;U < Y; U++)
       $[U] = 0;
-    IQ(Q, Y - 8, BigInt(this.length * 8), M3), this.process(Q, 0);
+    IQ(Q, Y - 8, BigInt(this.length * 8), G), this.process(Q, 0);
     let Z = g$(J), K = this.outputLen;
     if (K % 4)
       throw Error("_sha2: outputLen should be aligned to 32bit");
@@ -2630,7 +2630,7 @@ class G8 extends O$ {
     if (X > q.length)
       throw Error("_sha2: outputLen bigger than state");
     for (let U = 0;U < X; U++)
-      Z.setUint32(4 * U, q[U], M3);
+      Z.setUint32(4 * U, q[U], G);
   }
   digest() {
     let { buffer: J, outputLen: $ } = this;
@@ -2640,8 +2640,8 @@ class G8 extends O$ {
   }
   _cloneInto(J) {
     J || (J = new this.constructor), J.set(...this.get());
-    let { blockLen: $, buffer: Q, length: Y, finished: M3, destroyed: G, pos: Z } = this;
-    if (J.destroyed = G, J.finished = M3, J.length = Y, J.pos = Z, Y % $)
+    let { blockLen: $, buffer: Q, length: Y, finished: G, destroyed: M3, pos: Z } = this;
+    if (J.destroyed = M3, J.finished = G, J.length = Y, J.pos = Z, Y % $)
       J.buffer.set(Q);
     return J;
   }
@@ -2651,36 +2651,36 @@ class G8 extends O$ {
 }
 var qJ = Uint32Array.from([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]);
 var HQ = Uint32Array.from([1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, 2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987, 1925078388, 2162078206, 2614888103, 3248222580, 3835390401, 4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, 2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411, 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424, 2428436474, 2756734187, 3204031479, 3329325298]);
-var RJ = new Uint32Array(64);
+var CJ = new Uint32Array(64);
 
-class U0 extends G8 {
+class U0 extends M8 {
   constructor(J = 32) {
     super(64, J, 8, false);
     this.A = qJ[0] | 0, this.B = qJ[1] | 0, this.C = qJ[2] | 0, this.D = qJ[3] | 0, this.E = qJ[4] | 0, this.F = qJ[5] | 0, this.G = qJ[6] | 0, this.H = qJ[7] | 0;
   }
   get() {
-    let { A: J, B: $, C: Q, D: Y, E: M3, F: G, G: Z, H: K } = this;
-    return [J, $, Q, Y, M3, G, Z, K];
+    let { A: J, B: $, C: Q, D: Y, E: G, F: M3, G: Z, H: K } = this;
+    return [J, $, Q, Y, G, M3, Z, K];
   }
-  set(J, $, Q, Y, M3, G, Z, K) {
-    this.A = J | 0, this.B = $ | 0, this.C = Q | 0, this.D = Y | 0, this.E = M3 | 0, this.F = G | 0, this.G = Z | 0, this.H = K | 0;
+  set(J, $, Q, Y, G, M3, Z, K) {
+    this.A = J | 0, this.B = $ | 0, this.C = Q | 0, this.D = Y | 0, this.E = G | 0, this.F = M3 | 0, this.G = Z | 0, this.H = K | 0;
   }
   process(J, $) {
     for (let U = 0;U < 16; U++, $ += 4)
-      RJ[U] = J.getUint32($, false);
+      CJ[U] = J.getUint32($, false);
     for (let U = 16;U < 64; U++) {
-      let D3 = RJ[U - 15], V = RJ[U - 2], O3 = QJ(D3, 7) ^ QJ(D3, 18) ^ D3 >>> 3, L2 = QJ(V, 17) ^ QJ(V, 19) ^ V >>> 10;
-      RJ[U] = L2 + RJ[U - 7] + O3 + RJ[U - 16] | 0;
+      let D3 = CJ[U - 15], V = CJ[U - 2], O3 = QJ(D3, 7) ^ QJ(D3, 18) ^ D3 >>> 3, L2 = QJ(V, 17) ^ QJ(V, 19) ^ V >>> 10;
+      CJ[U] = L2 + CJ[U - 7] + O3 + CJ[U - 16] | 0;
     }
-    let { A: Q, B: Y, C: M3, D: G, E: Z, F: K, G: X, H: q } = this;
+    let { A: Q, B: Y, C: G, D: M3, E: Z, F: K, G: X, H: q } = this;
     for (let U = 0;U < 64; U++) {
-      let D3 = QJ(Z, 6) ^ QJ(Z, 11) ^ QJ(Z, 25), V = q + D3 + K0(Z, K, X) + HQ[U] + RJ[U] | 0, L2 = (QJ(Q, 2) ^ QJ(Q, 13) ^ QJ(Q, 22)) + q0(Q, Y, M3) | 0;
-      q = X, X = K, K = Z, Z = G + V | 0, G = M3, M3 = Y, Y = Q, Q = V + L2 | 0;
+      let D3 = QJ(Z, 6) ^ QJ(Z, 11) ^ QJ(Z, 25), V = q + D3 + K0(Z, K, X) + HQ[U] + CJ[U] | 0, L2 = (QJ(Q, 2) ^ QJ(Q, 13) ^ QJ(Q, 22)) + q0(Q, Y, G) | 0;
+      q = X, X = K, K = Z, Z = M3 + V | 0, M3 = G, G = Y, Y = Q, Q = V + L2 | 0;
     }
-    Q = Q + this.A | 0, Y = Y + this.B | 0, M3 = M3 + this.C | 0, G = G + this.D | 0, Z = Z + this.E | 0, K = K + this.F | 0, X = X + this.G | 0, q = q + this.H | 0, this.set(Q, Y, M3, G, Z, K, X, q);
+    Q = Q + this.A | 0, Y = Y + this.B | 0, G = G + this.C | 0, M3 = M3 + this.D | 0, Z = Z + this.E | 0, K = K + this.F | 0, X = X + this.G | 0, q = q + this.H | 0, this.set(Q, Y, G, M3, Z, K, X, q);
   }
   roundClean() {
-    kJ(RJ);
+    kJ(CJ);
   }
   destroy() {
     this.set(0, 0, 0, 0, 0, 0, 0, 0), kJ(this.buffer);
@@ -2696,14 +2696,14 @@ class Z8 extends O$ {
     if (this.iHash = J.create(), typeof this.iHash.update !== "function")
       throw Error("Expected instance of class which extends utils.Hash");
     this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
-    let Y = this.blockLen, M3 = new Uint8Array(Y);
-    M3.set(Q.length > Y ? J.create().update(Q).digest() : Q);
-    for (let G = 0;G < M3.length; G++)
-      M3[G] ^= 54;
-    this.iHash.update(M3), this.oHash = J.create();
-    for (let G = 0;G < M3.length; G++)
-      M3[G] ^= 106;
-    this.oHash.update(M3), kJ(M3);
+    let Y = this.blockLen, G = new Uint8Array(Y);
+    G.set(Q.length > Y ? J.create().update(Q).digest() : Q);
+    for (let M3 = 0;M3 < G.length; M3++)
+      G[M3] ^= 54;
+    this.iHash.update(G), this.oHash = J.create();
+    for (let M3 = 0;M3 < G.length; M3++)
+      G[M3] ^= 106;
+    this.oHash.update(G), kJ(G);
   }
   update(J) {
     return oJ(this), this.iHash.update(J), this;
@@ -2717,8 +2717,8 @@ class Z8 extends O$ {
   }
   _cloneInto(J) {
     J || (J = Object.create(Object.getPrototypeOf(this), {}));
-    let { oHash: $, iHash: Q, finished: Y, destroyed: M3, blockLen: G, outputLen: Z } = this;
-    return J = J, J.finished = Y, J.destroyed = M3, J.blockLen = G, J.outputLen = Z, J.oHash = $._cloneInto(J.oHash), J.iHash = Q._cloneInto(J.iHash), J;
+    let { oHash: $, iHash: Q, finished: Y, destroyed: G, blockLen: M3, outputLen: Z } = this;
+    return J = J, J.finished = Y, J.destroyed = G, J.blockLen = M3, J.outputLen = Z, J.oHash = $._cloneInto(J.oHash), J.iHash = Q._cloneInto(J.iHash), J;
   }
   clone() {
     return this._cloneInto();
@@ -2743,7 +2743,7 @@ function sJ(J, $) {
   if (typeof $ !== "boolean")
     throw Error(J + " boolean expected, got " + $);
 }
-function C$(J) {
+function R$(J) {
   let $ = J.toString(16);
   return $.length & 1 ? "0" + $ : $;
 }
@@ -2772,7 +2772,7 @@ function j0(J) {
     return J - (UJ.a - 10);
   return;
 }
-function R$(J) {
+function C$(J) {
   if (typeof J !== "string")
     throw Error("hex string expected, got " + typeof J);
   if (V0)
@@ -2781,13 +2781,13 @@ function R$(J) {
   if ($ % 2)
     throw Error("hex string expected, got unpadded hex of length " + $);
   let Y = new Uint8Array(Q);
-  for (let M3 = 0, G = 0;M3 < Q; M3++, G += 2) {
-    let Z = j0(J.charCodeAt(G)), K = j0(J.charCodeAt(G + 1));
+  for (let G = 0, M3 = 0;G < Q; G++, M3 += 2) {
+    let Z = j0(J.charCodeAt(M3)), K = j0(J.charCodeAt(M3 + 1));
     if (Z === undefined || K === undefined) {
-      let X = J[G] + J[G + 1];
-      throw Error('hex string expected, got non-hex character "' + X + '" at index ' + G);
+      let X = J[M3] + J[M3 + 1];
+      throw Error('hex string expected, got non-hex character "' + X + '" at index ' + M3);
     }
-    Y[M3] = Z * 16 + K;
+    Y[G] = Z * 16 + K;
   }
   return Y;
 }
@@ -2798,7 +2798,7 @@ function z8(J) {
   return j8(J), D0(rJ(Uint8Array.from(J).reverse()));
 }
 function bJ(J, $) {
-  return R$(J.toString(16).padStart($ * 2, "0"));
+  return C$(J.toString(16).padStart($ * 2, "0"));
 }
 function D8(J, $) {
   return bJ(J, $).reverse();
@@ -2807,29 +2807,29 @@ function s2(J, $, Q) {
   let Y;
   if (typeof $ === "string")
     try {
-      Y = R$($);
-    } catch (G) {
-      throw Error(J + " must be hex string or Uint8Array, cause: " + G);
+      Y = C$($);
+    } catch (M3) {
+      throw Error(J + " must be hex string or Uint8Array, cause: " + M3);
     }
   else if (aJ($))
     Y = Uint8Array.from($);
   else
     throw Error(J + " must be hex string or Uint8Array");
-  let M3 = Y.length;
-  if (typeof Q === "number" && M3 !== Q)
-    throw Error(J + " of length " + Q + " expected, got " + M3);
+  let G = Y.length;
+  if (typeof Q === "number" && G !== Q)
+    throw Error(J + " of length " + Q + " expected, got " + G);
   return Y;
 }
-function B$(...J) {
+function P$(...J) {
   let $ = 0;
   for (let Y = 0;Y < J.length; Y++) {
-    let M3 = J[Y];
-    j8(M3), $ += M3.length;
+    let G = J[Y];
+    j8(G), $ += G.length;
   }
   let Q = new Uint8Array($);
-  for (let Y = 0, M3 = 0;Y < J.length; Y++) {
-    let G = J[Y];
-    Q.set(G, M3), M3 += G.length;
+  for (let Y = 0, G = 0;Y < J.length; Y++) {
+    let M3 = J[Y];
+    Q.set(M3, G), G += M3.length;
   }
   return Q;
 }
@@ -2857,14 +2857,14 @@ function O0(J, $, Q) {
     throw Error("qByteLen must be a number");
   if (typeof Q !== "function")
     throw Error("hmacFn must be a function");
-  let Y = q8(J), M3 = q8(J), G = 0, Z = () => {
-    Y.fill(1), M3.fill(0), G = 0;
-  }, K = (...D3) => Q(M3, Y, ...D3), X = (D3 = q8(0)) => {
-    if (M3 = K(z0([0]), D3), Y = K(), D3.length === 0)
+  let Y = q8(J), G = q8(J), M3 = 0, Z = () => {
+    Y.fill(1), G.fill(0), M3 = 0;
+  }, K = (...D3) => Q(G, Y, ...D3), X = (D3 = q8(0)) => {
+    if (G = K(z0([0]), D3), Y = K(), D3.length === 0)
       return;
-    M3 = K(z0([1]), D3), Y = K();
+    G = K(z0([1]), D3), Y = K();
   }, q = () => {
-    if (G++ >= 1000)
+    if (M3++ >= 1000)
       throw Error("drbg: tried 1000 values");
     let D3 = 0, V = [];
     while (D3 < $) {
@@ -2872,7 +2872,7 @@ function O0(J, $, Q) {
       let O3 = Y.slice();
       V.push(O3), D3 += Y.length;
     }
-    return B$(...V);
+    return P$(...V);
   };
   return (D3, V) => {
     Z(), X(D3);
@@ -2884,30 +2884,30 @@ function O0(J, $, Q) {
 }
 var _Q = { bigint: (J) => typeof J === "bigint", function: (J) => typeof J === "function", boolean: (J) => typeof J === "boolean", string: (J) => typeof J === "string", stringOrUint8Array: (J) => typeof J === "string" || aJ(J), isSafeInteger: (J) => Number.isSafeInteger(J), array: (J) => Array.isArray(J), field: (J, $) => $.Fp.isValid(J), hash: (J) => typeof J === "function" && Number.isSafeInteger(J.outputLen) };
 function gJ(J, $, Q = {}) {
-  let Y = (M3, G, Z) => {
-    let K = _Q[G];
+  let Y = (G, M3, Z) => {
+    let K = _Q[M3];
     if (typeof K !== "function")
       throw Error("invalid validator function");
-    let X = J[M3];
+    let X = J[G];
     if (Z && X === undefined)
       return;
     if (!K(X, J))
-      throw Error("param " + String(M3) + " is invalid. Expected " + G + ", got " + X);
+      throw Error("param " + String(G) + " is invalid. Expected " + M3 + ", got " + X);
   };
-  for (let [M3, G] of Object.entries($))
-    Y(M3, G, false);
-  for (let [M3, G] of Object.entries(Q))
-    Y(M3, G, true);
+  for (let [G, M3] of Object.entries($))
+    Y(G, M3, false);
+  for (let [G, M3] of Object.entries(Q))
+    Y(G, M3, true);
   return J;
 }
 function V8(J) {
   let $ = new WeakMap;
   return (Q, ...Y) => {
-    let M3 = $.get(Q);
-    if (M3 !== undefined)
-      return M3;
-    let G = J(Q, ...Y);
-    return $.set(Q, G), G;
+    let G = $.get(Q);
+    if (G !== undefined)
+      return G;
+    let M3 = J(Q, ...Y);
+    return $.set(Q, M3), M3;
   };
 }
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
@@ -2915,9 +2915,9 @@ var t2 = BigInt(0);
 var n2 = BigInt(1);
 var vJ = BigInt(2);
 var yQ = BigInt(3);
-var R0 = BigInt(4);
-var B0 = BigInt(5);
-var P0 = BigInt(8);
+var C0 = BigInt(4);
+var P0 = BigInt(5);
+var B0 = BigInt(8);
 function d3(J, $) {
   let Q = J % $;
   return Q >= t2 ? Q : $ + Q;
@@ -2933,23 +2933,23 @@ function u$(J, $) {
     throw Error("invert: expected non-zero number");
   if ($ <= t2)
     throw Error("invert: expected positive modulus, got " + $);
-  let Q = d3(J, $), Y = $, M3 = t2, G = n2, Z = n2, K = t2;
+  let Q = d3(J, $), Y = $, G = t2, M3 = n2, Z = n2, K = t2;
   while (Q !== t2) {
-    let q = Y / Q, U = Y % Q, D3 = M3 - Z * q, V = G - K * q;
-    Y = Q, Q = U, M3 = Z, G = K, Z = D3, K = V;
+    let q = Y / Q, U = Y % Q, D3 = G - Z * q, V = M3 - K * q;
+    Y = Q, Q = U, G = Z, M3 = K, Z = D3, K = V;
   }
   if (Y !== n2)
     throw Error("invert: does not exist");
-  return d3(M3, $);
+  return d3(G, $);
 }
 function L0(J, $) {
-  let Q = (J.ORDER + n2) / R0, Y = J.pow($, Q);
+  let Q = (J.ORDER + n2) / C0, Y = J.pow($, Q);
   if (!J.eql(J.sqr(Y), $))
     throw Error("Cannot find square root");
   return Y;
 }
 function AQ(J, $) {
-  let Q = (J.ORDER - B0) / P0, Y = J.mul($, vJ), M3 = J.pow(Y, Q), G = J.mul($, M3), Z = J.mul(J.mul(G, vJ), M3), K = J.mul(G, J.sub(Z, J.ONE));
+  let Q = (J.ORDER - P0) / B0, Y = J.mul($, vJ), G = J.pow(Y, Q), M3 = J.mul($, G), Z = J.mul(J.mul(M3, vJ), G), K = J.mul(M3, J.sub(Z, J.ONE));
   if (!J.eql(J.sqr(K), $))
     throw Error("Cannot find square root");
   return K;
@@ -2960,19 +2960,19 @@ function wQ(J) {
   let $ = J - n2, Q = 0;
   while ($ % vJ === t2)
     $ /= vJ, Q++;
-  let Y = vJ, M3 = P$(J);
-  while (C0(M3, Y) === 1)
+  let Y = vJ, G = B$(J);
+  while (R0(G, Y) === 1)
     if (Y++ > 1000)
       throw Error("Cannot find square root: probably non-prime P");
   if (Q === 1)
     return L0;
-  let G = M3.pow(Y, $), Z = ($ + n2) / vJ;
+  let M3 = G.pow(Y, $), Z = ($ + n2) / vJ;
   return function(X, q) {
     if (X.is0(q))
       return q;
-    if (C0(X, q) !== 1)
+    if (R0(X, q) !== 1)
       throw Error("Cannot find square root");
-    let U = Q, D3 = X.mul(X.ONE, G), V = X.pow(q, $), O3 = X.pow(q, Z);
+    let U = Q, D3 = X.mul(X.ONE, M3), V = X.pow(q, $), O3 = X.pow(q, Z);
     while (!X.eql(V, X.ONE)) {
       if (X.is0(V))
         return X.ZERO;
@@ -2987,16 +2987,16 @@ function wQ(J) {
   };
 }
 function EQ(J) {
-  if (J % R0 === yQ)
+  if (J % C0 === yQ)
     return L0;
-  if (J % P0 === B0)
+  if (J % B0 === P0)
     return AQ;
   return wQ(J);
 }
 var xQ = ["create", "isValid", "is0", "neg", "inv", "sqrt", "sqr", "eql", "add", "sub", "mul", "pow", "div", "addN", "subN", "mulN", "sqrN"];
 function N8(J) {
-  let $ = { ORDER: "bigint", MASK: "bigint", BYTES: "isSafeInteger", BITS: "isSafeInteger" }, Q = xQ.reduce((Y, M3) => {
-    return Y[M3] = "function", Y;
+  let $ = { ORDER: "bigint", MASK: "bigint", BYTES: "isSafeInteger", BITS: "isSafeInteger" }, Q = xQ.reduce((Y, G) => {
+    return Y[G] = "function", Y;
   }, $);
   return gJ(J, Q);
 }
@@ -3007,45 +3007,45 @@ function kQ(J, $, Q) {
     return J.ONE;
   if (Q === n2)
     return $;
-  let Y = J.ONE, M3 = $;
+  let Y = J.ONE, G = $;
   while (Q > t2) {
     if (Q & n2)
-      Y = J.mul(Y, M3);
-    M3 = J.sqr(M3), Q >>= n2;
+      Y = J.mul(Y, G);
+    G = J.sqr(G), Q >>= n2;
   }
   return Y;
 }
 function O8(J, $, Q = false) {
-  let Y = Array($.length).fill(Q ? J.ZERO : undefined), M3 = $.reduce((Z, K, X) => {
+  let Y = Array($.length).fill(Q ? J.ZERO : undefined), G = $.reduce((Z, K, X) => {
     if (J.is0(K))
       return Z;
     return Y[X] = Z, J.mul(Z, K);
-  }, J.ONE), G = J.inv(M3);
+  }, J.ONE), M3 = J.inv(G);
   return $.reduceRight((Z, K, X) => {
     if (J.is0(K))
       return Z;
     return Y[X] = J.mul(Z, Y[X]), J.mul(Z, K);
-  }, G), Y;
+  }, M3), Y;
 }
-function C0(J, $) {
-  let Q = (J.ORDER - n2) / vJ, Y = J.pow($, Q), M3 = J.eql(Y, J.ONE), G = J.eql(Y, J.ZERO), Z = J.eql(Y, J.neg(J.ONE));
-  if (!M3 && !G && !Z)
+function R0(J, $) {
+  let Q = (J.ORDER - n2) / vJ, Y = J.pow($, Q), G = J.eql(Y, J.ONE), M3 = J.eql(Y, J.ZERO), Z = J.eql(Y, J.neg(J.ONE));
+  if (!G && !M3 && !Z)
     throw Error("invalid Legendre symbol result");
-  return M3 ? 1 : G ? 0 : -1;
+  return G ? 1 : M3 ? 0 : -1;
 }
-function C8(J, $) {
+function R8(J, $) {
   if ($ !== undefined)
     f$($);
   let Q = $ !== undefined ? $ : J.toString(2).length, Y = Math.ceil(Q / 8);
   return { nBitLength: Q, nByteLength: Y };
 }
-function P$(J, $, Q = false, Y = {}) {
+function B$(J, $, Q = false, Y = {}) {
   if (J <= t2)
     throw Error("invalid field: expected ORDER > 0, got " + J);
-  let { nBitLength: M3, nByteLength: G } = C8(J, $);
-  if (G > 2048)
+  let { nBitLength: G, nByteLength: M3 } = R8(J, $);
+  if (M3 > 2048)
     throw Error("invalid field: expected ORDER of <= 2048 bytes");
-  let Z, K = Object.freeze({ ORDER: J, isLE: Q, BITS: M3, BYTES: G, MASK: fJ(M3), ZERO: t2, ONE: n2, create: (X) => d3(X, J), isValid: (X) => {
+  let Z, K = Object.freeze({ ORDER: J, isLE: Q, BITS: G, BYTES: M3, MASK: fJ(G), ZERO: t2, ONE: n2, create: (X) => d3(X, J), isValid: (X) => {
     if (typeof X !== "bigint")
       throw Error("invalid field element: expected bigint, got " + typeof X);
     return t2 <= X && X < J;
@@ -3053,9 +3053,9 @@ function P$(J, $, Q = false, Y = {}) {
     if (!Z)
       Z = EQ(J);
     return Z(K, X);
-  }), toBytes: (X) => Q ? D8(X, G) : bJ(X, G), fromBytes: (X) => {
-    if (X.length !== G)
-      throw Error("Field.fromBytes: expected " + G + " bytes, got " + X.length);
+  }), toBytes: (X) => Q ? D8(X, M3) : bJ(X, M3), fromBytes: (X) => {
+    if (X.length !== M3)
+      throw Error("Field.fromBytes: expected " + M3 + " bytes, got " + X.length);
     return Q ? z8(X) : WJ(X);
   }, invertBatch: (X) => O8(K, X), cmov: (X, q, U) => U ? q : X });
   return Object.freeze(K);
@@ -3066,21 +3066,21 @@ function T0(J) {
   let $ = J.toString(2).length;
   return Math.ceil($ / 8);
 }
-function R8(J) {
+function C8(J) {
   let $ = T0(J);
   return $ + Math.ceil($ / 2);
 }
 function I0(J, $, Q = false) {
-  let Y = J.length, M3 = T0($), G = R8($);
-  if (Y < 16 || Y < G || Y > 1024)
-    throw Error("expected " + G + "-1024 bytes of input, got " + Y);
+  let Y = J.length, G = T0($), M3 = C8($);
+  if (Y < 16 || Y < M3 || Y > 1024)
+    throw Error("expected " + M3 + "-1024 bytes of input, got " + Y);
   let Z = Q ? z8(J) : WJ(J), K = d3(Z, $ - n2) + n2;
-  return Q ? D8(K, M3) : bJ(K, M3);
+  return Q ? D8(K, G) : bJ(K, G);
 }
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 var H0 = BigInt(0);
 var I8 = BigInt(1);
-function B8(J, $) {
+function P8(J, $) {
   let Q = $.negate();
   return J ? Q : $;
 }
@@ -3088,15 +3088,15 @@ function _0(J, $) {
   if (!Number.isSafeInteger(J) || J <= 0 || J > $)
     throw Error("invalid window size, expected [1.." + $ + "], got W=" + J);
 }
-function P8(J, $) {
+function B8(J, $) {
   _0(J, $);
-  let Q = Math.ceil($ / J) + 1, Y = 2 ** (J - 1), M3 = 2 ** J, G = fJ(J), Z = BigInt(J);
-  return { windows: Q, windowSize: Y, mask: G, maxNumber: M3, shiftBy: Z };
+  let Q = Math.ceil($ / J) + 1, Y = 2 ** (J - 1), G = 2 ** J, M3 = fJ(J), Z = BigInt(J);
+  return { windows: Q, windowSize: Y, mask: M3, maxNumber: G, shiftBy: Z };
 }
 function S0(J, $, Q) {
-  let { windowSize: Y, mask: M3, maxNumber: G, shiftBy: Z } = Q, K = Number(J & M3), X = J >> Z;
+  let { windowSize: Y, mask: G, maxNumber: M3, shiftBy: Z } = Q, K = Number(J & G), X = J >> Z;
   if (K > Y)
-    K -= G, X += I8;
+    K -= M3, X += I8;
   let q = $ * Y, U = q + Math.abs(K) - 1, D3 = K === 0, V = K < 0, O3 = $ % 2 !== 0;
   return { nextN: X, offset: U, isZero: D3, isNeg: V, isNegF: O3, offsetF: q };
 }
@@ -3122,74 +3122,74 @@ function T8(J) {
   return y0.get(J) || 1;
 }
 function A0(J, $) {
-  return { constTimeNegate: B8, hasPrecomputes(Q) {
+  return { constTimeNegate: P8, hasPrecomputes(Q) {
     return T8(Q) !== 1;
-  }, unsafeLadder(Q, Y, M3 = J.ZERO) {
-    let G = Q;
+  }, unsafeLadder(Q, Y, G = J.ZERO) {
+    let M3 = Q;
     while (Y > H0) {
       if (Y & I8)
-        M3 = M3.add(G);
-      G = G.double(), Y >>= I8;
+        G = G.add(M3);
+      M3 = M3.double(), Y >>= I8;
     }
-    return M3;
+    return G;
   }, precomputeWindow(Q, Y) {
-    let { windows: M3, windowSize: G } = P8(Y, $), Z = [], K = Q, X = K;
-    for (let q = 0;q < M3; q++) {
+    let { windows: G, windowSize: M3 } = B8(Y, $), Z = [], K = Q, X = K;
+    for (let q = 0;q < G; q++) {
       X = K, Z.push(X);
-      for (let U = 1;U < G; U++)
+      for (let U = 1;U < M3; U++)
         X = X.add(K), Z.push(X);
       K = X.double();
     }
     return Z;
-  }, wNAF(Q, Y, M3) {
-    let { ZERO: G, BASE: Z } = J, K = P8(Q, $);
+  }, wNAF(Q, Y, G) {
+    let { ZERO: M3, BASE: Z } = J, K = B8(Q, $);
     for (let X = 0;X < K.windows; X++) {
-      let { nextN: q, offset: U, isZero: D3, isNeg: V, isNegF: O3, offsetF: L2 } = S0(M3, X, K);
-      if (M3 = q, D3)
-        Z = Z.add(B8(O3, Y[L2]));
+      let { nextN: q, offset: U, isZero: D3, isNeg: V, isNegF: O3, offsetF: L2 } = S0(G, X, K);
+      if (G = q, D3)
+        Z = Z.add(P8(O3, Y[L2]));
       else
-        G = G.add(B8(V, Y[U]));
+        M3 = M3.add(P8(V, Y[U]));
     }
-    return { p: G, f: Z };
-  }, wNAFUnsafe(Q, Y, M3, G = J.ZERO) {
-    let Z = P8(Q, $);
+    return { p: M3, f: Z };
+  }, wNAFUnsafe(Q, Y, G, M3 = J.ZERO) {
+    let Z = B8(Q, $);
     for (let K = 0;K < Z.windows; K++) {
-      if (M3 === H0)
+      if (G === H0)
         break;
-      let { nextN: X, offset: q, isZero: U, isNeg: D3 } = S0(M3, K, Z);
-      if (M3 = X, U)
+      let { nextN: X, offset: q, isZero: U, isNeg: D3 } = S0(G, K, Z);
+      if (G = X, U)
         continue;
       else {
         let V = Y[q];
-        G = G.add(D3 ? V.negate() : V);
+        M3 = M3.add(D3 ? V.negate() : V);
       }
     }
-    return G;
-  }, getPrecomputes(Q, Y, M3) {
-    let G = L8.get(Y);
-    if (!G) {
-      if (G = this.precomputeWindow(Y, Q), Q !== 1)
-        L8.set(Y, M3(G));
+    return M3;
+  }, getPrecomputes(Q, Y, G) {
+    let M3 = L8.get(Y);
+    if (!M3) {
+      if (M3 = this.precomputeWindow(Y, Q), Q !== 1)
+        L8.set(Y, G(M3));
     }
-    return G;
-  }, wNAFCached(Q, Y, M3) {
-    let G = T8(Q);
-    return this.wNAF(G, this.getPrecomputes(G, Q, M3), Y);
-  }, wNAFCachedUnsafe(Q, Y, M3, G) {
+    return M3;
+  }, wNAFCached(Q, Y, G) {
+    let M3 = T8(Q);
+    return this.wNAF(M3, this.getPrecomputes(M3, Q, G), Y);
+  }, wNAFCachedUnsafe(Q, Y, G, M3) {
     let Z = T8(Q);
     if (Z === 1)
-      return this.unsafeLadder(Q, Y, G);
-    return this.wNAFUnsafe(Z, this.getPrecomputes(Z, Q, M3), Y, G);
+      return this.unsafeLadder(Q, Y, M3);
+    return this.wNAFUnsafe(Z, this.getPrecomputes(Z, Q, G), Y, M3);
   }, setWindowSize(Q, Y) {
     _0(Y, $), y0.set(Q, Y), L8.delete(Q);
   } };
 }
 function w0(J, $, Q, Y) {
   bQ(Q, J), FQ(Y, $);
-  let M3 = Q.length, G = Y.length;
-  if (M3 !== G)
+  let G = Q.length, M3 = Y.length;
+  if (G !== M3)
     throw Error("arrays of points and scalars must have equal length");
-  let Z = J.ZERO, K = N0(BigInt(M3)), X = 1;
+  let Z = J.ZERO, K = N0(BigInt(G)), X = 1;
   if (K > 12)
     X = K - 3;
   else if (K > 4)
@@ -3199,7 +3199,7 @@ function w0(J, $, Q, Y) {
   let q = fJ(X), U = Array(Number(q) + 1).fill(Z), D3 = Math.floor(($.BITS - 1) / X) * X, V = Z;
   for (let O3 = D3;O3 >= 0; O3 -= X) {
     U.fill(Z);
-    for (let N2 = 0;N2 < G; N2++) {
+    for (let N2 = 0;N2 < M3; N2++) {
       let b3 = Y[N2], y3 = Number(b3 >> BigInt(O3) & q);
       U[y3] = U[y3].add(Q[N2]);
     }
@@ -3213,7 +3213,7 @@ function w0(J, $, Q, Y) {
   return V;
 }
 function H8(J) {
-  return N8(J.Fp), gJ(J, { n: "bigint", h: "bigint", Gx: "field", Gy: "field" }, { nBitLength: "isSafeInteger", nByteLength: "isSafeInteger" }), Object.freeze({ ...C8(J.n, J.nBitLength), ...J, ...{ p: J.Fp.ORDER } });
+  return N8(J.Fp), gJ(J, { n: "bigint", h: "bigint", Gx: "field", Gy: "field" }, { nBitLength: "isSafeInteger", nByteLength: "isSafeInteger" }), Object.freeze({ ...R8(J.n, J.nBitLength), ...J, ...{ p: J.Fp.ORDER } });
 }
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 function E0(J) {
@@ -3225,9 +3225,9 @@ function E0(J) {
 function fQ(J) {
   let $ = H8(J);
   gJ($, { a: "field", b: "field" }, { allowInfinityPoint: "boolean", allowedPrivateKeyLengths: "array", clearCofactor: "function", fromBytes: "function", isTorsionFree: "function", toBytes: "function", wrapPrivateKey: "boolean" });
-  let { endo: Q, Fp: Y, a: M3 } = $;
+  let { endo: Q, Fp: Y, a: G } = $;
   if (Q) {
-    if (!Y.eql(M3, Y.ZERO))
+    if (!Y.eql(G, Y.ZERO))
       throw Error("invalid endo: CURVE.a must be 0");
     if (typeof Q !== "object" || typeof Q.beta !== "bigint" || typeof Q.splitScalar !== "function")
       throw Error('invalid endo: expected "beta": bigint and "splitScalar": function');
@@ -3246,22 +3246,22 @@ var jJ = { Err: x0, _tlv: { encode: (J, $) => {
     throw new Q("tlv.encode: wrong tag");
   if ($.length & 1)
     throw new Q("tlv.encode: unpadded data");
-  let Y = $.length / 2, M3 = C$(Y);
-  if (M3.length / 2 & 128)
+  let Y = $.length / 2, G = R$(Y);
+  if (G.length / 2 & 128)
     throw new Q("tlv.encode: long form length too big");
-  let G = Y > 127 ? C$(M3.length / 2 | 128) : "";
-  return C$(J) + G + M3 + $;
+  let M3 = Y > 127 ? R$(G.length / 2 | 128) : "";
+  return R$(J) + M3 + G + $;
 }, decode(J, $) {
   let { Err: Q } = jJ, Y = 0;
   if (J < 0 || J > 256)
     throw new Q("tlv.encode: wrong tag");
   if ($.length < 2 || $[Y++] !== J)
     throw new Q("tlv.decode: wrong tlv");
-  let M3 = $[Y++], G = !!(M3 & 128), Z = 0;
-  if (!G)
-    Z = M3;
+  let G = $[Y++], M3 = !!(G & 128), Z = 0;
+  if (!M3)
+    Z = G;
   else {
-    let X = M3 & 127;
+    let X = G & 127;
     if (!X)
       throw new Q("tlv.decode(long): indefinite length not supported");
     if (X > 4)
@@ -3284,7 +3284,7 @@ var jJ = { Err: x0, _tlv: { encode: (J, $) => {
   let { Err: $ } = jJ;
   if (J < zJ)
     throw new $("integer: negative integers are not allowed");
-  let Q = C$(J);
+  let Q = R$(J);
   if (Number.parseInt(Q[0], 16) & 8)
     Q = "00" + Q;
   if (Q.length & 1)
@@ -3298,40 +3298,40 @@ var jJ = { Err: x0, _tlv: { encode: (J, $) => {
     throw new $("invalid signature integer: unnecessary leading zero");
   return WJ(J);
 } }, toSig(J) {
-  let { Err: $, _int: Q, _tlv: Y } = jJ, M3 = s2("signature", J), { v: G, l: Z } = Y.decode(48, M3);
+  let { Err: $, _int: Q, _tlv: Y } = jJ, G = s2("signature", J), { v: M3, l: Z } = Y.decode(48, G);
   if (Z.length)
     throw new $("invalid signature: left bytes after parsing");
-  let { v: K, l: X } = Y.decode(2, G), { v: q, l: U } = Y.decode(2, X);
+  let { v: K, l: X } = Y.decode(2, M3), { v: q, l: U } = Y.decode(2, X);
   if (U.length)
     throw new $("invalid signature: left bytes after parsing");
   return { r: Q.decode(K), s: Q.decode(q) };
 }, hexFromSig(J) {
-  let { _tlv: $, _int: Q } = jJ, Y = $.encode(2, Q.encode(J.r)), M3 = $.encode(2, Q.encode(J.s)), G = Y + M3;
-  return $.encode(48, G);
+  let { _tlv: $, _int: Q } = jJ, Y = $.encode(2, Q.encode(J.r)), G = $.encode(2, Q.encode(J.s)), M3 = Y + G;
+  return $.encode(48, M3);
 } };
 function S8(J, $) {
   return rJ(bJ(J, $));
 }
 var zJ = BigInt(0);
 var h3 = BigInt(1);
-var hG = BigInt(2);
+var hM = BigInt(2);
 var _8 = BigInt(3);
 var gQ = BigInt(4);
 function vQ(J) {
-  let $ = fQ(J), { Fp: Q } = $, Y = P$($.n, $.nBitLength), M3 = $.toBytes || ((W, j, B3) => {
-    let P3 = j.toAffine();
-    return B$(Uint8Array.from([4]), Q.toBytes(P3.x), Q.toBytes(P3.y));
-  }), G = $.fromBytes || ((W) => {
-    let j = W.subarray(1), B3 = Q.fromBytes(j.subarray(0, Q.BYTES)), P3 = Q.fromBytes(j.subarray(Q.BYTES, 2 * Q.BYTES));
-    return { x: B3, y: P3 };
+  let $ = fQ(J), { Fp: Q } = $, Y = B$($.n, $.nBitLength), G = $.toBytes || ((W, j, P3) => {
+    let B3 = j.toAffine();
+    return P$(Uint8Array.from([4]), Q.toBytes(B3.x), Q.toBytes(B3.y));
+  }), M3 = $.fromBytes || ((W) => {
+    let j = W.subarray(1), P3 = Q.fromBytes(j.subarray(0, Q.BYTES)), B3 = Q.fromBytes(j.subarray(Q.BYTES, 2 * Q.BYTES));
+    return { x: P3, y: B3 };
   });
   function Z(W) {
-    let { a: j, b: B3 } = $, P3 = Q.sqr(W), E3 = Q.mul(P3, W);
-    return Q.add(Q.add(E3, Q.mul(W, j)), B3);
+    let { a: j, b: P3 } = $, B3 = Q.sqr(W), E3 = Q.mul(B3, W);
+    return Q.add(Q.add(E3, Q.mul(W, j)), P3);
   }
   function K(W, j) {
-    let B3 = Q.sqr(j), P3 = Z(W);
-    return Q.eql(B3, P3);
+    let P3 = Q.sqr(j), B3 = Z(W);
+    return Q.eql(P3, B3);
   }
   if (!K($.Gx, $.Gy))
     throw Error("bad curve params: generator point");
@@ -3342,21 +3342,21 @@ function vQ(J) {
     return v$(W, h3, $.n);
   }
   function D3(W) {
-    let { allowedPrivateKeyLengths: j, nByteLength: B3, wrapPrivateKey: P3, n: E3 } = $;
+    let { allowedPrivateKeyLengths: j, nByteLength: P3, wrapPrivateKey: B3, n: E3 } = $;
     if (j && typeof W !== "bigint") {
       if (aJ(W))
         W = rJ(W);
       if (typeof W !== "string" || !j.includes(W.length))
         throw Error("invalid private key");
-      W = W.padStart(B3 * 2, "0");
+      W = W.padStart(P3 * 2, "0");
     }
     let x3;
     try {
-      x3 = typeof W === "bigint" ? W : WJ(s2("private key", W, B3));
+      x3 = typeof W === "bigint" ? W : WJ(s2("private key", W, P3));
     } catch (k2) {
-      throw Error("invalid private key, expected hex or " + B3 + " bytes, got " + typeof W);
+      throw Error("invalid private key, expected hex or " + P3 + " bytes, got " + typeof W);
     }
-    if (P3)
+    if (B3)
       x3 = d3(x3, E3);
     return FJ("private key", x3, h3, E3), x3;
   }
@@ -3365,13 +3365,13 @@ function vQ(J) {
       throw Error("ProjectivePoint expected");
   }
   let O3 = V8((W, j) => {
-    let { px: B3, py: P3, pz: E3 } = W;
+    let { px: P3, py: B3, pz: E3 } = W;
     if (Q.eql(E3, Q.ONE))
-      return { x: B3, y: P3 };
+      return { x: P3, y: B3 };
     let x3 = W.is0();
     if (j == null)
       j = x3 ? Q.ONE : Q.inv(E3);
-    let k2 = Q.mul(B3, j), S3 = Q.mul(P3, j), A3 = Q.mul(E3, j);
+    let k2 = Q.mul(P3, j), S3 = Q.mul(B3, j), A3 = Q.mul(E3, j);
     if (x3)
       return { x: Q.ZERO, y: Q.ZERO };
     if (!Q.eql(A3, Q.ONE))
@@ -3383,10 +3383,10 @@ function vQ(J) {
         return;
       throw Error("bad point: ZERO");
     }
-    let { x: j, y: B3 } = W.toAffine();
-    if (!Q.isValid(j) || !Q.isValid(B3))
+    let { x: j, y: P3 } = W.toAffine();
+    if (!Q.isValid(j) || !Q.isValid(P3))
       throw Error("bad point: x or y not FE");
-    if (!K(j, B3))
+    if (!K(j, P3))
       throw Error("bad point: equation left != right");
     if (!W.isTorsionFree())
       throw Error("bad point: not in prime-order subgroup");
@@ -3394,25 +3394,25 @@ function vQ(J) {
   });
 
   class N2 {
-    constructor(W, j, B3) {
+    constructor(W, j, P3) {
       if (W == null || !Q.isValid(W))
         throw Error("x required");
       if (j == null || !Q.isValid(j) || Q.is0(j))
         throw Error("y required");
-      if (B3 == null || !Q.isValid(B3))
+      if (P3 == null || !Q.isValid(P3))
         throw Error("z required");
-      this.px = W, this.py = j, this.pz = B3, Object.freeze(this);
+      this.px = W, this.py = j, this.pz = P3, Object.freeze(this);
     }
     static fromAffine(W) {
-      let { x: j, y: B3 } = W || {};
-      if (!W || !Q.isValid(j) || !Q.isValid(B3))
+      let { x: j, y: P3 } = W || {};
+      if (!W || !Q.isValid(j) || !Q.isValid(P3))
         throw Error("invalid affine point");
       if (W instanceof N2)
         throw Error("projective point not allowed");
-      let P3 = (E3) => Q.eql(E3, Q.ZERO);
-      if (P3(j) && P3(B3))
+      let B3 = (E3) => Q.eql(E3, Q.ZERO);
+      if (B3(j) && B3(P3))
         return N2.ZERO;
-      return new N2(j, B3, Q.ONE);
+      return new N2(j, P3, Q.ONE);
     }
     get x() {
       return this.toAffine().x;
@@ -3421,11 +3421,11 @@ function vQ(J) {
       return this.toAffine().y;
     }
     static normalizeZ(W) {
-      let j = O8(Q, W.map((B3) => B3.pz));
-      return W.map((B3, P3) => B3.toAffine(j[P3])).map(N2.fromAffine);
+      let j = O8(Q, W.map((P3) => P3.pz));
+      return W.map((P3, B3) => P3.toAffine(j[B3])).map(N2.fromAffine);
     }
     static fromHex(W) {
-      let j = N2.fromAffine(G(s2("pointHex", W)));
+      let j = N2.fromAffine(M3(s2("pointHex", W)));
       return j.assertValidity(), j;
     }
     static fromPrivateKey(W) {
@@ -3448,22 +3448,22 @@ function vQ(J) {
     }
     equals(W) {
       V(W);
-      let { px: j, py: B3, pz: P3 } = this, { px: E3, py: x3, pz: k2 } = W, S3 = Q.eql(Q.mul(j, k2), Q.mul(E3, P3)), A3 = Q.eql(Q.mul(B3, k2), Q.mul(x3, P3));
+      let { px: j, py: P3, pz: B3 } = this, { px: E3, py: x3, pz: k2 } = W, S3 = Q.eql(Q.mul(j, k2), Q.mul(E3, B3)), A3 = Q.eql(Q.mul(P3, k2), Q.mul(x3, B3));
       return S3 && A3;
     }
     negate() {
       return new N2(this.px, Q.neg(this.py), this.pz);
     }
     double() {
-      let { a: W, b: j } = $, B3 = Q.mul(j, _8), { px: P3, py: E3, pz: x3 } = this, k2 = Q.ZERO, S3 = Q.ZERO, A3 = Q.ZERO, _2 = Q.mul(P3, P3), l3 = Q.mul(E3, E3), u2 = Q.mul(x3, x3), z = Q.mul(P3, E3);
-      return z = Q.add(z, z), A3 = Q.mul(P3, x3), A3 = Q.add(A3, A3), k2 = Q.mul(W, A3), S3 = Q.mul(B3, u2), S3 = Q.add(k2, S3), k2 = Q.sub(l3, S3), S3 = Q.add(l3, S3), S3 = Q.mul(k2, S3), k2 = Q.mul(z, k2), A3 = Q.mul(B3, A3), u2 = Q.mul(W, u2), z = Q.sub(_2, u2), z = Q.mul(W, z), z = Q.add(z, A3), A3 = Q.add(_2, _2), _2 = Q.add(A3, _2), _2 = Q.add(_2, u2), _2 = Q.mul(_2, z), S3 = Q.add(S3, _2), u2 = Q.mul(E3, x3), u2 = Q.add(u2, u2), _2 = Q.mul(u2, z), k2 = Q.sub(k2, _2), A3 = Q.mul(u2, l3), A3 = Q.add(A3, A3), A3 = Q.add(A3, A3), new N2(k2, S3, A3);
+      let { a: W, b: j } = $, P3 = Q.mul(j, _8), { px: B3, py: E3, pz: x3 } = this, k2 = Q.ZERO, S3 = Q.ZERO, A3 = Q.ZERO, _2 = Q.mul(B3, B3), l3 = Q.mul(E3, E3), u2 = Q.mul(x3, x3), z = Q.mul(B3, E3);
+      return z = Q.add(z, z), A3 = Q.mul(B3, x3), A3 = Q.add(A3, A3), k2 = Q.mul(W, A3), S3 = Q.mul(P3, u2), S3 = Q.add(k2, S3), k2 = Q.sub(l3, S3), S3 = Q.add(l3, S3), S3 = Q.mul(k2, S3), k2 = Q.mul(z, k2), A3 = Q.mul(P3, A3), u2 = Q.mul(W, u2), z = Q.sub(_2, u2), z = Q.mul(W, z), z = Q.add(z, A3), A3 = Q.add(_2, _2), _2 = Q.add(A3, _2), _2 = Q.add(_2, u2), _2 = Q.mul(_2, z), S3 = Q.add(S3, _2), u2 = Q.mul(E3, x3), u2 = Q.add(u2, u2), _2 = Q.mul(u2, z), k2 = Q.sub(k2, _2), A3 = Q.mul(u2, l3), A3 = Q.add(A3, A3), A3 = Q.add(A3, A3), new N2(k2, S3, A3);
     }
     add(W) {
       V(W);
-      let { px: j, py: B3, pz: P3 } = this, { px: E3, py: x3, pz: k2 } = W, S3 = Q.ZERO, A3 = Q.ZERO, _2 = Q.ZERO, l3 = $.a, u2 = Q.mul($.b, _8), z = Q.mul(j, E3), R3 = Q.mul(B3, x3), T3 = Q.mul(P3, k2), F = Q.add(j, B3), I2 = Q.add(E3, x3);
-      F = Q.mul(F, I2), I2 = Q.add(z, R3), F = Q.sub(F, I2), I2 = Q.add(j, P3);
+      let { px: j, py: P3, pz: B3 } = this, { px: E3, py: x3, pz: k2 } = W, S3 = Q.ZERO, A3 = Q.ZERO, _2 = Q.ZERO, l3 = $.a, u2 = Q.mul($.b, _8), z = Q.mul(j, E3), C3 = Q.mul(P3, x3), T3 = Q.mul(B3, k2), F = Q.add(j, P3), I2 = Q.add(E3, x3);
+      F = Q.mul(F, I2), I2 = Q.add(z, C3), F = Q.sub(F, I2), I2 = Q.add(j, B3);
       let w3 = Q.add(E3, k2);
-      return I2 = Q.mul(I2, w3), w3 = Q.add(z, T3), I2 = Q.sub(I2, w3), w3 = Q.add(B3, P3), S3 = Q.add(x3, k2), w3 = Q.mul(w3, S3), S3 = Q.add(R3, T3), w3 = Q.sub(w3, S3), _2 = Q.mul(l3, I2), S3 = Q.mul(u2, T3), _2 = Q.add(S3, _2), S3 = Q.sub(R3, _2), _2 = Q.add(R3, _2), A3 = Q.mul(S3, _2), R3 = Q.add(z, z), R3 = Q.add(R3, z), T3 = Q.mul(l3, T3), I2 = Q.mul(u2, I2), R3 = Q.add(R3, T3), T3 = Q.sub(z, T3), T3 = Q.mul(l3, T3), I2 = Q.add(I2, T3), z = Q.mul(R3, I2), A3 = Q.add(A3, z), z = Q.mul(w3, I2), S3 = Q.mul(F, S3), S3 = Q.sub(S3, z), z = Q.mul(F, R3), _2 = Q.mul(w3, _2), _2 = Q.add(_2, z), new N2(S3, A3, _2);
+      return I2 = Q.mul(I2, w3), w3 = Q.add(z, T3), I2 = Q.sub(I2, w3), w3 = Q.add(P3, B3), S3 = Q.add(x3, k2), w3 = Q.mul(w3, S3), S3 = Q.add(C3, T3), w3 = Q.sub(w3, S3), _2 = Q.mul(l3, I2), S3 = Q.mul(u2, T3), _2 = Q.add(S3, _2), S3 = Q.sub(C3, _2), _2 = Q.add(C3, _2), A3 = Q.mul(S3, _2), C3 = Q.add(z, z), C3 = Q.add(C3, z), T3 = Q.mul(l3, T3), I2 = Q.mul(u2, I2), C3 = Q.add(C3, T3), T3 = Q.sub(z, T3), T3 = Q.mul(l3, T3), I2 = Q.add(I2, T3), z = Q.mul(C3, I2), A3 = Q.add(A3, z), z = Q.mul(w3, I2), S3 = Q.mul(F, S3), S3 = Q.sub(S3, z), z = Q.mul(F, C3), _2 = Q.mul(w3, _2), _2 = Q.add(_2, z), new N2(S3, A3, _2);
     }
     subtract(W) {
       return this.add(W.negate());
@@ -3475,16 +3475,16 @@ function vQ(J) {
       return f3.wNAFCached(this, W, N2.normalizeZ);
     }
     multiplyUnsafe(W) {
-      let { endo: j, n: B3 } = $;
-      FJ("scalar", W, zJ, B3);
-      let P3 = N2.ZERO;
+      let { endo: j, n: P3 } = $;
+      FJ("scalar", W, zJ, P3);
+      let B3 = N2.ZERO;
       if (W === zJ)
-        return P3;
+        return B3;
       if (this.is0() || W === h3)
         return this;
       if (!j || f3.hasPrecomputes(this))
         return f3.wNAFCachedUnsafe(this, W, N2.normalizeZ);
-      let { k1neg: E3, k1: x3, k2neg: k2, k2: S3 } = j.splitScalar(W), A3 = P3, _2 = P3, l3 = this;
+      let { k1neg: E3, k1: x3, k2neg: k2, k2: S3 } = j.splitScalar(W), A3 = B3, _2 = B3, l3 = this;
       while (x3 > zJ || S3 > zJ) {
         if (x3 & h3)
           A3 = A3.add(l3);
@@ -3499,20 +3499,20 @@ function vQ(J) {
       return _2 = new N2(Q.mul(_2.px, j.beta), _2.py, _2.pz), A3.add(_2);
     }
     multiply(W) {
-      let { endo: j, n: B3 } = $;
-      FJ("scalar", W, h3, B3);
-      let P3, E3;
+      let { endo: j, n: P3 } = $;
+      FJ("scalar", W, h3, P3);
+      let B3, E3;
       if (j) {
         let { k1neg: x3, k1: k2, k2neg: S3, k2: A3 } = j.splitScalar(W), { p: _2, f: l3 } = this.wNAF(k2), { p: u2, f: z } = this.wNAF(A3);
-        _2 = f3.constTimeNegate(x3, _2), u2 = f3.constTimeNegate(S3, u2), u2 = new N2(Q.mul(u2.px, j.beta), u2.py, u2.pz), P3 = _2.add(u2), E3 = l3.add(z);
+        _2 = f3.constTimeNegate(x3, _2), u2 = f3.constTimeNegate(S3, u2), u2 = new N2(Q.mul(u2.px, j.beta), u2.py, u2.pz), B3 = _2.add(u2), E3 = l3.add(z);
       } else {
         let { p: x3, f: k2 } = this.wNAF(W);
-        P3 = x3, E3 = k2;
+        B3 = x3, E3 = k2;
       }
-      return N2.normalizeZ([P3, E3])[0];
+      return N2.normalizeZ([B3, E3])[0];
     }
-    multiplyAndAddUnsafe(W, j, B3) {
-      let P3 = N2.BASE, E3 = (k2, S3) => S3 === zJ || S3 === h3 || !k2.equals(P3) ? k2.multiplyUnsafe(S3) : k2.multiply(S3), x3 = E3(this, j).add(E3(W, B3));
+    multiplyAndAddUnsafe(W, j, P3) {
+      let B3 = N2.BASE, E3 = (k2, S3) => S3 === zJ || S3 === h3 || !k2.equals(B3) ? k2.multiplyUnsafe(S3) : k2.multiply(S3), x3 = E3(this, j).add(E3(W, P3));
       return x3.is0() ? undefined : x3;
     }
     toAffine(W) {
@@ -3535,7 +3535,7 @@ function vQ(J) {
       return this.multiplyUnsafe($.h);
     }
     toRawBytes(W = true) {
-      return sJ("isCompressed", W), this.assertValidity(), M3(N2, this, W);
+      return sJ("isCompressed", W), this.assertValidity(), G(N2, this, W);
     }
     toHex(W = true) {
       return sJ("isCompressed", W), rJ(this.toRawBytes(W));
@@ -3550,79 +3550,79 @@ function uQ(J) {
   return gJ($, { hash: "hash", hmac: "function", randomBytes: "function" }, { bits2int: "function", bits2int_modN: "function", lowS: "boolean" }), Object.freeze({ lowS: true, ...$ });
 }
 function k0(J) {
-  let $ = uQ(J), { Fp: Q, n: Y, nByteLength: M3, nBitLength: G } = $, Z = Q.BYTES + 1, K = 2 * Q.BYTES + 1;
+  let $ = uQ(J), { Fp: Q, n: Y, nByteLength: G, nBitLength: M3 } = $, Z = Q.BYTES + 1, K = 2 * Q.BYTES + 1;
   function X(z) {
     return d3(z, Y);
   }
   function q(z) {
     return u$(z, Y);
   }
-  let { ProjectivePoint: U, normPrivateKeyToScalar: D3, weierstrassEquation: V, isWithinCurveOrder: O3 } = vQ({ ...$, toBytes(z, R3, T3) {
-    let F = R3.toAffine(), I2 = Q.toBytes(F.x), w3 = B$;
+  let { ProjectivePoint: U, normPrivateKeyToScalar: D3, weierstrassEquation: V, isWithinCurveOrder: O3 } = vQ({ ...$, toBytes(z, C3, T3) {
+    let F = C3.toAffine(), I2 = Q.toBytes(F.x), w3 = P$;
     if (sJ("isCompressed", T3), T3)
-      return w3(Uint8Array.from([R3.hasEvenY() ? 2 : 3]), I2);
+      return w3(Uint8Array.from([C3.hasEvenY() ? 2 : 3]), I2);
     else
       return w3(Uint8Array.from([4]), I2, Q.toBytes(F.y));
   }, fromBytes(z) {
-    let R3 = z.length, T3 = z[0], F = z.subarray(1);
-    if (R3 === Z && (T3 === 2 || T3 === 3)) {
+    let C3 = z.length, T3 = z[0], F = z.subarray(1);
+    if (C3 === Z && (T3 === 2 || T3 === 3)) {
       let I2 = WJ(F);
       if (!v$(I2, h3, Q.ORDER))
         throw Error("Point is not on curve");
       let w3 = V(I2), $J;
       try {
         $J = Q.sqrt(w3);
-      } catch (MJ) {
-        let a2 = MJ instanceof Error ? ": " + MJ.message : "";
+      } catch (GJ) {
+        let a2 = GJ instanceof Error ? ": " + GJ.message : "";
         throw Error("Point is not on curve" + a2);
       }
       let i2 = ($J & h3) === h3;
       if ((T3 & 1) === 1 !== i2)
         $J = Q.neg($J);
       return { x: I2, y: $J };
-    } else if (R3 === K && T3 === 4) {
+    } else if (C3 === K && T3 === 4) {
       let I2 = Q.fromBytes(F.subarray(0, Q.BYTES)), w3 = Q.fromBytes(F.subarray(Q.BYTES, 2 * Q.BYTES));
       return { x: I2, y: w3 };
     } else {
       let I2 = Z, w3 = K;
-      throw Error("invalid Point, expected length of " + I2 + ", or uncompressed " + w3 + ", got " + R3);
+      throw Error("invalid Point, expected length of " + I2 + ", or uncompressed " + w3 + ", got " + C3);
     }
   } });
   function L2(z) {
-    let R3 = Y >> h3;
-    return z > R3;
+    let C3 = Y >> h3;
+    return z > C3;
   }
   function N2(z) {
     return L2(z) ? X(-z) : z;
   }
-  let b3 = (z, R3, T3) => WJ(z.slice(R3, T3));
+  let b3 = (z, C3, T3) => WJ(z.slice(C3, T3));
 
   class y3 {
-    constructor(z, R3, T3) {
-      if (FJ("r", z, h3, Y), FJ("s", R3, h3, Y), this.r = z, this.s = R3, T3 != null)
+    constructor(z, C3, T3) {
+      if (FJ("r", z, h3, Y), FJ("s", C3, h3, Y), this.r = z, this.s = C3, T3 != null)
         this.recovery = T3;
       Object.freeze(this);
     }
     static fromCompact(z) {
-      let R3 = M3;
-      return z = s2("compactSignature", z, R3 * 2), new y3(b3(z, 0, R3), b3(z, R3, 2 * R3));
+      let C3 = G;
+      return z = s2("compactSignature", z, C3 * 2), new y3(b3(z, 0, C3), b3(z, C3, 2 * C3));
     }
     static fromDER(z) {
-      let { r: R3, s: T3 } = jJ.toSig(s2("DER", z));
-      return new y3(R3, T3);
+      let { r: C3, s: T3 } = jJ.toSig(s2("DER", z));
+      return new y3(C3, T3);
     }
     assertValidity() {}
     addRecoveryBit(z) {
       return new y3(this.r, this.s, z);
     }
     recoverPublicKey(z) {
-      let { r: R3, s: T3, recovery: F } = this, I2 = E3(s2("msgHash", z));
+      let { r: C3, s: T3, recovery: F } = this, I2 = E3(s2("msgHash", z));
       if (F == null || ![0, 1, 2, 3].includes(F))
         throw Error("recovery id invalid");
-      let w3 = F === 2 || F === 3 ? R3 + $.n : R3;
+      let w3 = F === 2 || F === 3 ? C3 + $.n : C3;
       if (w3 >= Q.ORDER)
         throw Error("recovery id 2 or 3 invalid");
-      let $J = (F & 1) === 0 ? "02" : "03", i2 = U.fromHex($J + S8(w3, Q.BYTES)), YJ = q(w3), MJ = X(-I2 * YJ), a2 = X(T3 * YJ), DJ = U.BASE.multiplyAndAddUnsafe(i2, MJ, a2);
+      let $J = (F & 1) === 0 ? "02" : "03", i2 = U.fromHex($J + S8(w3, Q.BYTES)), YJ = q(w3), GJ = X(-I2 * YJ), a2 = X(T3 * YJ), DJ = U.BASE.multiplyAndAddUnsafe(i2, GJ, a2);
       if (!DJ)
         throw Error("point at infinify");
       return DJ.assertValidity(), DJ;
@@ -3634,33 +3634,33 @@ function k0(J) {
       return this.hasHighS() ? new y3(this.r, X(-this.s), this.recovery) : this;
     }
     toDERRawBytes() {
-      return R$(this.toDERHex());
+      return C$(this.toDERHex());
     }
     toDERHex() {
       return jJ.hexFromSig(this);
     }
     toCompactRawBytes() {
-      return R$(this.toCompactHex());
+      return C$(this.toCompactHex());
     }
     toCompactHex() {
-      let z = M3;
+      let z = G;
       return S8(this.r, z) + S8(this.s, z);
     }
   }
   let f3 = { isValidPrivateKey(z) {
     try {
       return D3(z), true;
-    } catch (R3) {
+    } catch (C3) {
       return false;
     }
   }, normPrivateKeyToScalar: D3, randomPrivateKey: () => {
-    let z = R8($.n);
+    let z = C8($.n);
     return I0($.randomBytes(z), $.n);
-  }, precompute(z = 8, R3 = U.BASE) {
-    return R3._setWindowSize(z), R3.multiply(BigInt(3)), R3;
+  }, precompute(z = 8, C3 = U.BASE) {
+    return C3._setWindowSize(z), C3.multiply(BigInt(3)), C3;
   } };
-  function W(z, R3 = true) {
-    return U.fromPrivateKey(z).toRawBytes(R3);
+  function W(z, C3 = true) {
+    return U.fromPrivateKey(z).toRawBytes(C3);
   }
   function j(z) {
     if (typeof z === "bigint")
@@ -3668,51 +3668,51 @@ function k0(J) {
     if (z instanceof U)
       return true;
     let T3 = s2("key", z).length, F = Q.BYTES, I2 = F + 1, w3 = 2 * F + 1;
-    if ($.allowedPrivateKeyLengths || M3 === I2)
+    if ($.allowedPrivateKeyLengths || G === I2)
       return;
     else
       return T3 === I2 || T3 === w3;
   }
-  function B3(z, R3, T3 = true) {
+  function P3(z, C3, T3 = true) {
     if (j(z) === true)
       throw Error("first arg must be private key");
-    if (j(R3) === false)
+    if (j(C3) === false)
       throw Error("second arg must be public key");
-    return U.fromHex(R3).multiply(D3(z)).toRawBytes(T3);
+    return U.fromHex(C3).multiply(D3(z)).toRawBytes(T3);
   }
-  let P3 = $.bits2int || function(z) {
+  let B3 = $.bits2int || function(z) {
     if (z.length > 8192)
       throw Error("input is too large");
-    let R3 = WJ(z), T3 = z.length * 8 - G;
-    return T3 > 0 ? R3 >> BigInt(T3) : R3;
+    let C3 = WJ(z), T3 = z.length * 8 - M3;
+    return T3 > 0 ? C3 >> BigInt(T3) : C3;
   }, E3 = $.bits2int_modN || function(z) {
-    return X(P3(z));
-  }, x3 = fJ(G);
+    return X(B3(z));
+  }, x3 = fJ(M3);
   function k2(z) {
-    return FJ("num < 2^" + G, z, zJ, x3), bJ(z, M3);
+    return FJ("num < 2^" + M3, z, zJ, x3), bJ(z, G);
   }
-  function S3(z, R3, T3 = A3) {
-    if (["recovered", "canonical"].some((PJ) => (PJ in T3)))
+  function S3(z, C3, T3 = A3) {
+    if (["recovered", "canonical"].some((BJ) => (BJ in T3)))
       throw Error("sign() legacy options not supported");
     let { hash: F, randomBytes: I2 } = $, { lowS: w3, prehash: $J, extraEntropy: i2 } = T3;
     if (w3 == null)
       w3 = true;
     if (z = s2("msgHash", z), E0(T3), $J)
       z = s2("prehashed msgHash", F(z));
-    let YJ = E3(z), MJ = D3(R3), a2 = [k2(MJ), k2(YJ)];
+    let YJ = E3(z), GJ = D3(C3), a2 = [k2(GJ), k2(YJ)];
     if (i2 != null && i2 !== false) {
-      let PJ = i2 === true ? I2(Q.BYTES) : i2;
-      a2.push(s2("extraEntropy", PJ));
+      let BJ = i2 === true ? I2(Q.BYTES) : i2;
+      a2.push(s2("extraEntropy", BJ));
     }
-    let DJ = B$(...a2), T$ = YJ;
-    function l$(PJ) {
-      let mJ = P3(PJ);
+    let DJ = P$(...a2), T$ = YJ;
+    function l$(BJ) {
+      let mJ = B3(BJ);
       if (!O3(mJ))
         return;
       let c$ = q(mJ), J$ = U.BASE.multiply(mJ).toAffine(), LJ = X(J$.x);
       if (LJ === zJ)
         return;
-      let $$ = X(c$ * X(T$ + LJ * MJ));
+      let $$ = X(c$ * X(T$ + LJ * GJ));
       if ($$ === zJ)
         return;
       let hJ = (J$.x === LJ ? 0 : 2) | Number(J$.y & h3), F8 = $$;
@@ -3723,25 +3723,25 @@ function k0(J) {
     return { seed: DJ, k2sig: l$ };
   }
   let A3 = { lowS: $.lowS, prehash: false }, _2 = { lowS: $.lowS, prehash: false };
-  function l3(z, R3, T3 = A3) {
-    let { seed: F, k2sig: I2 } = S3(z, R3, T3), w3 = $;
+  function l3(z, C3, T3 = A3) {
+    let { seed: F, k2sig: I2 } = S3(z, C3, T3), w3 = $;
     return O0(w3.hash.outputLen, w3.nByteLength, w3.hmac)(F, I2);
   }
   U.BASE._setWindowSize(8);
-  function u2(z, R3, T3, F = _2) {
+  function u2(z, C3, T3, F = _2) {
     let I2 = z;
-    R3 = s2("msgHash", R3), T3 = s2("publicKey", T3);
+    C3 = s2("msgHash", C3), T3 = s2("publicKey", T3);
     let { lowS: w3, prehash: $J, format: i2 } = F;
     if (E0(F), "strict" in F)
       throw Error("options.strict was renamed to lowS");
     if (i2 !== undefined && i2 !== "compact" && i2 !== "der")
       throw Error("format must be compact or der");
-    let YJ = typeof I2 === "string" || aJ(I2), MJ = !YJ && !i2 && typeof I2 === "object" && I2 !== null && typeof I2.r === "bigint" && typeof I2.s === "bigint";
-    if (!YJ && !MJ)
+    let YJ = typeof I2 === "string" || aJ(I2), GJ = !YJ && !i2 && typeof I2 === "object" && I2 !== null && typeof I2.r === "bigint" && typeof I2.s === "bigint";
+    if (!YJ && !GJ)
       throw Error("invalid signature, expected Uint8Array, hex string or Signature instance");
     let a2 = undefined, DJ;
     try {
-      if (MJ)
+      if (GJ)
         a2 = new y3(I2.r, I2.s);
       if (YJ) {
         try {
@@ -3763,17 +3763,17 @@ function k0(J) {
     if (w3 && a2.hasHighS())
       return false;
     if ($J)
-      R3 = $.hash(R3);
-    let { r: T$, s: l$ } = a2, PJ = E3(R3), mJ = q(l$), c$ = X(PJ * mJ), J$ = X(T$ * mJ), LJ = U.BASE.multiplyAndAddUnsafe(DJ, c$, J$)?.toAffine();
+      C3 = $.hash(C3);
+    let { r: T$, s: l$ } = a2, BJ = E3(C3), mJ = q(l$), c$ = X(BJ * mJ), J$ = X(T$ * mJ), LJ = U.BASE.multiplyAndAddUnsafe(DJ, c$, J$)?.toAffine();
     if (!LJ)
       return false;
     return X(LJ.x) === T$;
   }
-  return { CURVE: $, getPublicKey: W, getSharedSecret: B3, sign: l3, verify: u2, ProjectivePoint: U, Signature: y3, utils: f3 };
+  return { CURVE: $, getPublicKey: W, getSharedSecret: P3, sign: l3, verify: u2, ProjectivePoint: U, Signature: y3, utils: f3 };
 }
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 function mQ(J) {
-  return { hash: J, hmac: ($, ...Q) => X8(J, $, G0(...Q)), randomBytes: X0 };
+  return { hash: J, hmac: ($, ...Q) => X8(J, $, M0(...Q)), randomBytes: X0 };
 }
 function b0(J, $) {
   let Q = (Y) => k0({ ...J, ...mQ(Y) });
@@ -3787,14 +3787,14 @@ var lQ = BigInt(1);
 var y8 = BigInt(2);
 var f0 = (J, $) => (J + $ / y8) / $;
 function cQ(J) {
-  let $ = g0, Q = BigInt(3), Y = BigInt(6), M3 = BigInt(11), G = BigInt(22), Z = BigInt(23), K = BigInt(44), X = BigInt(88), q = J * J * J % $, U = q * q * J % $, D3 = e2(U, Q, $) * U % $, V = e2(D3, Q, $) * U % $, O3 = e2(V, y8, $) * q % $, L2 = e2(O3, M3, $) * O3 % $, N2 = e2(L2, G, $) * L2 % $, b3 = e2(N2, K, $) * N2 % $, y3 = e2(b3, X, $) * b3 % $, f3 = e2(y3, K, $) * N2 % $, W = e2(f3, Q, $) * U % $, j = e2(W, Z, $) * L2 % $, B3 = e2(j, Y, $) * q % $, P3 = e2(B3, y8, $);
-  if (!A8.eql(A8.sqr(P3), J))
+  let $ = g0, Q = BigInt(3), Y = BigInt(6), G = BigInt(11), M3 = BigInt(22), Z = BigInt(23), K = BigInt(44), X = BigInt(88), q = J * J * J % $, U = q * q * J % $, D3 = e2(U, Q, $) * U % $, V = e2(D3, Q, $) * U % $, O3 = e2(V, y8, $) * q % $, L2 = e2(O3, G, $) * O3 % $, N2 = e2(L2, M3, $) * L2 % $, b3 = e2(N2, K, $) * N2 % $, y3 = e2(b3, X, $) * b3 % $, f3 = e2(y3, K, $) * N2 % $, W = e2(f3, Q, $) * U % $, j = e2(W, Z, $) * L2 % $, P3 = e2(j, Y, $) * q % $, B3 = e2(P3, y8, $);
+  if (!A8.eql(A8.sqr(B3), J))
     throw Error("Cannot find square root");
-  return P3;
+  return B3;
 }
-var A8 = P$(g0, undefined, undefined, { sqrt: cQ });
+var A8 = B$(g0, undefined, undefined, { sqrt: cQ });
 var w8 = b0({ a: hQ, b: BigInt(7), Fp: A8, n: F0, Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"), Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"), h: BigInt(1), lowS: true, endo: { beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"), splitScalar: (J) => {
-  let $ = F0, Q = BigInt("0x3086d221a7d46bcde86c90e49284eb15"), Y = -lQ * BigInt("0xe4437ed6010e88286f547fa90abfe4c3"), M3 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), G = Q, Z = BigInt("0x100000000000000000000000000000000"), K = f0(G * J, $), X = f0(-Y * J, $), q = d3(J - K * Q - X * M3, $), U = d3(-K * Y - X * G, $), D3 = q > Z, V = U > Z;
+  let $ = F0, Q = BigInt("0x3086d221a7d46bcde86c90e49284eb15"), Y = -lQ * BigInt("0xe4437ed6010e88286f547fa90abfe4c3"), G = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), M3 = Q, Z = BigInt("0x100000000000000000000000000000000"), K = f0(M3 * J, $), X = f0(-Y * J, $), q = d3(J - K * Q - X * G, $), U = d3(-K * Y - X * M3, $), D3 = q > Z, V = U > Z;
   if (D3)
     q = $ - q;
   if (V)
@@ -3808,7 +3808,7 @@ function m$() {
   return "0x" + Buffer.from(J).toString("hex");
 }
 function eJ(J) {
-  let $ = J.startsWith("0x") ? J.slice(2) : J, Q = Buffer.from($, "hex"), Y = w8.getPublicKey(Q, false), G = cJ(Y.slice(1)).slice(-20), Z = "0x" + Buffer.from(G).toString("hex");
+  let $ = J.startsWith("0x") ? J.slice(2) : J, Q = Buffer.from($, "hex"), Y = w8.getPublicKey(Q, false), M3 = cJ(Y.slice(1)).slice(-20), Z = "0x" + Buffer.from(M3).toString("hex");
   return OJ(Z);
 }
 function h$(J) {
@@ -3861,9 +3861,9 @@ class v2 extends V$ {
   static noProxyInviters(J) {
     return new v2(`No proxy inviters found for ${J}. The inviter must have mutual trust connections with users who are also trusted by the invitation module, and these users must have sufficient balance.`, { code: "INVITATION_NO_PROXY_INVITERS", source: "VALIDATION", context: { inviter: J } });
   }
-  static insufficientBalance(J, $, Q, Y, M3, G) {
+  static insufficientBalance(J, $, Q, Y, G, M3) {
     let Z = Number(Q) / 1000000000000000000, K = Number(Y) / 1000000000000000000;
-    return new v2(`Insufficient balance for ${J} invitation(s). Can only afford ${$} invitation(s). Requested: ${Z.toFixed(6)} CRC, Available: ${K.toFixed(6)} CRC.`, { code: "INVITATION_INSUFFICIENT_BALANCE", source: "VALIDATION", context: { from: M3, to: G, requestedInvites: J, availableInvites: $, requested: Q.toString(), available: Y.toString(), requestedCrc: Z, availableCrc: K } });
+    return new v2(`Insufficient balance for ${J} invitation(s). Can only afford ${$} invitation(s). Requested: ${Z.toFixed(6)} CRC, Available: ${K.toFixed(6)} CRC.`, { code: "INVITATION_INSUFFICIENT_BALANCE", source: "VALIDATION", context: { from: G, to: M3, requestedInvites: J, availableInvites: $, requested: Q.toString(), available: Y.toString(), requestedCrc: Z, availableCrc: K } });
   }
   static inviteeAlreadyRegistered(J, $) {
     return new v2(`Invitee ${$} is already registered as a human in Circles Hub. Cannot invite an already registered user.`, { code: "INVITATION_INVITEE_ALREADY_REGISTERED", source: "VALIDATION", context: { inviter: J, invitee: $ } });
@@ -3884,8 +3884,8 @@ function L$(J) {
 function u0(J) {
   let $ = new Uint8Array(J.length * 2);
   return J.forEach((Q, Y) => {
-    let M3 = Q >> 8, G = Q & 255, Z = 2 * Y;
-    $[Z] = M3, $[Z + 1] = G;
+    let G = Q >> 8, M3 = Q & 255, Z = 2 * Y;
+    $[Z] = G, $[Z + 1] = M3;
   }), L$($);
 }
 function m0(J, $, Q) {
@@ -3893,42 +3893,42 @@ function m0(J, $, Q) {
   J.forEach((Z) => {
     Y.add(Z.from.toLowerCase()), Y.add(Z.to.toLowerCase()), Y.add(Z.tokenOwner.toLowerCase());
   });
-  let M3 = [...Y].sort((Z, K) => {
+  let G = [...Y].sort((Z, K) => {
     let X = BigInt(Z), q = BigInt(K), U = X < q, D3 = X > q;
     return U ? -1 : D3 ? 1 : 0;
-  }), G = {};
-  return M3.forEach((Z, K) => {
-    G[Z] = K;
-  }), { sorted: M3, idx: G };
+  }), M3 = {};
+  return G.forEach((Z, K) => {
+    M3[Z] = K;
+  }), { sorted: G, idx: M3 };
 }
 function pQ(J, $) {
-  let Q = new Set, Y = [], M3 = null;
-  if (J.forEach((G, Z) => {
-    let K = G.from.toLowerCase(), X = G.to.toLowerCase();
+  let Q = new Set, Y = [], G = null;
+  if (J.forEach((M3, Z) => {
+    let K = M3.from.toLowerCase(), X = M3.to.toLowerCase();
     if (K === $ && X === $)
-      M3 = Z;
+      G = Z;
     else if (X === $)
       Y.push(Z);
-  }), M3 !== null)
-    Q.add(M3);
+  }), G !== null)
+    Q.add(G);
   else
-    Y.forEach((G) => Q.add(G));
+    Y.forEach((M3) => Q.add(M3));
   return Q;
 }
 function h0(J, $, Q, Y) {
-  let M3 = J.toLowerCase(), G = $.toLowerCase(), { sorted: Z, idx: K } = m0(Y, M3, G), X = pQ(Y, G), q = Y.map((y3, f3) => {
+  let G = J.toLowerCase(), M3 = $.toLowerCase(), { sorted: Z, idx: K } = m0(Y, G, M3), X = pQ(Y, M3), q = Y.map((y3, f3) => {
     return { streamSinkId: X.has(f3) ? 1 : 0, amount: y3.value };
   });
   if (X.size === 0)
-    throw Error(`No terminal edges detected. Flow must have at least one edge delivering to receiver ${G}`);
-  let U = Array.from(X), D3 = [{ sourceCoordinate: K[M3], flowEdgeIds: U, data: new Uint8Array(0) }], V = [];
+    throw Error(`No terminal edges detected. Flow must have at least one edge delivering to receiver ${M3}`);
+  let U = Array.from(X), D3 = [{ sourceCoordinate: K[G], flowEdgeIds: U, data: new Uint8Array(0) }], V = [];
   Y.forEach((y3) => {
     V.push(K[y3.tokenOwner.toLowerCase()]), V.push(K[y3.from.toLowerCase()]), V.push(K[y3.to.toLowerCase()]);
   });
   let O3 = u0(V), L2 = BigInt(Q), N2 = q.filter((y3) => y3.streamSinkId === 1).reduce((y3, f3) => y3 + BigInt(f3.amount.toString()), BigInt(0));
   if (N2 !== L2)
     throw Error(`Terminal sum ${N2} does not equal expected ${L2}`);
-  return { flowVertices: Z, flowEdges: q, streams: D3, packedCoordinates: O3, sourceCoordinate: K[M3] };
+  return { flowVertices: Z, flowEdges: q, streams: D3, packedCoordinates: O3, sourceCoordinate: K[G] };
 }
 function l0(J, $) {
   let Q = J.streams.map((Y) => ({ sourceCoordinate: Y.sourceCoordinate, flowEdgeIds: Y.flowEdgeIds, data: Y.data instanceof Uint8Array ? L$(Y.data) : Y.data }));
@@ -3937,11 +3937,11 @@ function l0(J, $) {
   return Q;
 }
 async function c0(J, $, Q) {
-  let Y = new Map, M3 = new Set;
+  let Y = new Map, G = new Set;
   return Q.transfers.forEach((K) => {
     if (J.toLowerCase() === K.from.toLowerCase())
-      M3.add(K.tokenOwner.toLowerCase());
-  }), (await new x$($).token.getTokenInfoBatch(Array.from(M3))).forEach((K) => {
+      G.add(K.tokenOwner.toLowerCase());
+  }), (await new x$($).token.getTokenInfoBatch(Array.from(G))).forEach((K) => {
     if (K.isWrapped && !K.isInflationary)
       K.tokenType = "CrcV2_ERC20WrapperDeployed_Demurraged";
     Y.set(K.tokenAddress.toLowerCase(), K);
@@ -3950,19 +3950,19 @@ async function c0(J, $, Q) {
 function p0(J, $) {
   let Q = {};
   return J.transfers.forEach((Y) => {
-    let M3 = $.get(Y.tokenOwner.toLowerCase());
-    if (M3 && M3.tokenType.startsWith("CrcV2_ERC20WrapperDeployed")) {
+    let G = $.get(Y.tokenOwner.toLowerCase());
+    if (G && G.tokenType.startsWith("CrcV2_ERC20WrapperDeployed")) {
       if (!Q[Y.tokenOwner])
-        Q[Y.tokenOwner] = [BigInt(0), M3.tokenType];
+        Q[Y.tokenOwner] = [BigInt(0), G.tokenType];
       Q[Y.tokenOwner][0] += BigInt(Y.value);
     }
   }), Q;
 }
 function d0(J, $) {
   let Q = J.transfers.map((Y) => {
-    let M3 = $.get(Y.tokenOwner.toLowerCase());
-    if (M3 && M3.tokenType.startsWith("CrcV2_ERC20WrapperDeployed"))
-      return { ...Y, tokenOwner: M3.tokenOwner };
+    let G = $.get(Y.tokenOwner.toLowerCase());
+    if (G && G.tokenType.startsWith("CrcV2_ERC20WrapperDeployed"))
+      return { ...Y, tokenOwner: G.tokenOwner };
     return Y;
   });
   return { ...J, transfers: Q };
@@ -3976,8 +3976,8 @@ class JJ extends Y$ {
     return new JJ(`No valid transfer path found from ${J} to ${$}. ${Q || "This could mean there's no trust connection, insufficient balance, or the tokens are not transferable."}`, { code: "TRANSFER_NO_PATH", source: "PATHFINDING", context: { from: J, to: $, reason: Q } });
   }
   static insufficientBalance(J, $, Q, Y) {
-    let M3 = Number(J) / 1000000000000000000, G = Number($) / 1000000000000000000;
-    return new JJ(`Insufficient balance for transfer. Requested: ${M3.toFixed(6)} CRC, Available: ${G.toFixed(6)} CRC.`, { code: "TRANSFER_INSUFFICIENT_BALANCE", source: "VALIDATION", context: { from: Q, to: Y, requested: J.toString(), available: $.toString(), requestedCrc: M3, availableCrc: G } });
+    let G = Number(J) / 1000000000000000000, M3 = Number($) / 1000000000000000000;
+    return new JJ(`Insufficient balance for transfer. Requested: ${G.toFixed(6)} CRC, Available: ${M3.toFixed(6)} CRC.`, { code: "TRANSFER_INSUFFICIENT_BALANCE", source: "VALIDATION", context: { from: Q, to: Y, requested: J.toString(), available: $.toString(), requestedCrc: G, availableCrc: M3 } });
   }
   static wrappedTokensRequired() {
     return new JJ("Insufficient unwrapped token balance for transfer. Your balance contains wrapped tokens (ERC20 wrappers), but useWrappedBalances option is not enabled. Please enable it by passing { useWrappedBalances: true } in the transfer options.", { code: "TRANSFER_WRAPPED_TOKENS_REQUIRED", source: "VALIDATION" });
@@ -4002,37 +4002,37 @@ class uJ {
   balance;
   group;
   constructor(J) {
-    this.config = J, this.hubV2 = new CJ({ address: J.v2HubAddress, rpcUrl: J.circlesRpcUrl }), this.liftERC20 = new k$({ address: J.liftERC20Address, rpcUrl: J.circlesRpcUrl }), this.rpcClient = new VJ(J.circlesRpcUrl), this.pathfinder = new KJ(this.rpcClient), this.balance = new yJ(this.rpcClient), this.group = new wJ(this.rpcClient);
+    this.config = J, this.hubV2 = new RJ({ address: J.v2HubAddress, rpcUrl: J.circlesRpcUrl }), this.liftERC20 = new k$({ address: J.liftERC20Address, rpcUrl: J.circlesRpcUrl }), this.rpcClient = new VJ(J.circlesRpcUrl), this.pathfinder = new KJ(this.rpcClient), this.balance = new yJ(this.rpcClient), this.group = new wJ(this.rpcClient);
   }
-  async buildFlowMatrixTx(J, $, Q, Y, M3 = false) {
-    let G = J.toLowerCase(), Z = $.toLowerCase();
+  async buildFlowMatrixTx(J, $, Q, Y, G = false) {
+    let M3 = J.toLowerCase(), Z = $.toLowerCase();
     if (!Q.transfers || Q.transfers.length === 0)
-      throw JJ.noPathFound(G, Z);
+      throw JJ.noPathFound(M3, Z);
     let K = { ...Q };
-    if (M3 && Y?.toTokens?.length === 1) {
+    if (G && Y?.toTokens?.length === 1) {
       let f3 = Y.toTokens[0].toLowerCase();
       if (Q.maxFlow > 0n)
         K.transfers.push({ from: Z, to: Z, tokenOwner: f3, value: Q.maxFlow });
     }
-    let X = await c0(G, this.config.circlesRpcUrl, K), q = p0(K, X), U = Object.keys(q).length > 0;
+    let X = await c0(M3, this.config.circlesRpcUrl, K), q = p0(K, X), U = Object.keys(q).length > 0;
     if (U && !Y?.useWrappedBalances)
       throw JJ.wrappedTokensRequired();
     let D3 = [], V = [];
     if (U) {
-      let f3 = await this._getTokenBalanceMap(G), W = this._createDemurragedUnwrapCalls(q), { unwrapCalls: j, wrapCalls: B3 } = this._createInflationaryUnwrapAndWrapCalls(q, X, f3);
-      D3 = [...W, ...j], V = B3, K = d0(K, X);
+      let f3 = await this._getTokenBalanceMap(M3), W = this._createDemurragedUnwrapCalls(q), { unwrapCalls: j, wrapCalls: P3 } = this._createInflationaryUnwrapAndWrapCalls(q, X, f3);
+      D3 = [...W, ...j], V = P3, K = d0(K, X);
     }
-    let O3 = h0(G, Z, K.maxFlow, K.transfers), L2 = l0(O3, Y?.txData), N2 = this.hubV2.operateFlowMatrix(O3.flowVertices, O3.flowEdges, L2, O3.packedCoordinates), b3 = false;
+    let O3 = h0(M3, Z, K.maxFlow, K.transfers), L2 = l0(O3, Y?.txData), N2 = this.hubV2.operateFlowMatrix(O3.flowVertices, O3.flowEdges, L2, O3.packedCoordinates), b3 = false;
     try {
-      b3 = await this.hubV2.isApprovedForAll(G, G);
+      b3 = await this.hubV2.isApprovedForAll(M3, M3);
     } catch (f3) {
       console.warn("Failed to check approval status, including approval transaction:", f3);
     }
-    return [...b3 ? [] : [this.hubV2.setApprovalForAll(G, true)], ...D3, N2, ...V];
+    return [...b3 ? [] : [this.hubV2.setApprovalForAll(M3, true)], ...D3, N2, ...V];
   }
-  async constructAdvancedTransfer(J, $, Q, Y, M3 = false) {
-    let G = J.toLowerCase(), Z = $.toLowerCase(), K = BigInt(Q);
-    if (G === Z && Y?.fromTokens?.length === 1 && Y?.toTokens?.length === 1) {
+  async constructAdvancedTransfer(J, $, Q, Y, G = false) {
+    let M3 = J.toLowerCase(), Z = $.toLowerCase(), K = BigInt(Q);
+    if (M3 === Z && Y?.fromTokens?.length === 1 && Y?.toTokens?.length === 1) {
       let O3 = Y.fromTokens[0], L2 = Y.toTokens[0], [N2, b3] = await Promise.all([this.liftERC20.erc20Circles(0, L2), this.liftERC20.erc20Circles(1, L2)]);
       if (O3.toLowerCase() === N2.toLowerCase() && N2 !== IJ) {
         let f3 = new z$({ address: O3, rpcUrl: this.config.circlesRpcUrl }).unwrap(K);
@@ -4043,12 +4043,12 @@ class uJ {
         return [{ to: W.to, data: W.data, value: W.value ?? 0n }];
       }
     }
-    let X = this._truncateToSixDecimals(K), q = await this._getDefaultTokenExcludeList(Z, Y?.excludeFromTokens), { ...U } = Y || {}, D3 = { ...U, ...q ? { excludeFromTokens: q } : {} }, V = await this.pathfinder.findPath({ from: G, to: Z, targetFlow: X, ...D3 });
+    let X = this._truncateToSixDecimals(K), q = await this._getDefaultTokenExcludeList(Z, Y?.excludeFromTokens), { ...U } = Y || {}, D3 = { ...U, ...q ? { excludeFromTokens: q } : {} }, V = await this.pathfinder.findPath({ from: M3, to: Z, targetFlow: X, ...D3 });
     if (!V.transfers || V.transfers.length === 0)
-      throw JJ.noPathFound(G, Z);
+      throw JJ.noPathFound(M3, Z);
     if (V.maxFlow < X)
-      throw JJ.insufficientBalance(X, V.maxFlow, G, Z);
-    return this.buildFlowMatrixTx(G, Z, V, Y, M3);
+      throw JJ.insufficientBalance(X, V.maxFlow, M3, Z);
+    return this.buildFlowMatrixTx(M3, Z, V, Y, G);
   }
   async _getTokenBalanceMap(J) {
     let $ = await this.balance.getTokenBalances(J), Q = new Map;
@@ -4058,8 +4058,8 @@ class uJ {
   }
   _createDemurragedUnwrapCalls(J) {
     let $ = [];
-    for (let [Q, [Y, M3]] of Object.entries(J)) {
-      if (M3 !== "CrcV2_ERC20WrapperDeployed_Demurraged")
+    for (let [Q, [Y, G]] of Object.entries(J)) {
+      if (G !== "CrcV2_ERC20WrapperDeployed_Demurraged")
         continue;
       let Z = new z$({ address: Q, rpcUrl: this.config.circlesRpcUrl }).unwrap(Y);
       $.push({ to: Z.to, data: Z.data, value: Z.value ?? 0n });
@@ -4067,22 +4067,22 @@ class uJ {
     return $;
   }
   _createInflationaryUnwrapAndWrapCalls(J, $, Q) {
-    let Y = [], M3 = [];
-    for (let [G, [Z, K]] of Object.entries(J)) {
+    let Y = [], G = [];
+    for (let [M3, [Z, K]] of Object.entries(J)) {
       if (K !== "CrcV2_ERC20WrapperDeployed_Inflationary")
         continue;
-      let X = $.get(G.toLowerCase()), q = Q.get(G.toLowerCase()) || 0n;
+      let X = $.get(M3.toLowerCase()), q = Q.get(M3.toLowerCase()) || 0n;
       if (q === 0n)
         continue;
-      let D3 = new D$({ address: G, rpcUrl: this.config.circlesRpcUrl }).unwrap(q);
+      let D3 = new D$({ address: M3, rpcUrl: this.config.circlesRpcUrl }).unwrap(q);
       Y.push({ to: D3.to, data: D3.data, value: D3.value ?? 0n });
       let V = X?.tokenOwner, O3 = nJ.attoStaticCirclesToAttoCircles(q) - Z;
       if (O3 > 0n) {
         let L2 = this.hubV2.wrap(V, O3, 1);
-        M3.push({ to: L2.to, data: L2.data, value: L2.value ?? 0n });
+        G.push({ to: L2.to, data: L2.data, value: L2.value ?? 0n });
       }
     }
-    return { unwrapCalls: Y, wrapCalls: M3 };
+    return { unwrapCalls: Y, wrapCalls: G };
   }
   _truncateToSixDecimals(J) {
     let $ = BigInt(1e6), Q = BigInt(10) ** BigInt(18);
@@ -4091,13 +4091,13 @@ class uJ {
   async _getDefaultTokenExcludeList(J, $) {
     let Q = await this.group.findGroups(1, { mintHandlerEquals: J }), Y = new Set;
     if (Q.results.length > 0) {
-      let M3 = Q.results[0];
-      if (Y.add(M3.group.toLowerCase()), M3.erc20WrapperDemurraged)
-        Y.add(M3.erc20WrapperDemurraged.toLowerCase());
-      if (M3.erc20WrapperStatic)
-        Y.add(M3.erc20WrapperStatic.toLowerCase());
+      let G = Q.results[0];
+      if (Y.add(G.group.toLowerCase()), G.erc20WrapperDemurraged)
+        Y.add(G.erc20WrapperDemurraged.toLowerCase());
+      if (G.erc20WrapperStatic)
+        Y.add(G.erc20WrapperStatic.toLowerCase());
     }
-    if ($?.forEach((M3) => Y.add(M3.toLowerCase())), Y.size === 0)
+    if ($?.forEach((G) => Y.add(G.toLowerCase())), Y.size === 0)
       return;
     return Array.from(Y);
   }
@@ -4117,12 +4117,12 @@ class E8 {
   constructor(J) {
     if (!J.referralsServiceUrl)
       throw new v2("referralsServiceUrl is required in config", { code: "INVITATION_MISSING_CONFIG", source: "INVITATIONS", context: { missingField: "referralsServiceUrl" } });
-    this.config = J, this.rpcClient = new VJ(J.circlesRpcUrl), this.pathfinder = new KJ(this.rpcClient), this.trust = new _J(this.rpcClient), this.token = new AJ(this.rpcClient), this.hubV2 = new CJ({ address: J.v2HubAddress, rpcUrl: J.circlesRpcUrl }), this.referralsModule = new iJ({ address: J.referralsModuleAddress, rpcUrl: J.circlesRpcUrl }), this.invitationFarm = new tJ({ address: J.invitationFarmAddress, rpcUrl: J.circlesRpcUrl }), this.invitationModuleContract = new F$({ address: J.invitationModuleAddress, rpcUrl: J.circlesRpcUrl });
+    this.config = J, this.rpcClient = new VJ(J.circlesRpcUrl), this.pathfinder = new KJ(this.rpcClient), this.trust = new _J(this.rpcClient), this.token = new AJ(this.rpcClient), this.hubV2 = new RJ({ address: J.v2HubAddress, rpcUrl: J.circlesRpcUrl }), this.referralsModule = new iJ({ address: J.referralsModuleAddress, rpcUrl: J.circlesRpcUrl }), this.invitationFarm = new tJ({ address: J.invitationFarmAddress, rpcUrl: J.circlesRpcUrl }), this.invitationModuleContract = new F$({ address: J.invitationModuleAddress, rpcUrl: J.circlesRpcUrl });
   }
   async ensureInviterSetup(J) {
-    let $ = J.toLowerCase(), Q = this.config.invitationModuleAddress, Y = [], M3 = new b$({ address: $, rpcUrl: this.config.circlesRpcUrl });
-    if (!await M3.isModuleEnabled(Q))
-      Y.push(M3.enableModule(Q)), Y.push(this.invitationModuleContract.trustInviter($));
+    let $ = J.toLowerCase(), Q = this.config.invitationModuleAddress, Y = [], G = new b$({ address: $, rpcUrl: this.config.circlesRpcUrl });
+    if (!await G.isModuleEnabled(Q))
+      Y.push(G.enableModule(Q)), Y.push(this.invitationModuleContract.trustInviter($));
     else if (!await this.hubV2.isTrusted(Q, $))
       Y.push(this.invitationModuleContract.trustInviter($));
     return Y;
@@ -4140,10 +4140,10 @@ class E8 {
     try {
       let Y = new URL(`${this.config.referralsServiceUrl}/list/${J}`);
       Y.searchParams.set("limit", String($)), Y.searchParams.set("offset", String(Q));
-      let M3 = await fetch(Y.toString(), { method: "GET", headers: { accept: "application/json" } });
-      if (!M3.ok)
-        throw new v2(`HTTP error! status: ${M3.status}`, { code: "INVITATION_HTTP_ERROR", source: "INVITATIONS", context: { status: M3.status, url: Y.toString() } });
-      return await M3.json();
+      let G = await fetch(Y.toString(), { method: "GET", headers: { accept: "application/json" } });
+      if (!G.ok)
+        throw new v2(`HTTP error! status: ${G.status}`, { code: "INVITATION_HTTP_ERROR", source: "INVITATIONS", context: { status: G.status, url: Y.toString() } });
+      return await G.json();
     } catch (Y) {
       if (Y instanceof v2)
         throw Y;
@@ -4152,11 +4152,11 @@ class E8 {
   }
   orderRealInviters(J, $) {
     let Q = $.toLowerCase();
-    return J.sort((Y, M3) => {
-      let G = Y.address.toLowerCase() === Q, Z = M3.address.toLowerCase() === Q;
-      if (G && !Z)
+    return J.sort((Y, G) => {
+      let M3 = Y.address.toLowerCase() === Q, Z = G.address.toLowerCase() === Q;
+      if (M3 && !Z)
         return -1;
-      if (!G && Z)
+      if (!M3 && Z)
         return 1;
       return 0;
     });
@@ -4165,7 +4165,7 @@ class E8 {
     let Q = J.toLowerCase(), Y = $.toLowerCase();
     if (await this.hubV2.isHuman(Y))
       throw v2.inviteeAlreadyRegistered(Q, Y);
-    let G = await this.ensureInviterSetup(Q), Z = await this.getRealInviters(Q), K = [...G];
+    let M3 = await this.ensureInviterSetup(Q), Z = await this.getRealInviters(Q), K = [...M3];
     if (Z.length > 0) {
       console.log("[generateInvite] Using STANDARD PATH (proxy inviters available)");
       let X = Z[0].address, q = await this.findInvitePath(Q, X), U = await this.generateInviteData([Y], false), V = await new uJ(this.config).buildFlowMatrixTx(Q, this.config.invitationModuleAddress, q, { toTokens: [X], useWrappedBalances: true, txData: y$(U) }, true);
@@ -4186,32 +4186,32 @@ class E8 {
     if ($)
       Y = $.toLowerCase();
     else {
-      let G = await this.getRealInviters(Q);
-      if (G.length === 0)
+      let M3 = await this.getRealInviters(Q);
+      if (M3.length === 0)
         throw v2.noPathFound(Q, this.config.invitationModuleAddress);
-      Y = G[0].address;
+      Y = M3[0].address;
     }
-    let M3 = await this.pathfinder.findPath({ from: Q, to: this.config.invitationModuleAddress, targetFlow: m2, toTokens: [Y], useWrappedBalances: true, simulatedTrusts: [{ truster: this.config.invitationModuleAddress, trustee: Q }] });
-    if (!M3.transfers || M3.transfers.length === 0)
+    let G = await this.pathfinder.findPath({ from: Q, to: this.config.invitationModuleAddress, targetFlow: m2, toTokens: [Y], useWrappedBalances: true, simulatedTrusts: [{ truster: this.config.invitationModuleAddress, trustee: Q }] });
+    if (!G.transfers || G.transfers.length === 0)
       throw v2.noPathFound(Q, this.config.invitationModuleAddress);
-    if (M3.maxFlow < m2) {
-      let Z = Number(M3.maxFlow / m2);
-      throw v2.insufficientBalance(1, Z, m2, M3.maxFlow, Q, this.config.invitationModuleAddress);
+    if (G.maxFlow < m2) {
+      let Z = Number(G.maxFlow / m2);
+      throw v2.insufficientBalance(1, Z, m2, G.maxFlow, Q, this.config.invitationModuleAddress);
     }
-    return M3;
+    return G;
   }
   async findFarmInvitePath(J) {
     let $ = J.toLowerCase(), Q = await this.pathfinder.findPath({ from: $, to: HJ, targetFlow: m2, toTokens: [n0], useWrappedBalances: true });
     if (!Q.transfers || Q.transfers.length === 0)
       throw v2.noPathFound($, HJ);
     if (Q.maxFlow < m2) {
-      let M3 = Number(Q.maxFlow / m2);
-      throw v2.insufficientBalance(1, M3, m2, Q.maxFlow, $, HJ);
+      let G = Number(Q.maxFlow / m2);
+      throw v2.insufficientBalance(1, G, m2, Q.maxFlow, $, HJ);
     }
     return Q;
   }
   async getRealInviters(J) {
-    let $ = J.toLowerCase(), [Q, Y, M3, G, Z] = await Promise.all([dJ !== "0x0000000000000000000000000000000000000000" ? this.trust.getTrusts(dJ) : Promise.resolve([]), this.trust.getTrustedBy($), this.trust.getMutualTrusts($), this.trust.getTrusts(this.config.invitationModuleAddress), this.trust.getMutualTrusts(this.config.invitationModuleAddress)]), K = new Set(Q.map((j) => j.objectAvatar.toLowerCase())), X = new Set([...Y.map((j) => j.objectAvatar.toLowerCase()), ...M3.map((j) => j.objectAvatar.toLowerCase())]), q = new Set([...G.map((j) => j.objectAvatar.toLowerCase()), ...Z.map((j) => j.objectAvatar.toLowerCase())]), D3 = [...[...X].filter((j) => q.has(j) && !K.has(j)), $];
+    let $ = J.toLowerCase(), [Q, Y, G, M3, Z] = await Promise.all([dJ !== "0x0000000000000000000000000000000000000000" ? this.trust.getTrusts(dJ) : Promise.resolve([]), this.trust.getTrustedBy($), this.trust.getMutualTrusts($), this.trust.getTrusts(this.config.invitationModuleAddress), this.trust.getMutualTrusts(this.config.invitationModuleAddress)]), K = new Set(Q.map((j) => j.objectAvatar.toLowerCase())), X = new Set([...Y.map((j) => j.objectAvatar.toLowerCase()), ...G.map((j) => j.objectAvatar.toLowerCase())]), q = new Set([...M3.map((j) => j.objectAvatar.toLowerCase()), ...Z.map((j) => j.objectAvatar.toLowerCase())]), D3 = [...[...X].filter((j) => q.has(j) && !K.has(j)), $];
     if (D3.length === 0)
       return [];
     let V = await this.pathfinder.findPath({ from: $, to: this.config.invitationModuleAddress, useWrappedBalances: true, targetFlow: X$, toTokens: D3, simulatedTrusts: [{ truster: this.config.invitationModuleAddress, trustee: $ }] });
@@ -4219,28 +4219,28 @@ class E8 {
       return [];
     let O3 = this.config.invitationModuleAddress.toLowerCase(), L2 = V.transfers.filter((j) => j.to.toLowerCase() === O3), N2 = [...new Set(L2.map((j) => j.tokenOwner.toLowerCase()))], b3 = await this.token.getTokenInfoBatch(N2), y3 = new Map;
     for (let j of b3) {
-      let B3 = j.tokenAddress ?? j.token;
-      if (B3 && j?.tokenOwner)
-        y3.set(B3.toLowerCase(), j.tokenOwner.toLowerCase());
+      let P3 = j.tokenAddress ?? j.token;
+      if (P3 && j?.tokenOwner)
+        y3.set(P3.toLowerCase(), j.tokenOwner.toLowerCase());
     }
     let f3 = new Map;
     for (let j of L2) {
-      let B3 = j.tokenOwner.toLowerCase(), P3 = y3.get(B3) ?? B3;
-      f3.set(P3, (f3.get(P3) ?? 0n) + j.value);
+      let P3 = j.tokenOwner.toLowerCase(), B3 = y3.get(P3) ?? P3;
+      f3.set(B3, (f3.get(B3) ?? 0n) + j.value);
     }
     let W = [];
-    for (let [j, B3] of f3.entries()) {
-      let P3 = Number(B3 / m2);
-      if (P3 >= 1)
-        W.push({ address: j, possibleInvites: P3 });
+    for (let [j, P3] of f3.entries()) {
+      let B3 = Number(P3 / m2);
+      if (B3 >= 1)
+        W.push({ address: j, possibleInvites: B3 });
     }
     return this.orderRealInviters(W, $);
   }
   async generateReferral(J) {
-    let $ = J.toLowerCase(), Q = m$(), Y = eJ(Q), M3 = await this.ensureInviterSetup($), G = await this.getRealInviters($), Z = [...M3];
-    if (G.length > 0) {
+    let $ = J.toLowerCase(), Q = m$(), Y = eJ(Q), G = await this.ensureInviterSetup($), M3 = await this.getRealInviters($), Z = [...G];
+    if (M3.length > 0) {
       console.log("[generateReferral] Using STANDARD PATH (proxy inviters available)");
-      let K = new uJ(this.config), X = await this.generateInviteData([Y], true), q = G[0].address, U = await this.findInvitePath($, q), D3 = await K.buildFlowMatrixTx($, this.config.invitationModuleAddress, U, { toTokens: [q], useWrappedBalances: true, txData: y$(X) }, true);
+      let K = new uJ(this.config), X = await this.generateInviteData([Y], true), q = M3[0].address, U = await this.findInvitePath($, q), D3 = await K.buildFlowMatrixTx($, this.config.invitationModuleAddress, U, { toTokens: [q], useWrappedBalances: true, txData: y$(X) }, true);
       Z.push(...D3);
     } else {
       console.log("[generateReferral] Using FARM FALLBACK PATH (no proxy inviters available)");
@@ -4270,7 +4270,7 @@ class E8 {
     }
   }
   computeAddress(J) {
-    let Q = J.toLowerCase().replace("0x", "").padStart(64, "0"), Y = r$.replace("0x", "") + Q, M3 = h$("0x" + Y), G = "ff", Z = s$.toLowerCase().replace("0x", ""), K = M3.replace("0x", ""), X = e$.replace("0x", ""), q = "ff" + Z + K + X, D3 = "0x" + h$("0x" + q).slice(-40);
+    let Q = J.toLowerCase().replace("0x", "").padStart(64, "0"), Y = r$.replace("0x", "") + Q, G = h$("0x" + Y), M3 = "ff", Z = s$.toLowerCase().replace("0x", ""), K = G.replace("0x", ""), X = e$.replace("0x", ""), q = "ff" + Z + K + X, D3 = "0x" + h$("0x" + q).slice(-40);
     return OJ(D3);
   }
   generateSecrets(J) {
@@ -4288,7 +4288,7 @@ class nQ {
   referralsModule;
   hubV2;
   constructor(J) {
-    this.referralsModuleAddress = J.referralsModuleAddress, this.invitations = new E8(J), this.invitationFarm = new tJ({ address: J.invitationFarmAddress, rpcUrl: J.circlesRpcUrl }), this.referralsModule = new iJ({ address: J.referralsModuleAddress, rpcUrl: J.circlesRpcUrl }), this.hubV2 = new CJ({ address: J.v2HubAddress, rpcUrl: J.circlesRpcUrl });
+    this.referralsModuleAddress = J.referralsModuleAddress, this.invitations = new E8(J), this.invitationFarm = new tJ({ address: J.invitationFarmAddress, rpcUrl: J.circlesRpcUrl }), this.referralsModule = new iJ({ address: J.referralsModuleAddress, rpcUrl: J.circlesRpcUrl }), this.hubV2 = new RJ({ address: J.v2HubAddress, rpcUrl: J.circlesRpcUrl });
   }
   async getQuota(J) {
     return this.invitationFarm.inviterQuota(J);
@@ -4302,19 +4302,19 @@ class nQ {
   async generateReferrals(J, $) {
     if ($ <= 0)
       throw new v2("Count must be greater than 0", { code: "INVITATION_INVALID_COUNT", source: "VALIDATION", context: { count: $ } });
-    let Q = J.toLowerCase(), Y = $ === 1, M3 = await this.simulateClaim(Q, $);
-    if (!M3.length)
+    let Q = J.toLowerCase(), Y = $ === 1, G = await this.simulateClaim(Q, $);
+    if (!G.length)
       throw new v2("No invitation IDs returned from claim", { code: "INVITATION_NO_IDS", source: "INVITATIONS", context: { inviter: Q, count: $ } });
-    let G = this.invitations.generateSecrets($), Z = G.map((U) => U.signer), K = await this.invitationFarm.invitationModule(), X = Y ? this.invitationFarm.claimInvite() : this.invitationFarm.claimInvites(BigInt($)), q = Y ? this.buildReferralTransfer(Q, K, M3[0], Z[0]) : this.buildBatchReferralTransfer(Q, K, M3, Z);
-    return { referrals: G, transactions: [X, q] };
+    let M3 = this.invitations.generateSecrets($), Z = M3.map((U) => U.signer), K = await this.invitationFarm.invitationModule(), X = Y ? this.invitationFarm.claimInvite() : this.invitationFarm.claimInvites(BigInt($)), q = Y ? this.buildReferralTransfer(Q, K, G[0], Z[0]) : this.buildBatchReferralTransfer(Q, K, G, Z);
+    return { referrals: M3, transactions: [X, q] };
   }
   async generateInvites(J, $) {
     if ($.length === 0)
       throw new v2("At least one invitee address must be provided", { code: "INVITATION_INVALID_COUNT", source: "VALIDATION", context: { count: 0 } });
-    let Q = J.toLowerCase(), Y = $.map((U) => U.toLowerCase()), M3 = Y.length, G = M3 === 1, Z = await this.simulateClaim(Q, M3);
+    let Q = J.toLowerCase(), Y = $.map((U) => U.toLowerCase()), G = Y.length, M3 = G === 1, Z = await this.simulateClaim(Q, G);
     if (!Z.length)
-      throw new v2("No invitation IDs returned from claim", { code: "INVITATION_NO_IDS", source: "INVITATIONS", context: { inviter: Q, count: M3 } });
-    let K = await this.invitationFarm.invitationModule(), X = G ? this.invitationFarm.claimInvite() : this.invitationFarm.claimInvites(BigInt(M3)), q = G ? this.buildInviteTransfer(Q, K, Z[0], Y[0]) : this.buildBatchInviteTransfer(Q, K, Z, Y);
+      throw new v2("No invitation IDs returned from claim", { code: "INVITATION_NO_IDS", source: "INVITATIONS", context: { inviter: Q, count: G } });
+    let K = await this.invitationFarm.invitationModule(), X = M3 ? this.invitationFarm.claimInvite() : this.invitationFarm.claimInvites(BigInt(G)), q = M3 ? this.buildInviteTransfer(Q, K, Z[0], Y[0]) : this.buildBatchInviteTransfer(Q, K, Z, Y);
     return { invitees: Y, transactions: [X, q] };
   }
   async listReferrals(J, $ = 10, Q = 0) {
@@ -4326,20 +4326,20 @@ class nQ {
     return this.invitationFarm.read("claimInvites", [BigInt($)], { from: J });
   }
   buildReferralTransfer(J, $, Q, Y) {
-    let M3 = this.referralsModule.createAccount(Y).data, G = r3(["address", "bytes"], [this.referralsModuleAddress, M3]);
-    return this.hubV2.safeTransferFrom(J, $, Q, m2, G);
+    let G = this.referralsModule.createAccount(Y).data, M3 = r3(["address", "bytes"], [this.referralsModuleAddress, G]);
+    return this.hubV2.safeTransferFrom(J, $, Q, m2, M3);
   }
   buildBatchReferralTransfer(J, $, Q, Y) {
-    let M3 = this.referralsModule.createAccounts(Y).data, G = r3(["address", "bytes"], [this.referralsModuleAddress, M3]), Z = Q.map(() => m2);
-    return this.hubV2.safeBatchTransferFrom(J, $, Q, Z, G);
+    let G = this.referralsModule.createAccounts(Y).data, M3 = r3(["address", "bytes"], [this.referralsModuleAddress, G]), Z = Q.map(() => m2);
+    return this.hubV2.safeBatchTransferFrom(J, $, Q, Z, M3);
   }
   buildInviteTransfer(J, $, Q, Y) {
-    let M3 = r3(["address"], [Y]);
-    return this.hubV2.safeTransferFrom(J, $, Q, m2, M3);
+    let G = r3(["address"], [Y]);
+    return this.hubV2.safeTransferFrom(J, $, Q, m2, G);
   }
   buildBatchInviteTransfer(J, $, Q, Y) {
-    let M3 = r3(["address[]"], [Y]), G = Q.map(() => m2);
-    return this.hubV2.safeBatchTransferFrom(J, $, Q, G, M3);
+    let G = r3(["address[]"], [Y]), M3 = Q.map(() => m2);
+    return this.hubV2.safeBatchTransferFrom(J, $, Q, M3, G);
   }
 }
 
@@ -4351,7 +4351,7 @@ class x8 {
     this.address = J.address, this.abi = J.abi, this.rpcUrl = J.rpcUrl;
   }
   async read(J, $, Q) {
-    let Y = TJ({ abi: this.abi, functionName: J, args: $ }), M3 = { to: this.address, data: Y, ...Q?.from && { from: Q.from } }, Z = await (await fetch(this.rpcUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_call", params: [M3, "latest"] }) })).json();
+    let Y = TJ({ abi: this.abi, functionName: J, args: $ }), G = { to: this.address, data: Y, ...Q?.from && { from: Q.from } }, Z = await (await fetch(this.rpcUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_call", params: [G, "latest"] }) })).json();
     if (Z.error)
       throw Error(`RPC Error: ${Z.error.message}`);
     if (!Z.result)
@@ -4380,14 +4380,14 @@ class k8 extends x8 {
   claimAccount(J, $, Q, Y) {
     return { to: this.address, data: this.encodeWrite("claimAccount", [J, $, Q, Y]), value: BigInt(0) };
   }
-  claimAccountWithMetadata(J, $, Q, Y, M3) {
-    return { to: this.address, data: this.encodeWrite("claimAccount", [J, $, Q, Y, M3]), value: BigInt(0) };
+  claimAccountWithMetadata(J, $, Q, Y, G) {
+    return { to: this.address, data: this.encodeWrite("claimAccount", [J, $, Q, Y, G]), value: BigInt(0) };
   }
-  claimAccountWithAffiliateGroup(J, $, Q, Y, M3) {
-    return { to: this.address, data: this.encodeWrite("claimAccount", [J, $, Q, Y, M3]), value: BigInt(0) };
+  claimAccountWithAffiliateGroup(J, $, Q, Y, G) {
+    return { to: this.address, data: this.encodeWrite("claimAccount", [J, $, Q, Y, G]), value: BigInt(0) };
   }
-  claimAccountWithMetadataAndAffiliateGroup(J, $, Q, Y, M3, G) {
-    return { to: this.address, data: this.encodeWrite("claimAccount", [J, $, Q, Y, M3, G]), value: BigInt(0) };
+  claimAccountWithMetadataAndAffiliateGroup(J, $, Q, Y, G, M3) {
+    return { to: this.address, data: this.encodeWrite("claimAccount", [J, $, Q, Y, G, M3]), value: BigInt(0) };
   }
   async accounts(J) {
     let [$, Q] = await this.read("accounts", [J]);
@@ -4466,17 +4466,17 @@ class iQ {
     return $.json();
   }
   async retrieve(J) {
-    let $ = eJ(J), { account: Q, claimed: Y } = await this.referralsModule.accounts($), M3 = await fetch(`${this.getBaseUrl()}/retrieve?key=${encodeURIComponent(J)}`);
-    if (M3.ok || M3.status === 410 || Y) {
-      let Z = await M3.json();
+    let $ = eJ(J), { account: Q, claimed: Y } = await this.referralsModule.accounts($), G = await fetch(`${this.getBaseUrl()}/retrieve?key=${encodeURIComponent(J)}`);
+    if (G.ok || G.status === 410 || Y) {
+      let Z = await G.json();
       if (Q === IJ)
         return { ...Z, error: `Referral not found on-chain for signer ${$}` };
       return Z;
     }
     if (Q === IJ)
       return { error: `Referral not found on-chain for signer ${$}` };
-    let G = await M3.json().catch(() => null);
-    throw o3.retrieveFailed(G?.error || M3.statusText, M3.status);
+    let M3 = await G.json().catch(() => null);
+    throw o3.retrieveFailed(M3?.error || G.statusText, G.status);
   }
   async listMine(J) {
     if (!this.getToken)
@@ -4490,12 +4490,12 @@ class iQ {
       $.set("inSession", String(J.inSession));
     if (J?.status !== undefined)
       $.set("status", J.status);
-    let Q = $.toString() ? `?${$}` : "", Y = await this.getAuthHeaders(), M3 = await fetch(`${this.getBaseUrl()}/my-referrals${Q}`, { headers: Y });
-    if (!M3.ok) {
-      let G = await M3.json();
-      throw o3.listFailed(G.error || M3.statusText);
+    let Q = $.toString() ? `?${$}` : "", Y = await this.getAuthHeaders(), G = await fetch(`${this.getBaseUrl()}/my-referrals${Q}`, { headers: Y });
+    if (!G.ok) {
+      let M3 = await G.json();
+      throw o3.listFailed(M3.error || G.statusText);
     }
-    return M3.json();
+    return G.json();
   }
   async listPublic(J, $) {
     let Q = new URLSearchParams;
@@ -4505,12 +4505,12 @@ class iQ {
       Q.set("offset", String($.offset));
     if ($?.inSession !== undefined)
       Q.set("inSession", String($.inSession));
-    let Y = Q.toString() ? `?${Q}` : "", M3 = await fetch(`${this.getBaseUrl()}/list/${encodeURIComponent(J)}${Y}`);
-    if (!M3.ok) {
-      let G = await M3.json();
-      throw o3.listFailed(G.error || M3.statusText);
+    let Y = Q.toString() ? `?${Q}` : "", G = await fetch(`${this.getBaseUrl()}/list/${encodeURIComponent(J)}${Y}`);
+    if (!G.ok) {
+      let M3 = await G.json();
+      throw o3.listFailed(M3.error || G.statusText);
     }
-    return M3.json();
+    return G.json();
   }
 }
 
@@ -4842,9 +4842,9 @@ for (let J = 0, Z = I2, $ = 1, Y = 0;J < 24; J++) {
       W ^= I2 << (I2 << BigInt(G)) - I2;
   WJ2.push(W);
 }
-var GJ2 = i2(WJ2, true);
-var BJ = GJ2[0];
-var SJ2 = GJ2[1];
+var GJ = i2(WJ2, true);
+var BJ = GJ[0];
+var SJ2 = GJ[1];
 var JJ2 = (J, Z, $) => $ > 32 ? t3(J, Z, $) : n3(J, Z, $);
 var ZJ = (J, Z, $) => $ > 32 ? a2(J, Z, $) : o4(J, Z, $);
 function wJ2(J, Z = 24) {
@@ -4963,7 +4963,7 @@ function KJ2(J) {
     Z += VJ2[J[$]];
   return Z;
 }
-function MJ(J) {
+function MJ2(J) {
   let Z = J.toLowerCase().replace("0x", ""), $ = KJ2(QJ2(new TextEncoder().encode(Z))).slice(2), Y = "0x";
   for (let W = 0;W < Z.length; W++)
     Y += parseInt($[W], 16) >= 8 ? Z[W].toUpperCase() : Z[W];
@@ -4973,7 +4973,7 @@ function V(J) {
   return J.toLowerCase();
 }
 function gJ2(J) {
-  return MJ(J);
+  return MJ2(J);
 }
 function AJ2(J) {
   if (typeof J !== "string")
@@ -5101,7 +5101,7 @@ class N2 {
   }
 }
 
-class R3 {
+class R4 {
   client;
   constructor(J) {
     this.client = J;
@@ -5330,7 +5330,7 @@ class T3 {
   }
 }
 
-class C4 {
+class C3 {
   client;
   constructor(J) {
     this.client = J;
@@ -5533,7 +5533,7 @@ class XJ2 {
   }
   get trust() {
     if (!this._trust)
-      this._trust = new R3(this.client);
+      this._trust = new R4(this.client);
     return this._trust;
   }
   get balance() {
@@ -5553,7 +5553,7 @@ class XJ2 {
   }
   get token() {
     if (!this._token)
-      this._token = new C4(this.client);
+      this._token = new C3(this.client);
     return this._token;
   }
   get invitation() {
@@ -7285,14 +7285,14 @@ var _0x71n = BigInt(113);
 var SHA3_PI = [];
 var SHA3_ROTL = [];
 var _SHA3_IOTA = [];
-for (let round = 0, R4 = _1n, x4 = 1, y4 = 0;round < 24; round++) {
+for (let round = 0, R5 = _1n, x4 = 1, y4 = 0;round < 24; round++) {
   [x4, y4] = [y4, (2 * x4 + 3 * y4) % 5];
   SHA3_PI.push(2 * (5 * y4 + x4));
   SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
   let t4 = _0n;
   for (let j2 = 0;j2 < 7; j2++) {
-    R4 = (R4 << _1n ^ (R4 >> _7n) * _0x71n) % _256n;
-    if (R4 & _2n)
+    R5 = (R5 << _1n ^ (R5 >> _7n) * _0x71n) % _256n;
+    if (R5 & _2n)
       t4 ^= _1n << (_1n << /* @__PURE__ */ BigInt(j2)) - _1n;
   }
   _SHA3_IOTA.push(t4);
@@ -10715,12 +10715,12 @@ class r5 {
 var pt = "0x0000000000000000000000000000000000000000";
 var Es = BigInt(96) * BigInt(1000000000000000000);
 var gs = BigInt("9999999999999999999999999999999999999");
-var R4 = BigInt(4294967295);
+var R5 = BigInt(4294967295);
 var nu = BigInt(32);
 function By(t4, u3 = false) {
   if (u3)
-    return { h: Number(t4 & R4), l: Number(t4 >> nu & R4) };
-  return { h: Number(t4 >> nu & R4) | 0, l: Number(t4 & R4) | 0 };
+    return { h: Number(t4 & R5), l: Number(t4 >> nu & R5) };
+  return { h: Number(t4 >> nu & R5) | 0, l: Number(t4 & R5) | 0 };
 }
 function Zy(t4, u3 = false) {
   let y4 = t4.length, s4 = new Uint32Array(y4), i3 = new Uint32Array(y4);
@@ -11312,8 +11312,8 @@ class Ku {
       throw k3.wrappedTokensRequired();
     let d5 = [], S4 = [];
     if (m4) {
-      let P4 = await this._getTokenBalanceMap(v4), C5 = this._createDemurragedUnwrapCalls(p4), { unwrapCalls: xu, wrapCalls: wu } = this._createInflationaryUnwrapAndWrapCalls(p4, a3, P4);
-      d5 = [...C5, ...xu], S4 = wu, b4 = Bt(b4, a3);
+      let P4 = await this._getTokenBalanceMap(v4), C4 = this._createDemurragedUnwrapCalls(p4), { unwrapCalls: xu, wrapCalls: wu } = this._createInflationaryUnwrapAndWrapCalls(p4, a3, P4);
+      d5 = [...C4, ...xu], S4 = wu, b4 = Bt(b4, a3);
     }
     let h5 = kt(v4, e4, b4.maxFlow, b4.transfers), I3 = Pt(h5, s4?.txData), D4 = this.hubV2.operateFlowMatrix(h5.flowVertices, h5.flowEdges, I3, h5.packedCoordinates), A4 = false;
     try {
@@ -11332,8 +11332,8 @@ class Ku {
         return [{ to: P4.to, data: P4.data, value: P4.value ?? 0n }];
       }
       if (h5.toLowerCase() === A4.toLowerCase() && A4 !== pt) {
-        let x4 = new Q({ address: h5, rpcUrl: this.config.circlesRpcUrl }), P4 = r5.attoCirclesToAttoStaticCircles(b4), C5 = x4.unwrap(P4);
-        return [{ to: C5.to, data: C5.data, value: C5.value ?? 0n }];
+        let x4 = new Q({ address: h5, rpcUrl: this.config.circlesRpcUrl }), P4 = r5.attoCirclesToAttoStaticCircles(b4), C4 = x4.unwrap(P4);
+        return [{ to: C4.to, data: C4.data, value: C4.value ?? 0n }];
       }
     }
     let a3 = this._truncateToSixDecimals(b4), p4 = await this._getDefaultTokenExcludeList(e4, s4?.excludeFromTokens), { ...m4 } = s4 || {}, d5 = { ...m4, ...p4 ? { excludeFromTokens: p4 } : {} }, S4 = await this.pathfinder.findPath({ from: v4, to: e4, targetFlow: a3, ...d5 });