hd-wallet-ui 2.1.3 → 2.2.2

package/dist/client/index.js

@@ -1,21 +1,21 @@
-const lt = Object.freeze({
+const Se = Object.freeze({
   cm: 0.01,
   km: 1e3,
   m: 1,
   mm: 1e-3
-}), ut = Object.freeze({
-  metersPerSourceUnit: lt,
+}), xe = Object.freeze({
+  metersPerSourceUnit: Se,
   quaternionNormTolerance: 1e-6,
   scaleComponentExclusiveMin: 0,
   scaleComponentInclusiveMax: 1e6,
   translationComponentAbsMax: 1e6,
   upAxes: Object.freeze(["X_UP", "Y_UP", "Z_UP"])
-}), ht = Object.freeze({ reviewedTransform: ut, schemaVersion: 1 }), $ = new TextEncoder(), tt = Object.getPrototypeOf(Uint8Array.prototype);
-Object.getOwnPropertyDescriptor(tt, "buffer").get;
-Object.getOwnPropertyDescriptor(tt, "length").get;
+}), Ce = Object.freeze({ reviewedTransform: xe, schemaVersion: 1 }), Y = new TextEncoder(), pe = Object.getPrototypeOf(Uint8Array.prototype);
+Object.getOwnPropertyDescriptor(pe, "buffer").get;
+Object.getOwnPropertyDescriptor(pe, "length").get;
 Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
 typeof SharedArrayBuffer > "u" || Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength").get;
-const k = "sdn-bip32-slip10-purpose-v1", M = "password-scrypt-v2", W = "ed25519-over-sha256-jcs-v1", ft = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u, dt = /^[0-9a-f]{64}$/u, yt = /^sha256:[0-9a-f]{64}$/u, mt = /^[1-9A-HJ-NP-Za-km-z]+$/u, Rt = 131072, pt = [
+const F = "sdn-bip32-slip10-purpose-v1", K = "password-scrypt-v2", ee = "ed25519-over-sha256-jcs-v1", Pe = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u, z = /^[0-9a-f]{64}$/u, Ne = /^sha256:[0-9a-f]{64}$/u, ge = /^[1-9A-HJ-NP-Za-km-z]+$/u, De = 131072, je = [
   "accountFingerprint",
   "accountIndex",
   "accountLabel",
@@ -25,7 +25,7 @@ const k = "sdn-bip32-slip10-purpose-v1", M = "password-scrypt-v2", W = "ed25519-
   "keys",
   "schemaVersion",
   "seedProfile"
-], Et = [
+], ke = [
   "bip32Fingerprint",
   "curve",
   "derivation",
@@ -37,7 +37,7 @@ const k = "sdn-bip32-slip10-purpose-v1", M = "password-scrypt-v2", W = "ed25519-
   "purpose",
   "seedProfile",
   "signatureProfile"
-], bt = [
+], Be = [
   "connectionExpiresAt",
   "event",
   "identity",
@@ -46,200 +46,200 @@ const k = "sdn-bip32-slip10-purpose-v1", M = "password-scrypt-v2", W = "ed25519-
 function u(r) {
   throw new TypeError(r);
 }
-function At(r) {
+function me(r) {
   if (r === null || typeof r != "object" || Array.isArray(r)) return !1;
-  const t = Object.getPrototypeOf(r);
-  return t === Object.prototype || t === null;
-}
-function S(r, t) {
-  typeof r != "string" && u(`${t} must be a string`);
-  for (let e = 0; e < r.length; e += 1) {
-    const i = r.charCodeAt(e);
-    let s = i;
-    if (i >= 55296 && i <= 56319) {
-      const o = r.charCodeAt(e + 1);
-      o >= 56320 && o <= 57343 || u(`${t} contains an unpaired surrogate`), s = 65536 + (i - 55296 << 10) + (o - 56320), e += 1;
-    } else i >= 56320 && i <= 57343 && u(`${t} contains an unpaired surrogate`);
-    ((s & 65535) === 65534 || (s & 65535) === 65535 || s >= 64976 && s <= 65007) && u(`${t} contains a Unicode noncharacter`);
+  const e = Object.getPrototypeOf(r);
+  return e === Object.prototype || e === null;
+}
+function v(r, e) {
+  typeof r != "string" && u(`${e} must be a string`);
+  for (let t = 0; t < r.length; t += 1) {
+    const s = r.charCodeAt(t);
+    let i = s;
+    if (s >= 55296 && s <= 56319) {
+      const o = r.charCodeAt(t + 1);
+      o >= 56320 && o <= 57343 || u(`${e} contains an unpaired surrogate`), i = 65536 + (s - 55296 << 10) + (o - 56320), t += 1;
+    } else s >= 56320 && s <= 57343 && u(`${e} contains an unpaired surrogate`);
+    ((i & 65535) === 65534 || (i & 65535) === 65535 || i >= 64976 && i <= 65007) && u(`${e} contains a Unicode noncharacter`);
   }
   return r;
 }
-function Ot(r) {
-  typeof r != "string" && u("wire JSON must be a string"), $.encode(r).byteLength > Rt && u("wire JSON is too large"), r.charCodeAt(0) === 65279 && u("wire JSON must not contain a BOM");
-  let t = 0, e = 0;
-  const i = () => {
-    for (; t < r.length && /[\u0009\u000a\u000d\u0020]/u.test(r[t]); ) t += 1;
-  }, s = () => {
-    r[t] !== '"' && u("invalid JSON string");
-    const l = t;
-    for (t += 1; t < r.length; ) {
-      const a = r.charCodeAt(t);
-      if (a === 34) {
-        t += 1;
-        let h;
+function $e(r) {
+  typeof r != "string" && u("wire JSON must be a string"), Y.encode(r).byteLength > De && u("wire JSON is too large"), r.charCodeAt(0) === 65279 && u("wire JSON must not contain a BOM");
+  let e = 0, t = 0;
+  const s = () => {
+    for (; e < r.length && /[\u0009\u000a\u000d\u0020]/u.test(r[e]); ) e += 1;
+  }, i = () => {
+    r[e] !== '"' && u("invalid JSON string");
+    const a = e;
+    for (e += 1; e < r.length; ) {
+      const l = r.charCodeAt(e);
+      if (l === 34) {
+        e += 1;
+        let f;
         try {
-          h = JSON.parse(r.slice(l, t));
+          f = JSON.parse(r.slice(a, e));
         } catch {
           u("invalid JSON string");
         }
-        return S(h, "JSON string");
+        return v(f, "JSON string");
       }
-      a < 32 && u("invalid JSON control character"), a === 92 && (t += 1, t >= r.length && u("unterminated JSON escape")), t += 1;
+      l < 32 && u("invalid JSON control character"), l === 92 && (e += 1, e >= r.length && u("unterminated JSON escape")), e += 1;
     }
     u("unterminated JSON string");
-  }, o = (l = 0) => {
-    l > 32 && u("wire JSON nesting is too deep"), e += 1, e > 4096 && u("wire JSON contains too many values"), i();
-    const a = r[t];
-    if (a === '"') return s();
-    if (a === "{") {
-      t += 1;
+  }, o = (a = 0) => {
+    a > 32 && u("wire JSON nesting is too deep"), t += 1, t > 4096 && u("wire JSON contains too many values"), s();
+    const l = r[e];
+    if (l === '"') return i();
+    if (l === "{") {
+      e += 1;
       const d = /* @__PURE__ */ Object.create(null), y = /* @__PURE__ */ new Set();
-      if (i(), r[t] === "}")
-        return t += 1, d;
-      for (; t < r.length; ) {
-        i();
-        const m = s();
-        if (y.has(m) && u(`duplicate JSON field: ${m}`), y.add(m), i(), r[t] !== ":" && u("missing JSON object colon"), t += 1, d[m] = o(l + 1), i(), r[t] === "}")
-          return t += 1, d;
-        r[t] !== "," && u("invalid JSON object separator"), t += 1;
+      if (s(), r[e] === "}")
+        return e += 1, d;
+      for (; e < r.length; ) {
+        s();
+        const m = i();
+        if (y.has(m) && u(`duplicate JSON field: ${m}`), y.add(m), s(), r[e] !== ":" && u("missing JSON object colon"), e += 1, d[m] = o(a + 1), s(), r[e] === "}")
+          return e += 1, d;
+        r[e] !== "," && u("invalid JSON object separator"), e += 1;
       }
       u("unterminated JSON object");
     }
-    if (a === "[") {
-      t += 1;
+    if (l === "[") {
+      e += 1;
       const d = [];
-      if (i(), r[t] === "]")
-        return t += 1, d;
-      for (; t < r.length; ) {
-        if (d.push(o(l + 1)), i(), r[t] === "]")
-          return t += 1, d;
-        r[t] !== "," && u("invalid JSON array separator"), t += 1;
+      if (s(), r[e] === "]")
+        return e += 1, d;
+      for (; e < r.length; ) {
+        if (d.push(o(a + 1)), s(), r[e] === "]")
+          return e += 1, d;
+        r[e] !== "," && u("invalid JSON array separator"), e += 1;
       }
       u("unterminated JSON array");
     }
     for (const [d, y] of [["true", !0], ["false", !1], ["null", null]])
-      if (r.startsWith(d, t))
-        return t += d.length, y;
-    const h = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(r.slice(t));
-    h || u("invalid JSON value"), t += h[0].length;
-    const f = Number(h[0]);
-    return Number.isFinite(f) || u("wire JSON number must be finite"), f;
+      if (r.startsWith(d, e))
+        return e += d.length, y;
+    const f = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(r.slice(e));
+    f || u("invalid JSON value"), e += f[0].length;
+    const h = Number(f[0]);
+    return Number.isFinite(h) || u("wire JSON number must be finite"), h;
   };
-  i();
+  s();
   const n = o();
-  return i(), t !== r.length && u("wire JSON contains trailing bytes"), n;
-}
-function wt(r) {
-  return typeof r == "string" ? Ot(r) : r;
-}
-function vt(r, t) {
-  if (r.byteLength !== t.byteLength) return !1;
-  let e = 0;
-  for (let i = 0; i < r.byteLength; i += 1) e |= r[i] ^ t[i];
-  return e === 0;
-}
-function O(r, t, e) {
-  const i = wt(r);
-  At(i) || u(`${e} must be a JSON object`), Object.getOwnPropertySymbols(i).length !== 0 && u(`${e} has an unknown symbol field`);
-  const s = Object.getOwnPropertyNames(i).sort(), o = [...t].sort(), n = $.encode(s.join("\0")), l = $.encode(o.join("\0"));
-  vt(n, l) || u(`${e} has missing or unknown fields`);
-  for (const a of s) {
-    const h = Object.getOwnPropertyDescriptor(i, a);
-    (!h || !h.enumerable || !("value" in h)) && u(`${e}.${a} must be an enumerable data field`), h.value === void 0 && u(`${e}.${a} must not be undefined`);
+  return s(), e !== r.length && u("wire JSON contains trailing bytes"), n;
+}
+function Ue(r) {
+  return typeof r == "string" ? $e(r) : r;
+}
+function Me(r, e) {
+  if (r.byteLength !== e.byteLength) return !1;
+  let t = 0;
+  for (let s = 0; s < r.byteLength; s += 1) t |= r[s] ^ e[s];
+  return t === 0;
+}
+function R(r, e, t) {
+  const s = Ue(r);
+  me(s) || u(`${t} must be a JSON object`), Object.getOwnPropertySymbols(s).length !== 0 && u(`${t} has an unknown symbol field`);
+  const i = Object.getOwnPropertyNames(s).sort(), o = [...e].sort(), n = Y.encode(i.join("\0")), a = Y.encode(o.join("\0"));
+  Me(n, a) || u(`${t} has missing or unknown fields`);
+  for (const l of i) {
+    const f = Object.getOwnPropertyDescriptor(s, l);
+    (!f || !f.enumerable || !("value" in f)) && u(`${t}.${l} must be an enumerable data field`), f.value === void 0 && u(`${t}.${l} must not be undefined`);
   }
-  return i;
+  return s;
 }
-function Y(r) {
+function S(r) {
   if (!r || typeof r != "object" || Object.isFrozen(r)) return r;
-  for (const t of Object.values(r)) Y(t);
+  for (const e of Object.values(r)) S(e);
   return Object.freeze(r);
 }
-function C(r) {
-  return Y(Object.fromEntries([...r].sort(([t], [e]) => t < e ? -1 : t > e ? 1 : 0)));
+function A(r) {
+  return S(Object.fromEntries([...r].sort(([e], [t]) => e < t ? -1 : e > t ? 1 : 0)));
 }
-function et(r, t, e) {
-  (!Array.isArray(r) || Object.getPrototypeOf(r) !== Array.prototype || r.length !== t) && u(`${e} must be a plain array with exactly ${t} values`);
-  const i = [...Array.from({ length: t }, (o, n) => String(n)), "length"], s = Reflect.ownKeys(r);
-  (s.length !== i.length || s.some((o, n) => o !== i[n])) && u(`${e} must be a dense plain array`);
-  for (let o = 0; o < t; o += 1) {
+function j(r, e, t) {
+  (!Array.isArray(r) || Object.getPrototypeOf(r) !== Array.prototype || r.length !== e) && u(`${t} must be a plain array with exactly ${e} values`);
+  const s = [...Array.from({ length: e }, (o, n) => String(n)), "length"], i = Reflect.ownKeys(r);
+  (i.length !== s.length || i.some((o, n) => o !== s[n])) && u(`${t} must be a dense plain array`);
+  for (let o = 0; o < e; o += 1) {
     const n = Object.getOwnPropertyDescriptor(r, String(o));
-    (!n || !n.enumerable || !("value" in n) || n.value === void 0) && u(`${e} must contain enumerable data values`);
+    (!n || !n.enumerable || !("value" in n) || n.value === void 0) && u(`${t} must contain enumerable data values`);
   }
 }
-function Lt(r) {
-  const t = O(
+function Ve(r) {
+  const e = R(
     r,
     ["reviewedTransform", "schemaVersion"],
     "asset review protocol policy"
   );
-  R(t.schemaVersion, 1, "asset review protocol schemaVersion");
-  const e = O(t.reviewedTransform, [
+  p(e.schemaVersion, 1, "asset review protocol schemaVersion");
+  const t = R(e.reviewedTransform, [
     "metersPerSourceUnit",
     "quaternionNormTolerance",
     "scaleComponentExclusiveMin",
     "scaleComponentInclusiveMax",
     "translationComponentAbsMax",
     "upAxes"
-  ], "asset review transform policy"), i = O(
-    e.metersPerSourceUnit,
+  ], "asset review transform policy"), s = R(
+    t.metersPerSourceUnit,
     ["cm", "km", "m", "mm"],
     "asset review unit policy"
   );
-  for (const [s, o] of Object.entries(i))
-    (typeof o != "number" || !Number.isFinite(o) || o <= 0) && u(`asset review unit policy ${s} must be positive and finite`);
-  for (const [s, o] of [
-    ["quaternionNormTolerance", e.quaternionNormTolerance],
-    ["scaleComponentExclusiveMin", e.scaleComponentExclusiveMin],
-    ["scaleComponentInclusiveMax", e.scaleComponentInclusiveMax],
-    ["translationComponentAbsMax", e.translationComponentAbsMax]
+  for (const [i, o] of Object.entries(s))
+    (typeof o != "number" || !Number.isFinite(o) || o <= 0) && u(`asset review unit policy ${i} must be positive and finite`);
+  for (const [i, o] of [
+    ["quaternionNormTolerance", t.quaternionNormTolerance],
+    ["scaleComponentExclusiveMin", t.scaleComponentExclusiveMin],
+    ["scaleComponentInclusiveMax", t.scaleComponentInclusiveMax],
+    ["translationComponentAbsMax", t.translationComponentAbsMax]
   ])
-    (typeof o != "number" || !Number.isFinite(o)) && u(`asset review transform policy ${s} must be finite`);
-  return (e.quaternionNormTolerance <= 0 || e.scaleComponentInclusiveMax <= e.scaleComponentExclusiveMin || e.translationComponentAbsMax <= 0) && u("asset review transform policy bounds are inconsistent"), et(e.upAxes, 3, "asset review up-axis policy"), e.upAxes.join("\0") !== "X_UP\0Y_UP\0Z_UP" && u("asset review up-axis policy is invalid"), C([
-    ["metersPerSourceUnit", C(Object.entries(i))],
-    ["quaternionNormTolerance", e.quaternionNormTolerance],
-    ["scaleComponentExclusiveMin", e.scaleComponentExclusiveMin],
-    ["scaleComponentInclusiveMax", e.scaleComponentInclusiveMax],
-    ["translationComponentAbsMax", e.translationComponentAbsMax],
-    ["upAxes", Object.freeze(Array.from({ length: 3 }, (s, o) => e.upAxes[o]))]
+    (typeof o != "number" || !Number.isFinite(o)) && u(`asset review transform policy ${i} must be finite`);
+  return (t.quaternionNormTolerance <= 0 || t.scaleComponentInclusiveMax <= t.scaleComponentExclusiveMin || t.translationComponentAbsMax <= 0) && u("asset review transform policy bounds are inconsistent"), j(t.upAxes, 3, "asset review up-axis policy"), t.upAxes.join("\0") !== "X_UP\0Y_UP\0Z_UP" && u("asset review up-axis policy is invalid"), A([
+    ["metersPerSourceUnit", A(Object.entries(s))],
+    ["quaternionNormTolerance", t.quaternionNormTolerance],
+    ["scaleComponentExclusiveMin", t.scaleComponentExclusiveMin],
+    ["scaleComponentInclusiveMax", t.scaleComponentInclusiveMax],
+    ["translationComponentAbsMax", t.translationComponentAbsMax],
+    ["upAxes", Object.freeze(Array.from({ length: 3 }, (i, o) => t.upAxes[o]))]
   ]);
 }
-Lt(ht);
-function R(r, t, e) {
-  return r !== t && u(`${e} must equal ${JSON.stringify(t)}`), r;
+Ve(Ce);
+function p(r, e, t) {
+  return r !== e && u(`${t} must equal ${JSON.stringify(e)}`), r;
 }
-function _t(r, t, e) {
-  return t.includes(r) || u(`${e} is not an allowed value`), r;
+function Ye(r, e, t) {
+  return e.includes(r) || u(`${t} is not an allowed value`), r;
 }
-function U(r, t, e) {
-  return S(r, e), t.test(r) || u(`${e} has an invalid encoding`), r;
+function T(r, e, t) {
+  return v(r, t), e.test(r) || u(`${t} has an invalid encoding`), r;
 }
-function It(r, t) {
-  return S(r, t), (!ft.test(r) || new Date(r).toISOString() !== r) && u(`${t} must be exact RFC3339 milliseconds UTC`), r;
+function Fe(r, e) {
+  return v(r, e), (!Pe.test(r) || new Date(r).toISOString() !== r) && u(`${e} must be exact RFC3339 milliseconds UTC`), r;
 }
-function Tt(r, t) {
-  const e = O(r, Et, `identity key ${t.purpose}`);
-  return R(e.purpose, t.purpose, "key purpose"), R(e.identityScheme, k, "key identityScheme"), R(e.seedProfile, M, "key seedProfile"), R(e.signatureProfile, t.signatureProfile, "key signatureProfile"), R(e.curve, t.curve, "key curve"), R(e.derivation, "slip10", "key derivation"), R(e.path, t.path, "key path"), R(e.encoding, "raw", "key encoding"), U(e.publicKeyHex, dt, "key publicKeyHex"), R(e.bip32Fingerprint, null, "key bip32Fingerprint"), U(e.keyId, yt, "key keyId"), C([
+function Ke(r, e) {
+  const t = R(r, ke, `identity key ${e.purpose}`);
+  return p(t.purpose, e.purpose, "key purpose"), p(t.identityScheme, F, "key identityScheme"), p(t.seedProfile, K, "key seedProfile"), p(t.signatureProfile, e.signatureProfile, "key signatureProfile"), p(t.curve, e.curve, "key curve"), p(t.derivation, "slip10", "key derivation"), p(t.path, e.path, "key path"), p(t.encoding, "raw", "key encoding"), T(t.publicKeyHex, z, "key publicKeyHex"), p(t.bip32Fingerprint, null, "key bip32Fingerprint"), T(t.keyId, Ne, "key keyId"), A([
     ["bip32Fingerprint", null],
-    ["curve", e.curve],
+    ["curve", t.curve],
     ["derivation", "slip10"],
     ["encoding", "raw"],
-    ["identityScheme", k],
-    ["keyId", e.keyId],
-    ["path", e.path],
-    ["publicKeyHex", e.publicKeyHex],
-    ["purpose", e.purpose],
-    ["seedProfile", M],
-    ["signatureProfile", e.signatureProfile]
+    ["identityScheme", F],
+    ["keyId", t.keyId],
+    ["path", t.path],
+    ["publicKeyHex", t.publicKeyHex],
+    ["purpose", t.purpose],
+    ["seedProfile", K],
+    ["signatureProfile", t.signatureProfile]
   ]);
 }
-function St(r) {
-  const t = O(r, pt, "WalletPublicIdentity");
-  R(t.schemaVersion, 1, "identity schemaVersion"), R(t.identityScheme, k, "identity identityScheme"), R(t.seedProfile, M, "identity seedProfile"), t.accountIndex !== 0 && u("public wallet identity must use account 0"), R(t.accountLabel, null, "identity accountLabel"), S(t.accountXpub, "identity accountXpub"), /^xpub[1-9A-HJ-NP-Za-km-z]{107}$/u.test(t.accountXpub) || u("identity accountXpub is invalid"), S(t.accountPeerId, "identity accountPeerId"), (!t.accountPeerId.startsWith("16Uiu2H") || t.accountPeerId.length < 40 || t.accountPeerId.length > 64 || !mt.test(t.accountPeerId)) && u("identity accountPeerId is invalid"), U(t.accountFingerprint, /^[0-9a-f]{8}$/u, "identity accountFingerprint"), et(t.keys, 3, "public identity keys array");
-  const e = [
+function qe(r) {
+  const e = R(r, je, "WalletPublicIdentity");
+  p(e.schemaVersion, 1, "identity schemaVersion"), p(e.identityScheme, F, "identity identityScheme"), p(e.seedProfile, K, "identity seedProfile"), e.accountIndex !== 0 && u("public wallet identity must use account 0"), p(e.accountLabel, null, "identity accountLabel"), v(e.accountXpub, "identity accountXpub"), /^xpub[1-9A-HJ-NP-Za-km-z]{107}$/u.test(e.accountXpub) || u("identity accountXpub is invalid"), v(e.accountPeerId, "identity accountPeerId"), (!e.accountPeerId.startsWith("16Uiu2H") || e.accountPeerId.length < 40 || e.accountPeerId.length > 64 || !ge.test(e.accountPeerId)) && u("identity accountPeerId is invalid"), T(e.accountFingerprint, /^[0-9a-f]{8}$/u, "identity accountFingerprint"), j(e.keys, 3, "public identity keys array");
+  const t = [
     {
       purpose: "asset-review-approval",
       curve: "ed25519",
-      signatureProfile: W,
+      signatureProfile: ee,
       path: "m/44'/0'/0'/2'/0'"
     },
     {
@@ -251,52 +251,204 @@ function St(r) {
     {
       purpose: "sdn-authentication",
       curve: "ed25519",
-      signatureProfile: W,
+      signatureProfile: ee,
       path: "m/44'/0'/0'/0'/0'"
     }
-  ], i = Array.from(
+  ], s = Array.from(
     { length: 3 },
-    (s, o) => Tt(t.keys[o], e[o])
+    (i, o) => Ke(e.keys[o], t[o])
   );
-  return C([
-    ["accountFingerprint", t.accountFingerprint],
+  return A([
+    ["accountFingerprint", e.accountFingerprint],
     ["accountIndex", 0],
     ["accountLabel", null],
-    ["accountPeerId", t.accountPeerId],
-    ["accountXpub", t.accountXpub],
-    ["identityScheme", k],
-    ["keys", Y(i)],
+    ["accountPeerId", e.accountPeerId],
+    ["accountXpub", e.accountXpub],
+    ["identityScheme", F],
+    ["keys", S(s)],
     ["schemaVersion", 1],
-    ["seedProfile", M]
+    ["seedProfile", K]
+  ]);
+}
+function Re(r, e) {
+  const t = R(r, Be, `${e} result`);
+  p(t.schemaVersion, 1, "connection result schemaVersion"), Ye(t.event, ["connected", "disconnected"], "connection event"), e === "connect" && t.event !== "connected" && u("connect result must be connected");
+  let s = null, i = null;
+  return t.event === "connected" ? (s = qe(t.identity), i = Fe(t.connectionExpiresAt, "connectionExpiresAt")) : (t.identity !== null || t.connectionExpiresAt !== null) && u("disconnected result must clear identity and expiry"), A([
+    ["connectionExpiresAt", i],
+    ["event", t.event],
+    ["identity", s],
+    ["schemaVersion", 1]
+  ]);
+}
+function Ee(r, e) {
+  return R(r, [], e), S({});
+}
+function ze(r = {}) {
+  return Ee(r, "wallet connect request");
+}
+function He(r) {
+  return Re(r, "connect");
+}
+function Je(r = {}) {
+  return Ee(r, "wallet account request");
+}
+function We(r) {
+  return Re(r, "account");
+}
+const E = Object.freeze({
+  envelopeBytes: 512,
+  fieldBytes: 4096,
+  batchBytes: 12288,
+  fields: 16,
+  contextBytes: 256
+}), Xe = /^sdn-field-encryption\/v1\|[A-Za-z0-9_.-]{1,64}\|[A-Za-z0-9_.-]{1,64}\|[A-Za-z0-9_.-]{1,64}\|k[1-9][0-9]{0,8}$/u, te = ["ciphertextBase64url", "context", "encBase64url", "fieldId"], Qe = ["fields", "protocolVersion", "replyPublicKeyHex"], re = ["context", "encBase64url", "kmfBase64url", "protocolVersion", "replyPublicKeyHex"], Ze = ["fields", "replyEphemeralPublicKeyHex", "schemaVersion"], Ge = /^[A-Za-z0-9_-]*$/u;
+function q(r, e) {
+  return (!ArrayBuffer.isView(r) || !(r instanceof Uint8Array) || Object.getPrototypeOf(r) !== Uint8Array.prototype) && u(`${e} must be a plain Uint8Array`), Uint8Array.from(r);
+}
+function D(r) {
+  let e = "";
+  for (let t = 0; t < r.length; t += 1) e += String.fromCharCode(r[t]);
+  return globalThis.btoa(e).replace(/\+/gu, "-").replace(/\//gu, "_").replace(/=+$/gu, "");
+}
+function I(r, e, t, s) {
+  v(r, s), (!Ge.test(r) || r.length % 4 === 1 || r.length > Math.ceil(t * 4 / 3)) && u(`${s} must be canonical unpadded base64url`);
+  let i;
+  try {
+    i = globalThis.atob(r.replace(/-/gu, "+").replace(/_/gu, "/").padEnd(Math.ceil(r.length / 4) * 4, "="));
+  } catch {
+    u(`${s} must be valid base64url`);
+  }
+  const o = Uint8Array.from(i, (n) => n.charCodeAt(0));
+  return (o.length < e || o.length > t || D(o) !== r) && u(`${s} must canonically encode ${e}..${t} bytes`), o;
+}
+function X(r, e) {
+  return v(r, e), (Y.encode(r).byteLength > E.contextBytes || !Xe.test(r)) && u(`${e} must be sdn-field-encryption/v1|<site>|<schema>|<field>|k<version>`), r;
+}
+function et(r) {
+  return X(r, "context").split("|")[1];
+}
+function be(r) {
+  const e = R(r, Qe, "field-open request");
+  p(e.protocolVersion, 1, "field-open protocolVersion"), T(e.replyPublicKeyHex, z, "replyPublicKeyHex"), (!Array.isArray(e.fields) || e.fields.length < 1 || e.fields.length > E.fields) && u(`field-open request carries 1..${E.fields} fields`), j(e.fields, e.fields.length, "field-open fields");
+  let t = 0;
+  const s = e.fields.map((i, o) => {
+    const n = R(i, te, `field ${o}`);
+    return I(n.encBase64url, 1, E.envelopeBytes, `field ${o} encBase64url`), t += I(n.ciphertextBase64url, 1, E.fieldBytes, `field ${o} ciphertextBase64url`).length, X(n.context, `field ${o} context`), (!Number.isInteger(n.fieldId) || n.fieldId < 0 || n.fieldId > 65535) && u(`field ${o} fieldId must be 0..65535`), A(te.map((a) => [a, n[a]]));
+  });
+  return t > E.batchBytes && u(`field-open ciphertext exceeds ${E.batchBytes} bytes`), A([
+    ["fields", S(s)],
+    ["protocolVersion", 1],
+    ["replyPublicKeyHex", e.replyPublicKeyHex]
   ]);
 }
-function rt(r, t) {
-  const e = O(r, bt, `${t} result`);
-  R(e.schemaVersion, 1, "connection result schemaVersion"), _t(e.event, ["connected", "disconnected"], "connection event"), t === "connect" && e.event !== "connected" && u("connect result must be connected");
-  let i = null, s = null;
-  return e.event === "connected" ? (i = St(e.identity), s = It(e.connectionExpiresAt, "connectionExpiresAt")) : (e.identity !== null || e.connectionExpiresAt !== null) && u("disconnected result must clear identity and expiry"), C([
-    ["connectionExpiresAt", s],
-    ["event", e.event],
-    ["identity", i],
+function Ae(r) {
+  const e = R(r, re, "key-unwrap request");
+  return p(e.protocolVersion, 1, "key-unwrap protocolVersion"), T(e.replyPublicKeyHex, z, "replyPublicKeyHex"), X(e.context, "key-unwrap context"), I(e.encBase64url, 1, E.envelopeBytes, "key-unwrap encBase64url"), I(e.kmfBase64url, 1, E.envelopeBytes, "key-unwrap kmfBase64url"), A(re.map((t) => [t, e[t]]));
+}
+function we(r, e) {
+  const t = R(r, Ze, "field result");
+  p(t.schemaVersion, 1, "field result schemaVersion"), T(t.replyEphemeralPublicKeyHex, z, "replyEphemeralPublicKeyHex"), (!Array.isArray(t.fields) || t.fields.length < 1 || t.fields.length > e) && u(`field result carries 1..${e} fields`), j(t.fields, t.fields.length, "field result fields");
+  const s = t.fields.map((i, o) => {
+    if ((me(i) ? i.status : void 0) === "opened") {
+      const l = R(i, ["ciphertextBase64url", "status"], `field result ${o}`);
+      return I(l.ciphertextBase64url, 1, E.fieldBytes, `field result ${o} ciphertext`), A([["ciphertextBase64url", l.ciphertextBase64url], ["status", "opened"]]);
+    }
+    const a = R(i, ["reason", "status"], `field result ${o}`);
+    return p(a.status, "refused", `field result ${o} status`), p(a.reason, "NOT_ADDRESSED_TO_ACCOUNT", `field result ${o} reason`), A([["reason", "NOT_ADDRESSED_TO_ACCOUNT"], ["status", "refused"]]);
+  });
+  return A([
+    ["fields", S(s)],
+    ["replyEphemeralPublicKeyHex", t.replyEphemeralPublicKeyHex],
     ["schemaVersion", 1]
   ]);
 }
-function it(r, t) {
-  return O(r, [], t), Y({});
+function tt(r, e = "0".repeat(64)) {
+  const t = R(r, ["fields"], "openFields input");
+  return Array.isArray(t.fields) || u("openFields fields must be an array"), j(t.fields, t.fields.length, "openFields fields"), be({
+    fields: t.fields.map((s, i) => {
+      const o = R(s, ["ciphertext", "context", "enc", "fieldId"], `openFields field ${i}`);
+      return {
+        ciphertextBase64url: D(q(o.ciphertext, `field ${i} ciphertext`)),
+        context: o.context,
+        encBase64url: D(q(o.enc, `field ${i} enc`)),
+        fieldId: o.fieldId
+      };
+    }),
+    protocolVersion: 1,
+    replyPublicKeyHex: e
+  });
 }
-function Ct(r = {}) {
-  return it(r, "wallet connect request");
+function rt(r) {
+  return be(r);
 }
-function Pt(r) {
-  return rt(r, "connect");
+function st(r) {
+  return we(r, E.fields);
 }
-function xt(r = {}) {
-  return it(r, "wallet account request");
+function it(r, e = "0".repeat(64)) {
+  const t = R(r, ["context", "enc", "kmf"], "unwrapKey input");
+  return Ae({
+    context: t.context,
+    encBase64url: D(q(t.enc, "enc")),
+    kmfBase64url: D(q(t.kmf, "kmf")),
+    protocolVersion: 1,
+    replyPublicKeyHex: e
+  });
 }
-function Nt(r) {
-  return rt(r, "account");
+function nt(r) {
+  return Ae(r);
 }
-const v = "https://wallet.spacedatanetwork.org", P = "sdn.wallet.callback.v1:", _ = /^[0-9a-f]{64}$/u, q = /^[A-Za-z0-9_-]{43}$/u, jt = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u, gt = 250, Dt = 3e4, kt = 3e5, Mt = 9e5, Yt = 12e4, Vt = 8, K = 4096, z = 70 * 1024, $t = 64, st = Object.freeze({
+function ot(r) {
+  return we(r, 1);
+}
+const ct = new TextEncoder().encode("sdn-wallet-reply/v1"), at = new TextEncoder().encode("flatbuffers-field"), lt = new TextEncoder().encode("flatbuffers-iv");
+function ut(r) {
+  return Array.from(r, (e) => e.toString(16).padStart(2, "0")).join("");
+}
+function ft(r) {
+  return Uint8Array.from(r.match(/../gu), (e) => Number.parseInt(e, 16));
+}
+function se(r, e) {
+  const t = new Uint8Array(r.length + 6);
+  return t.set(r), t[r.length] = e >> 8, t[r.length + 1] = e & 255, t;
+}
+async function J(r, e, t, s) {
+  const i = await r.importKey("raw", e, "HKDF", !1, ["deriveBits"]);
+  return new Uint8Array(await r.deriveBits({
+    hash: "SHA-256",
+    info: t,
+    name: "HKDF",
+    salt: new Uint8Array(0)
+  }, i, s));
+}
+async function ht(r) {
+  const e = r?.subtle;
+  if (!e) throw new Error("Web Crypto is unavailable");
+  const t = await e.generateKey({ name: "X25519" }, !1, ["deriveBits"]), s = new Uint8Array(await e.exportKey("raw", t.publicKey));
+  if (s.length !== 32) throw new Error("X25519 public key is not 32 bytes");
+  let i = t.privateKey;
+  return Object.freeze({
+    publicKeyHex: ut(s),
+    /** Each reply ciphertext, in order, opened to its bytes. */
+    async open(o, n) {
+      if (!i) throw new Error("reply key already used");
+      const a = i;
+      i = null;
+      const l = await e.importKey("raw", ft(o), { name: "X25519" }, !1, []), f = new Uint8Array(await e.deriveBits({ name: "X25519", public: l }, a, 256)), h = await J(e, f, ct, 256);
+      f.fill(0);
+      try {
+        return await Promise.all(n.map(async (d, y) => {
+          if (d === null) return null;
+          const m = await J(e, h, se(at, y), 256), w = await J(e, h, se(lt, y), 128), H = await e.importKey("raw", m, "AES-CTR", !1, ["decrypt"]);
+          return m.fill(0), new Uint8Array(await e.decrypt({ counter: w, length: 128, name: "AES-CTR" }, H, d));
+        }));
+      } finally {
+        h.fill(0);
+      }
+    }
+  });
+}
+const x = "https://wallet.spacedatanetwork.org", k = "sdn.wallet.callback.v1:", P = /^[0-9a-f]{64}$/u, ie = /^[A-Za-z0-9_-]{43}$/u, dt = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u, yt = 250, pt = 3e4, mt = 3e5, Rt = 9e5, Et = 12e4, bt = 8, ne = 4096, oe = 70 * 1024, At = 64, Oe = Object.freeze({
   CALLBACK_ERROR: "The wallet return could not be verified. Try again.",
   CRYPTO_UNAVAILABLE: "Secure browser cryptography is unavailable.",
   DESTROYED: "This wallet client has been destroyed.",
@@ -304,274 +456,275 @@ const v = "https://wallet.spacedatanetwork.org", P = "sdn.wallet.callback.v1:",
   EXPIRED: "The wallet connection expired.",
   INVALID_CLIENT: "This wallet client is not registered.",
   INVALID_REQUEST: "The wallet request is invalid.",
+  NOT_ADDRESSED_TO_ACCOUNT: "This data is not sealed to your wallet.",
   RELAY_ERROR: "The wallet service could not complete the request. Try again.",
   REPLACED: "A newer wallet request replaced this one.",
   WALLET_NOT_COMPLETED: "The wallet did not complete. Check popup settings and try again."
-}), nt = new TextEncoder(), Ut = new TextDecoder("utf-8", { fatal: !0 });
-class T extends Error {
-  constructor(t) {
-    super(st[t]), this.name = "WalletClientError", Object.defineProperty(this, "code", {
+}), _e = new TextEncoder(), wt = new TextDecoder("utf-8", { fatal: !0 });
+class g extends Error {
+  constructor(e) {
+    super(Oe[e]), this.name = "WalletClientError", Object.defineProperty(this, "code", {
       configurable: !1,
       enumerable: !0,
-      value: t,
+      value: e,
       writable: !1
     });
   }
 }
 function c(r) {
-  return Object.hasOwn(st, r) ? new T(r) : new T("RELAY_ERROR");
+  return Object.hasOwn(Oe, r) ? new g(r) : new g("RELAY_ERROR");
 }
-function Ft(r) {
+function Ot(r) {
   if (r === null || typeof r != "object" || Array.isArray(r)) return !1;
-  const t = Object.getPrototypeOf(r);
-  return t === Object.prototype || t === null;
+  const e = Object.getPrototypeOf(r);
+  return e === Object.prototype || e === null;
 }
-function N(r, t) {
-  if (typeof r != "string" || r.length > t || nt.encode(r).byteLength > t || r.charCodeAt(0) === 65279)
+function $(r, e) {
+  if (typeof r != "string" || r.length > e || _e.encode(r).byteLength > e || r.charCodeAt(0) === 65279)
     throw c("RELAY_ERROR");
-  let e = 0, i = 0;
-  const s = () => {
-    for (; e < r.length && /[\u0009\u000a\u000d\u0020]/u.test(r[e]); ) e += 1;
+  let t = 0, s = 0;
+  const i = () => {
+    for (; t < r.length && /[\u0009\u000a\u000d\u0020]/u.test(r[t]); ) t += 1;
   }, o = () => {
-    if (r[e] !== '"') throw c("RELAY_ERROR");
-    const a = e;
-    for (e += 1; e < r.length; ) {
-      const h = r.charCodeAt(e);
-      if (h === 34) {
-        e += 1;
-        let f;
+    if (r[t] !== '"') throw c("RELAY_ERROR");
+    const l = t;
+    for (t += 1; t < r.length; ) {
+      const f = r.charCodeAt(t);
+      if (f === 34) {
+        t += 1;
+        let h;
         try {
-          f = JSON.parse(r.slice(a, e));
+          h = JSON.parse(r.slice(l, t));
         } catch {
           throw c("RELAY_ERROR");
         }
-        for (let d = 0; d < f.length; d += 1) {
-          const y = f.charCodeAt(d);
+        for (let d = 0; d < h.length; d += 1) {
+          const y = h.charCodeAt(d);
           if (y >= 55296 && y <= 56319) {
-            const m = f.charCodeAt(d + 1);
+            const m = h.charCodeAt(d + 1);
             if (!(m >= 56320 && m <= 57343)) throw c("RELAY_ERROR");
             d += 1;
           } else if (y >= 56320 && y <= 57343)
             throw c("RELAY_ERROR");
         }
-        return f;
+        return h;
       }
-      if (h < 32 || h === 92 && (e += 1, e >= r.length))
+      if (f < 32 || f === 92 && (t += 1, t >= r.length))
         throw c("RELAY_ERROR");
-      e += 1;
+      t += 1;
     }
     throw c("RELAY_ERROR");
-  }, n = (a = 0) => {
-    if (a > 32 || ++i > 4096) throw c("RELAY_ERROR");
-    s();
-    const h = r[e];
-    if (h === '"') return o();
-    if (h === "{") {
-      e += 1;
+  }, n = (l = 0) => {
+    if (l > 32 || ++s > 4096) throw c("RELAY_ERROR");
+    i();
+    const f = r[t];
+    if (f === '"') return o();
+    if (f === "{") {
+      t += 1;
       const y = /* @__PURE__ */ Object.create(null), m = /* @__PURE__ */ new Set();
-      if (s(), r[e] === "}")
-        return e += 1, y;
-      for (; e < r.length; ) {
-        s();
-        const b = o();
-        if (m.has(b) || (m.add(b), s(), r[e] !== ":")) throw c("RELAY_ERROR");
-        if (e += 1, y[b] = n(a + 1), s(), r[e] === "}")
-          return e += 1, y;
-        if (r[e] !== ",") throw c("RELAY_ERROR");
-        e += 1;
+      if (i(), r[t] === "}")
+        return t += 1, y;
+      for (; t < r.length; ) {
+        i();
+        const w = o();
+        if (m.has(w) || (m.add(w), i(), r[t] !== ":")) throw c("RELAY_ERROR");
+        if (t += 1, y[w] = n(l + 1), i(), r[t] === "}")
+          return t += 1, y;
+        if (r[t] !== ",") throw c("RELAY_ERROR");
+        t += 1;
       }
       throw c("RELAY_ERROR");
     }
-    if (h === "[") {
-      e += 1;
+    if (f === "[") {
+      t += 1;
       const y = [];
-      if (s(), r[e] === "]")
-        return e += 1, y;
-      for (; e < r.length; ) {
-        if (y.push(n(a + 1)), s(), r[e] === "]")
-          return e += 1, y;
-        if (r[e] !== ",") throw c("RELAY_ERROR");
-        e += 1;
+      if (i(), r[t] === "]")
+        return t += 1, y;
+      for (; t < r.length; ) {
+        if (y.push(n(l + 1)), i(), r[t] === "]")
+          return t += 1, y;
+        if (r[t] !== ",") throw c("RELAY_ERROR");
+        t += 1;
       }
       throw c("RELAY_ERROR");
     }
     for (const [y, m] of [["true", !0], ["false", !1], ["null", null]])
-      if (r.startsWith(y, e))
-        return e += y.length, m;
-    const f = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(r.slice(e));
-    if (!f) throw c("RELAY_ERROR");
-    e += f[0].length;
-    const d = Number(f[0]);
+      if (r.startsWith(y, t))
+        return t += y.length, m;
+    const h = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(r.slice(t));
+    if (!h) throw c("RELAY_ERROR");
+    t += h[0].length;
+    const d = Number(h[0]);
     if (!Number.isFinite(d)) throw c("RELAY_ERROR");
     return d;
   };
-  s();
-  const l = n();
-  if (s(), e !== r.length) throw c("RELAY_ERROR");
-  return l;
+  i();
+  const a = n();
+  if (i(), t !== r.length) throw c("RELAY_ERROR");
+  return a;
 }
-function j(r, t, e = "RELAY_ERROR") {
-  if (!Ft(r) || Object.getOwnPropertySymbols(r).length !== 0)
-    throw c(e);
-  const i = Object.getOwnPropertyNames(r).sort(), s = [...t].sort();
-  if (i.length !== s.length || i.some((o, n) => o !== s[n]))
-    throw c(e);
-  for (const o of i) {
+function U(r, e, t = "RELAY_ERROR") {
+  if (!Ot(r) || Object.getOwnPropertySymbols(r).length !== 0)
+    throw c(t);
+  const s = Object.getOwnPropertyNames(r).sort(), i = [...e].sort();
+  if (s.length !== i.length || s.some((o, n) => o !== i[n]))
+    throw c(t);
+  for (const o of s) {
     const n = Object.getOwnPropertyDescriptor(r, o);
     if (!n?.enumerable || !("value" in n) || n.value === void 0)
-      throw c(e);
+      throw c(t);
   }
   return r;
 }
-function g(r, t = "RELAY_ERROR") {
-  if (typeof r != "string" || !jt.test(r))
-    throw c(t);
-  const e = Date.parse(r);
-  if (!Number.isFinite(e) || new Date(e).toISOString() !== r)
-    throw c(t);
-  return e;
+function M(r, e = "RELAY_ERROR") {
+  if (typeof r != "string" || !dt.test(r))
+    throw c(e);
+  const t = Date.parse(r);
+  if (!Number.isFinite(t) || new Date(t).toISOString() !== r)
+    throw c(e);
+  return t;
 }
-function A(r) {
-  return Array.isArray(r) ? Object.freeze(r.map(A)) : r && typeof r == "object" ? Object.freeze(Object.fromEntries(
-    Object.entries(r).map(([t, e]) => [t, A(e)])
+function _(r) {
+  return Array.isArray(r) ? Object.freeze(r.map(_)) : r && typeof r == "object" ? Object.freeze(Object.fromEntries(
+    Object.entries(r).map(([e, t]) => [e, _(t)])
   )) : r;
 }
-function X(r) {
-  const t = {
-    identity: r.identity === null ? null : A(r.identity),
+function ce(r) {
+  const e = {
+    identity: r.identity === null ? null : _(r.identity),
     status: r.status
   };
-  return r.connectionExpiresAt !== void 0 && (t.connectionExpiresAt = r.connectionExpiresAt), r.error !== void 0 && (t.error = A(r.error)), A(t);
+  return r.connectionExpiresAt !== void 0 && (e.connectionExpiresAt = r.connectionExpiresAt), r.error !== void 0 && (e.error = _(r.error)), _(e);
 }
-function L(r) {
+function C(r) {
   return Object.freeze({ code: r.code, message: r.message });
 }
-function H(r) {
-  const t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-  let e = 0, i = 0, s = "";
+function ae(r) {
+  const e = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  let t = 0, s = 0, i = "";
   for (const o of r)
-    for (e = e << 8 | o, i += 8; i >= 6; )
-      i -= 6, s += t[e >>> i & 63], e &= (1 << i) - 1;
-  return i !== 0 && (s += t[e << 6 - i & 63]), s;
+    for (t = t << 8 | o, s += 8; s >= 6; )
+      s -= 6, i += e[t >>> s & 63], t &= (1 << s) - 1;
+  return s !== 0 && (i += e[t << 6 - s & 63]), i;
 }
-function Q(r) {
-  let t = "";
-  for (const e of r) t += e.toString(16).padStart(2, "0");
-  return t;
+function le(r) {
+  let e = "";
+  for (const t of r) e += t.toString(16).padStart(2, "0");
+  return e;
 }
-function V(r, t) {
-  const e = new Uint8Array(32);
-  return Reflect.apply(t, r, [e]), e;
+function W(r, e) {
+  const t = new Uint8Array(32);
+  return Reflect.apply(e, r, [t]), t;
 }
-function Bt(r) {
-  const t = r?.headers?.get?.("content-type");
-  return typeof t == "string" && /^application\/json(?:\s*;\s*charset=utf-8)?$/iu.test(t.trim());
+function _t(r) {
+  const e = r?.headers?.get?.("content-type");
+  return typeof e == "string" && /^application\/json(?:\s*;\s*charset=utf-8)?$/iu.test(e.trim());
 }
-function F(r) {
+function Q(r) {
   try {
     Promise.resolve(r).catch(() => {
     });
   } catch {
   }
 }
-function I(r) {
+function N(r) {
   try {
-    const t = r?.body, e = t?.cancel;
-    typeof e == "function" && F(Reflect.apply(e, t, []));
+    const e = r?.body, t = e?.cancel;
+    typeof t == "function" && Q(Reflect.apply(t, e, []));
   } catch {
   }
 }
-function ot(r) {
+function ve(r) {
   try {
-    const t = r?.cancel;
-    typeof t == "function" && F(Reflect.apply(t, r, []));
+    const e = r?.cancel;
+    typeof e == "function" && Q(Reflect.apply(e, r, []));
   } catch {
   }
 }
-function Jt(r) {
+function vt(r) {
   try {
-    const t = r?.releaseLock;
-    typeof t == "function" && Reflect.apply(t, r, []);
+    const e = r?.releaseLock;
+    typeof e == "function" && Reflect.apply(e, r, []);
   } catch {
   }
 }
-function w(r, t, e = null) {
+function L(r, e, t = null) {
   try {
     r.abort();
   } catch {
   }
-  e && ot(e), I(t);
+  t && ve(t), N(e);
 }
-function D(r, t, e = null) {
-  let i;
+function V(r, e, t = null) {
+  let s;
   try {
-    i = Promise.resolve(r);
-  } catch (s) {
-    return Promise.reject(s);
+    s = Promise.resolve(r);
+  } catch (i) {
+    return Promise.reject(i);
   }
-  return new Promise((s, o) => {
+  return new Promise((i, o) => {
     let n = !1;
-    const l = () => {
+    const a = () => {
       try {
-        t.removeEventListener("abort", h);
+        e.removeEventListener("abort", f);
       } catch {
       }
-    }, a = (f, d) => n ? !1 : (n = !0, l(), f(d), !0), h = () => {
-      a(o, c("RELAY_ERROR"));
+    }, l = (h, d) => n ? !1 : (n = !0, a(), h(d), !0), f = () => {
+      l(o, c("RELAY_ERROR"));
     };
     try {
-      t.addEventListener("abort", h, { once: !0 }), t.aborted && h();
+      e.addEventListener("abort", f, { once: !0 }), e.aborted && f();
     } catch {
-      h();
+      f();
     }
-    i.then(
-      (f) => {
+    s.then(
+      (h) => {
         if (n) {
           try {
-            e?.(f);
+            t?.(h);
           } catch {
           }
           return;
         }
-        a(s, f);
+        l(i, h);
       },
-      (f) => {
-        n || a(o, f);
+      (h) => {
+        n || l(o, h);
       }
     );
   });
 }
-async function Z(r, t, e) {
-  let i = null;
-  const s = [];
+async function ue(r, e, t) {
+  let s = null;
+  const i = [];
   let o = 0;
   try {
-    if (!Bt(r) || typeof r?.body?.getReader != "function")
+    if (!_t(r) || typeof r?.body?.getReader != "function")
       throw c("RELAY_ERROR");
-    for (i = r.body.getReader(); ; ) {
-      const a = i.read(), { done: h, value: f } = await D(a, e.signal);
-      if (h) break;
-      if (!(f instanceof Uint8Array) || (o += f.byteLength, o > t))
+    for (s = r.body.getReader(); ; ) {
+      const l = s.read(), { done: f, value: h } = await V(l, t.signal);
+      if (f) break;
+      if (!(h instanceof Uint8Array) || (o += h.byteLength, o > e))
         throw c("RELAY_ERROR");
-      s.push(f);
+      i.push(h);
     }
     const n = new Uint8Array(o);
-    let l = 0;
-    for (const a of s)
-      n.set(a, l), l += a.byteLength;
-    return Ut.decode(n);
+    let a = 0;
+    for (const l of i)
+      n.set(l, a), a += l.byteLength;
+    return wt.decode(n);
   } catch {
     try {
-      e.abort();
+      t.abort();
     } catch {
     }
-    throw i && ot(i), c("RELAY_ERROR");
+    throw s && ve(s), c("RELAY_ERROR");
   } finally {
-    i && Jt(i);
+    s && vt(s);
   }
 }
-function x(r, t) {
-  const e = {
+function B(r, e) {
+  const t = {
     body: JSON.stringify(r),
     cache: "no-store",
     credentials: "omit",
@@ -581,35 +734,35 @@ function x(r, t) {
     redirect: "error",
     referrerPolicy: "no-referrer"
   };
-  return t !== void 0 && (e.signal = t), e;
+  return e !== void 0 && (t.signal = e), t;
 }
-function Wt(r, t, e) {
-  let i;
+function Lt(r, e, t) {
+  let s;
   try {
-    i = N(r, 2048), j(i, ["code", "expiresAt", "schemaVersion", "state"], "CALLBACK_ERROR");
+    s = $(r, 2048), U(s, ["code", "expiresAt", "schemaVersion", "state"], "CALLBACK_ERROR");
   } catch {
     throw c("CALLBACK_ERROR");
   }
-  if (i.schemaVersion !== 1 || i.state !== t || !_.test(i.code))
+  if (s.schemaVersion !== 1 || s.state !== e || !P.test(s.code))
     throw c("CALLBACK_ERROR");
-  const s = g(i.expiresAt, "CALLBACK_ERROR");
-  if (s <= e || s - e > Yt)
+  const i = M(s.expiresAt, "CALLBACK_ERROR");
+  if (i <= t || i - t > Et)
     throw c("CALLBACK_ERROR");
-  return { code: i.code, expiresAt: s, state: i.state };
+  return { code: s.code, expiresAt: i, state: s.state };
 }
-function qt() {
+function Tt() {
   let r;
-  return { promise: new Promise((e) => {
-    r = e;
+  return { promise: new Promise((t) => {
+    r = t;
   }), resolve: r };
 }
-function G() {
-  let r, t;
-  return { promise: new Promise((i, s) => {
-    r = s, t = i;
-  }), reject: r, resolve: t };
+function fe() {
+  let r, e;
+  return { promise: new Promise((s, i) => {
+    r = i, e = s;
+  }), reject: r, resolve: e };
 }
-function Kt() {
+function It() {
   const r = globalThis.window;
   return Object.freeze({
     AbortController: globalThis.AbortController,
@@ -630,122 +783,123 @@ function Kt() {
     window: r
   });
 }
-class zt {
+class St {
   #k;
-  #M;
-  #C = !1;
+  #B;
+  #x = !1;
   #l = !1;
-  #Y = !1;
+  #$ = !1;
   #n = null;
-  #w = null;
+  #O = null;
   #b = /* @__PURE__ */ new Set();
-  #t;
-  #v = null;
+  #e;
+  #_ = null;
   #r = !1;
-  #R = 0;
-  #L = 0;
-  #_ = /* @__PURE__ */ new Set();
-  #P = [];
+  #m = 0;
+  #v = 0;
+  #L = /* @__PURE__ */ new Set();
+  #C = [];
   #o = null;
-  #x = !1;
+  #P = !1;
   #y = /* @__PURE__ */ new Set();
-  #V = Object.freeze({ identity: null, status: "dormant" });
+  #U = Object.freeze({ identity: null, status: "dormant" });
   #u = null;
-  #I = null;
+  #T = null;
   #A = null;
-  #p = /* @__PURE__ */ new Set();
-  #m;
-  constructor({ adapters: t, clientId: e, dependencies: i }) {
-    this.#k = t, this.#M = e, this.#t = i ?? Kt(), this.#m = this.#t.window;
+  #R = /* @__PURE__ */ new Set();
+  #p;
+  constructor({ adapters: e, clientId: t, dependencies: s }) {
+    this.#k = e, this.#B = t, this.#e = s ?? It(), this.#p = this.#e.window;
   }
   getSnapshot() {
-    return this.#F(), X(this.#V);
+    return this.#Y(), ce(this.#U);
   }
-  subscribe(t) {
-    if (typeof t != "function") throw c("INVALID_REQUEST");
+  subscribe(e) {
+    if (typeof e != "function") throw c("INVALID_REQUEST");
     if (this.#r) throw c("DESTROYED");
-    this.#_.add(t);
+    this.#L.add(e);
     try {
-      t(this.getSnapshot());
+      e(this.getSnapshot());
     } catch {
     }
-    let e = !0;
+    let t = !0;
     return () => {
-      e && (e = !1, this.#_.delete(t));
+      t && (t = !1, this.#L.delete(e));
     };
   }
-  execute(t, e) {
+  execute(e, t) {
     if (this.#r) return Promise.reject(c("DESTROYED"));
-    const i = this.#R, s = this.#k[t];
-    if (!s) return Promise.reject(c("INVALID_REQUEST"));
+    const s = this.#m, i = this.#k[e];
+    if (!i) return Promise.reject(c("INVALID_REQUEST"));
     let o;
     try {
-      o = s.buildRequest(e);
+      o = i.buildRequest(t);
     } catch {
-      const p = this.#e(i);
-      return p ? Promise.reject(p) : Promise.reject(c("INVALID_REQUEST"));
+      const b = this.#t(s);
+      return b ? Promise.reject(b) : Promise.reject(c("INVALID_REQUEST"));
     }
-    let n = this.#e(i);
+    let n = this.#t(s);
     if (n) return Promise.reject(n);
-    if (this.#C)
+    if (this.#x)
       return this.#l = !0, Promise.reject(c("REPLACED"));
-    const l = ++this.#R;
-    if (this.#Q(), n = this.#e(l), n) return Promise.reject(n);
+    const a = ++this.#m;
+    if (this.#Q(), n = this.#t(a), n) return Promise.reject(n);
     if (this.#l)
       return Promise.reject(c("CALLBACK_ERROR"));
-    if (this.#F(), n = this.#e(l), n) return Promise.reject(n);
-    const a = this.#s();
-    if (n = this.#e(l), n) return Promise.reject(n);
-    const h = this.#n && this.#n.expiresAtMs > a ? this.#n : null;
-    if (n = this.#e(l), n) return Promise.reject(n);
-    const f = this.#o;
+    if (this.#Y(), n = this.#t(a), n) return Promise.reject(n);
+    const l = this.#i();
+    if (n = this.#t(a), n) return Promise.reject(n);
+    const f = this.#n && this.#n.expiresAtMs > l ? this.#n : null;
+    if (n = this.#t(a), n) return Promise.reject(n);
+    const h = this.#o;
     let d, y, m;
     try {
-      const p = this.#t.crypto, E = p?.getRandomValues, at = p?.subtle?.digest, J = this.#m?.open;
-      if (n = this.#e(l), n) throw n;
-      if (typeof E != "function" || typeof at != "function" || typeof J != "function")
+      const b = this.#e.crypto, O = b?.getRandomValues, Ie = b?.subtle?.digest, G = this.#p?.open;
+      if (n = this.#t(a), n) throw n;
+      if (typeof O != "function" || typeof Ie != "function" || typeof G != "function")
         throw c("CRYPTO_UNAVAILABLE");
-      if (d = Q(V(p, E)), n = this.#e(l), n || (y = Q(V(p, E)), n = this.#e(l), n) || (m = H(V(p, E)), n = this.#e(l), n)) throw n;
-      if (!_.test(d) || !_.test(y) || !q.test(m))
+      if (d = le(W(b, O)), n = this.#t(a), n || (y = le(W(b, O)), n = this.#t(a), n) || (m = ae(W(b, O)), n = this.#t(a), n)) throw n;
+      if (!P.test(d) || !P.test(y) || !ie.test(m))
         throw c("CRYPTO_UNAVAILABLE");
-      if (Reflect.apply(J, this.#m, [
-        `${v}/transaction/${d}`,
+      if (Reflect.apply(G, this.#p, [
+        `${x}/transaction/${d}`,
         "_blank",
         "noopener"
-      ]), n = this.#e(l), n) throw n;
-    } catch (p) {
-      if (n = this.#e(l), n) return Promise.reject(n);
-      let E;
+      ]), n = this.#t(a), n) throw n;
+    } catch (b) {
+      if (n = this.#t(a), n) return Promise.reject(n);
+      let O;
       try {
-        E = p instanceof T ? p : c("CRYPTO_UNAVAILABLE");
+        O = b instanceof g ? b : c("CRYPTO_UNAVAILABLE");
       } catch {
-        E = c("CRYPTO_UNAVAILABLE");
+        O = c("CRYPTO_UNAVAILABLE");
       }
-      return f && (this.#T(f, "REPLACED", !1), n = this.#e(l), n) ? Promise.reject(n) : (this.#$(null, E, h, s.kind), Promise.reject(E));
+      return h && (this.#I(h, "REPLACED", !1), n = this.#t(a), n) ? Promise.reject(n) : (this.#M(null, O, f, i.kind), Promise.reject(O));
     }
-    if (f && (this.#T(f, "REPLACED", !1), n = this.#e(l), n))
+    if (h && (this.#I(h, "REPLACED", !1), n = this.#t(a), n))
       return Promise.reject(n);
-    const b = G(), ct = qt(), B = {
+    const w = fe(), H = Tt(), Z = {
       active: !0,
-      adapter: s,
+      adapter: i,
       callbackBusy: !1,
       challenge: null,
-      cleanup: ct,
+      cleanup: H,
       cleanupFinished: !1,
       cleanupStarted: !1,
       controllers: /* @__PURE__ */ new Set(),
       expiryTimer: null,
-      generation: ++this.#L,
+      generation: ++this.#v,
       operationTimer: null,
       phase: "hashing",
       pollTimer: null,
-      priorConnection: h,
-      promise: b.promise,
-      registrationDeadlineMs: a + Dt,
+      priorConnection: f,
+      promise: w.promise,
+      registrationDeadlineMs: l + pt,
       registrationOutcome: "none",
-      reject: b.reject,
+      reject: w.reject,
+      openResult: null,
       request: o,
-      resolve: b.resolve,
+      resolve: w.resolve,
       retryResolve: null,
       retryTimer: null,
       state: y,
@@ -753,433 +907,436 @@ class zt {
       transactionId: d,
       verifier: m
     };
-    return this.#o = B, this.#i({
-      ...h ? {
-        connectionExpiresAt: h.expiresAt,
-        identity: h.identity
+    return this.#o = Z, this.#s({
+      ...f ? {
+        connectionExpiresAt: f.expiresAt,
+        identity: f.identity
       } : { identity: null },
       status: "opening"
-    }), this.#W(B), b.promise;
+    }), this.#q(Z), w.promise;
   }
   async disconnect() {
     if (this.#r) throw c("DESTROYED");
-    const t = ++this.#R;
-    this.#f();
-    const e = this.#o;
-    let i = Promise.resolve();
-    e && (i = this.#T(e, "DISCONNECTED", !1));
-    let s = this.#e(t);
-    if (s)
-      throw await i, s;
-    if (this.#i({ identity: null, status: "dormant" }), await i, s = this.#e(t), s) throw s;
+    const e = ++this.#m;
+    this.#h();
+    const t = this.#o;
+    let s = Promise.resolve();
+    t && (s = this.#I(t, "DISCONNECTED", !1));
+    let i = this.#t(e);
+    if (i)
+      throw await s, i;
+    if (this.#s({ identity: null, status: "dormant" }), await s, i = this.#t(e), i) throw i;
   }
   destroy() {
-    if (this.#v) return this.#v;
-    const t = G();
-    this.#v = t.promise, this.#R += 1;
+    if (this.#_) return this.#_;
+    const e = fe();
+    this.#_ = e.promise, this.#m += 1;
     try {
-      this.#J(), t.resolve();
+      this.#K(), e.resolve();
     } catch {
-      t.reject(c("RELAY_ERROR"));
+      e.reject(c("RELAY_ERROR"));
     }
-    return this.#v;
+    return this.#_;
   }
-  #J() {
-    this.#r = !0, this.#L += 1, this.#f();
-    const t = [], e = this.#o;
-    e && (e.active = !1, this.#o = null, this.#S(e), e.reject(c("DESTROYED")), e.challenge && e.verifier && t.push(e));
-    for (const i of this.#y)
-      i.challenge && i.verifier && t.push(i);
-    for (const i of this.#b) i.abort();
+  #K() {
+    this.#r = !0, this.#v += 1, this.#h();
+    const e = [], t = this.#o;
+    t && (t.active = !1, this.#o = null, this.#S(t), t.reject(c("DESTROYED")), t.challenge && t.verifier && e.push(t));
+    for (const s of this.#y)
+      s.challenge && s.verifier && e.push(s);
+    for (const s of this.#b) s.abort();
     this.#b.clear();
-    for (const i of this.#p)
-      this.#t.clearTimeout(i), this.#t.clearInterval(i);
-    if (this.#p.clear(), this.#A)
+    for (const s of this.#R)
+      this.#e.clearTimeout(s), this.#e.clearInterval(s);
+    if (this.#R.clear(), this.#A)
       try {
         this.#A();
       } catch {
       }
-    this.#I = null, this.#A = null, this.#u = null, this.#_.clear();
-    for (const i of t) this.#H(i);
-    e && this.#a(e);
-    for (const i of [...this.#y]) this.#a(i);
-    this.#i({
-      error: L(c("DESTROYED")),
+    this.#T = null, this.#A = null, this.#u = null, this.#L.clear();
+    for (const s of e) this.#X(s);
+    t && this.#a(t);
+    for (const s of [...this.#y]) this.#a(s);
+    this.#s({
+      error: C(c("DESTROYED")),
       identity: null,
       status: "error"
     });
   }
-  async #W(t) {
-    if (!(!this.#c(t) || t.cleanupFinished))
+  async #q(e) {
+    if (!(!this.#c(e) || e.cleanupFinished))
       try {
-        t.operationTimer = this.#O(() => {
-          if (!t.cleanupFinished) {
-            if (t.phase === "hashing") {
-              this.#c(t) && this.#h(t, "CRYPTO_UNAVAILABLE", !1);
+        if (e.operationTimer = this.#w(() => {
+          if (!e.cleanupFinished) {
+            if (e.phase === "hashing") {
+              this.#c(e) && this.#f(e, "CRYPTO_UNAVAILABLE", !1);
               return;
             }
-            if (t.phase === "registering")
-              for (const l of t.controllers) l.abort();
+            if (e.phase === "registering")
+              for (const a of e.controllers) a.abort();
           }
-        }, Math.max(0, t.registrationDeadlineMs - this.#s()));
-        const e = await this.#t.crypto.subtle.digest(
+        }, Math.max(0, e.registrationDeadlineMs - this.#i())), typeof e.adapter.seal == "function") {
+          const a = await e.adapter.seal(e.request, this.#e.crypto);
+          e.request = a.request, e.openResult = a.open;
+        }
+        const t = await this.#e.crypto.subtle.digest(
           "SHA-256",
-          nt.encode(t.verifier)
-        ), i = H(new Uint8Array(e));
-        if (!q.test(i)) throw c("CRYPTO_UNAVAILABLE");
-        if (!this.#c(t)) {
-          t.registrationOutcome = "not-started", this.#a(t);
+          _e.encode(e.verifier)
+        ), s = ae(new Uint8Array(t));
+        if (!ie.test(s)) throw c("CRYPTO_UNAVAILABLE");
+        if (!this.#c(e)) {
+          e.registrationOutcome = "not-started", this.#a(e);
           return;
         }
-        t.challenge = i, t.phase = "registering";
-        const s = this.#j(t);
+        e.challenge = s, e.phase = "registering";
+        const i = this.#g(e);
         let o, n = null;
         try {
           try {
-            const a = this.#t.fetch(
-              `${v}/relay/v1/transactions`,
-              x({
-                clientId: this.#M,
-                codeChallenge: t.challenge,
+            const l = this.#e.fetch(
+              `${x}/relay/v1/transactions`,
+              B({
+                clientId: this.#B,
+                codeChallenge: e.challenge,
                 codeChallengeMethod: "S256",
-                operation: t.adapter.operation,
-                request: t.request,
+                operation: e.adapter.operation,
+                request: e.request,
                 schemaVersion: 1,
-                state: t.state,
-                transactionId: t.transactionId
-              }, s.signal)
+                state: e.state,
+                transactionId: e.transactionId
+              }, i.signal)
             );
-            n = await D(
-              a,
-              s.signal,
-              I
+            n = await V(
+              l,
+              i.signal,
+              N
             );
           } catch {
-            t.registrationOutcome = "ambiguous", t.active ? this.#h(t, "RELAY_ERROR") : this.#E(t);
+            e.registrationOutcome = "ambiguous", e.active ? this.#f(e, "RELAY_ERROR") : this.#E(e);
             return;
           }
-          t.registrationOutcome = "ambiguous";
-          let l;
+          e.registrationOutcome = "ambiguous";
+          let a;
           try {
-            l = n.status;
+            a = n.status;
           } catch {
-            w(s, n), t.active ? this.#h(t, "RELAY_ERROR") : this.#E(t);
+            L(i, n), e.active ? this.#f(e, "RELAY_ERROR") : this.#E(e);
             return;
           }
-          if (l !== 201) {
-            t.registrationOutcome = "definitive-failure", w(s, n), t.active ? this.#h(t, "RELAY_ERROR", !1) : this.#a(t);
+          if (a !== 201) {
+            e.registrationOutcome = "definitive-failure", L(i, n), e.active ? this.#f(e, "RELAY_ERROR", !1) : this.#a(e);
             return;
           }
           try {
-            const a = await Z(
+            const l = await ue(
               n,
-              K,
-              s
-            ), h = j(
-              N(a, K),
+              ne,
+              i
+            ), f = U(
+              $(l, ne),
               ["expiresAt", "schemaVersion", "transactionId"]
             );
-            if (h.schemaVersion !== 1 || h.transactionId !== t.transactionId)
+            if (f.schemaVersion !== 1 || f.transactionId !== e.transactionId)
               throw c("RELAY_ERROR");
-            o = g(h.expiresAt);
-            const f = this.#s();
-            if (o <= f || o - f > kt)
+            o = M(f.expiresAt);
+            const h = this.#i();
+            if (o <= h || o - h > mt)
               throw c("RELAY_ERROR");
           } catch {
-            t.registrationOutcome = "ambiguous", w(s, n), t.active ? this.#h(t, "RELAY_ERROR") : this.#E(t);
+            e.registrationOutcome = "ambiguous", L(i, n), e.active ? this.#f(e, "RELAY_ERROR") : this.#E(e);
             return;
           }
         } finally {
           try {
-            s.abort();
+            i.abort();
           } catch {
           }
-          this.#g(t, s), this.#d(t.operationTimer), t.operationTimer = null;
+          this.#D(e, i), this.#d(e.operationTimer), e.operationTimer = null;
         }
-        if (t.transactionExpiresAtMs = o, t.registrationOutcome = "registered", !this.#c(t)) {
-          this.#E(t);
+        if (e.transactionExpiresAtMs = o, e.registrationOutcome = "registered", !this.#c(e)) {
+          this.#E(e);
           return;
         }
-        t.phase = "waiting-callback", t.expiryTimer = this.#O(() => {
-          this.#c(t) && this.#h(t, "WALLET_NOT_COMPLETED");
-        }, Math.max(0, t.transactionExpiresAtMs - this.#s())), t.pollTimer = this.#X(() => {
-          this.#N(t, !1);
-        }, gt), await this.#N(t, !1);
-      } catch (e) {
-        if (!t.active) {
-          t.registrationOutcome === "ambiguous" || t.registrationOutcome === "registered" ? this.#E(t) : this.#a(t);
+        e.phase = "waiting-callback", e.expiryTimer = this.#w(() => {
+          this.#c(e) && this.#f(e, "WALLET_NOT_COMPLETED");
+        }, Math.max(0, e.transactionExpiresAtMs - this.#i())), e.pollTimer = this.#W(() => {
+          this.#N(e, !1);
+        }, yt), await this.#N(e, !1);
+      } catch (t) {
+        if (!e.active) {
+          e.registrationOutcome === "ambiguous" || e.registrationOutcome === "registered" ? this.#E(e) : this.#a(e);
           return;
         }
-        const i = e instanceof T ? e.code : t.phase === "hashing" ? "CRYPTO_UNAVAILABLE" : "RELAY_ERROR";
-        this.#h(t, i, t.registrationOutcome !== "none");
+        const s = t instanceof g ? t.code : e.phase === "hashing" ? "CRYPTO_UNAVAILABLE" : "RELAY_ERROR";
+        this.#f(e, s, e.registrationOutcome !== "none");
       }
   }
-  async #N(t, e) {
-    if (!this.#c(t) || t.phase !== "waiting-callback" || t.callbackBusy || !this.#u) return;
-    const i = `${P}${t.state}`;
-    let s;
+  async #N(e, t) {
+    if (!this.#c(e) || e.phase !== "waiting-callback" || e.callbackBusy || !this.#u) return;
+    const s = `${k}${e.state}`;
+    let i;
     try {
-      s = this.#u.getItem(i);
+      i = this.#u.getItem(s);
     } catch {
-      e && this.#h(t, "CALLBACK_ERROR");
+      t && this.#f(e, "CALLBACK_ERROR");
       return;
     }
-    if (s === null) return;
-    t.callbackBusy = !0;
+    if (i === null) return;
+    e.callbackBusy = !0;
     let o;
     try {
-      o = Wt(s, t.state, this.#s()), this.#u.removeItem(i);
+      o = Lt(i, e.state, this.#i()), this.#u.removeItem(s);
     } catch {
       try {
-        this.#u.removeItem(i);
+        this.#u.removeItem(s);
       } catch {
       }
-      this.#h(t, "CALLBACK_ERROR");
+      this.#f(e, "CALLBACK_ERROR");
       return;
     }
-    if (!this.#c(t)) return;
-    t.phase = "redeeming", this.#d(t.pollTimer, !0), t.pollTimer = null;
-    const n = this.#j(t);
-    let l = null;
+    if (!this.#c(e)) return;
+    e.phase = "redeeming", this.#d(e.pollTimer, !0), e.pollTimer = null;
+    const n = this.#g(e);
+    let a = null;
     try {
-      const a = this.#t.fetch(
-        `${v}/relay/v1/codes/redeem`,
-        x({
+      const l = this.#e.fetch(
+        `${x}/relay/v1/codes/redeem`,
+        B({
           code: o.code,
-          codeVerifier: t.verifier,
+          codeVerifier: e.verifier,
           schemaVersion: 1,
-          state: t.state,
-          transactionId: t.transactionId
+          state: e.state,
+          transactionId: e.transactionId
         }, n.signal)
       );
-      if (l = await D(
-        a,
-        n.signal,
-        I
-      ), l.status !== 200) throw c("RELAY_ERROR");
-      const h = await Z(
+      if (a = await V(
         l,
-        z,
+        n.signal,
+        N
+      ), a.status !== 200) throw c("RELAY_ERROR");
+      const f = await ue(
+        a,
+        oe,
         n
-      ), f = j(
-        N(h, z),
+      ), h = U(
+        $(f, oe),
         ["result", "schemaVersion", "transactionId"]
       );
-      if (f.schemaVersion !== 1 || f.transactionId !== t.transactionId)
+      if (h.schemaVersion !== 1 || h.transactionId !== e.transactionId)
         throw c("RELAY_ERROR");
       let d;
       try {
-        d = t.adapter.parseResult(f.result);
+        d = e.adapter.parseResult(h.result);
       } catch {
         throw c("RELAY_ERROR");
       }
-      if (!this.#c(t)) return;
-      this.#q(t, d);
-    } catch (a) {
-      if (l && w(n, l), !this.#c(t)) return;
-      const h = a instanceof T ? a.code : "RELAY_ERROR";
-      this.#h(t, h);
+      if (e.openResult && (d = await e.openResult(d)), !this.#c(e)) return;
+      this.#z(e, d);
+    } catch (l) {
+      if (a && L(n, a), !this.#c(e)) return;
+      const f = l instanceof g ? l.code : "RELAY_ERROR";
+      this.#f(e, f);
     } finally {
       try {
         n.abort();
       } catch {
       }
-      this.#g(t, n);
+      this.#D(e, n);
     }
   }
-  #q(t, e) {
-    if (!this.#c(t)) return;
-    let i = null;
-    (t.adapter.kind === "connect" || t.adapter.kind === "account" && e.event === "connected") && (i = this.#K(e)), t.active = !1, this.#o = null, this.#S(t);
-    let s = e;
-    t.adapter.kind === "connect" ? (this.#U(i), s = A(e.identity)) : t.adapter.kind === "account" ? (e.event === "connected" ? this.#U(i) : (this.#f(), this.#i({ identity: null, status: "dormant" })), s = void 0) : this.#z(t, void 0), t.resolve(s), this.#a(t);
+  #z(e, t) {
+    if (!this.#c(e)) return;
+    let s = null;
+    (e.adapter.kind === "connect" || e.adapter.kind === "account" && t.event === "connected") && (s = this.#H(t)), e.active = !1, this.#o = null, this.#S(e);
+    let i = t;
+    e.adapter.kind === "connect" ? (this.#V(s), i = _(t.identity)) : e.adapter.kind === "account" ? (t.event === "connected" ? this.#V(s) : (this.#h(), this.#s({ identity: null, status: "dormant" })), i = void 0) : this.#J(e, void 0), e.resolve(i), this.#a(e);
   }
-  #h(t, e, i = !0) {
-    this.#c(t) && this.#T(t, e, !0, i);
+  #f(e, t, s = !0) {
+    this.#c(e) && this.#I(e, t, !0, s);
   }
-  #T(t, e, i, s = !0) {
-    if (!t.active) return t.cleanup.promise;
-    const o = this.#R;
-    t.active = !1, this.#o === t && (this.#o = null), this.#L += 1, this.#S(t);
-    for (const a of t.controllers)
-      t.phase !== "registering" && a.abort();
-    const n = this.#e(o), l = n ?? c(e);
-    return t.reject(l), i && !n && this.#$(t, l, t.priorConnection, t.adapter.kind), this.#r ? (t.challenge && t.verifier && this.#B(t), this.#a(t), t.cleanup.promise) : (!s || t.registrationOutcome === "definitive-failure" || t.registrationOutcome === "not-started" ? this.#a(t) : t.phase === "hashing" ? (t.registrationOutcome = "not-started", this.#a(t)) : t.phase === "registering" && t.registrationOutcome === "none" ? this.#D(t) : (this.#D(t), this.#E(t)), t.cleanup.promise);
+  #I(e, t, s, i = !0) {
+    if (!e.active) return e.cleanup.promise;
+    const o = this.#m;
+    e.active = !1, this.#o === e && (this.#o = null), this.#v += 1, this.#S(e);
+    for (const l of e.controllers)
+      e.phase !== "registering" && l.abort();
+    const n = this.#t(o), a = n ?? c(t);
+    return e.reject(a), s && !n && this.#M(e, a, e.priorConnection, e.adapter.kind), this.#r ? (e.challenge && e.verifier && this.#F(e), this.#a(e), e.cleanup.promise) : (!i || e.registrationOutcome === "definitive-failure" || e.registrationOutcome === "not-started" ? this.#a(e) : e.phase === "hashing" ? (e.registrationOutcome = "not-started", this.#a(e)) : e.phase === "registering" && e.registrationOutcome === "none" ? this.#j(e) : (this.#j(e), this.#E(e)), e.cleanup.promise);
   }
-  #$(t, e, i, s) {
-    if (i?.expiresAtMs > this.#s()) {
-      this.#n = i, this.#i({
-        connectionExpiresAt: i.expiresAt,
-        error: L(e),
-        identity: i.identity,
+  #M(e, t, s, i) {
+    if (s?.expiresAtMs > this.#i()) {
+      this.#n = s, this.#s({
+        connectionExpiresAt: s.expiresAt,
+        error: C(t),
+        identity: s.identity,
         status: "connected"
       });
       return;
     }
-    this.#f(), this.#i({
-      error: L(e),
+    this.#h(), this.#s({
+      error: C(t),
       identity: null,
       status: "error"
     });
   }
-  #K(t) {
-    const e = g(t.connectionExpiresAt), i = this.#s();
-    if (e <= i || e - i > Mt)
+  #H(e) {
+    const t = M(e.connectionExpiresAt), s = this.#i();
+    if (t <= s || t - s > Rt)
       throw c("RELAY_ERROR");
     return {
-      expiresAt: t.connectionExpiresAt,
-      expiresAtMs: e,
-      identity: A(t.identity)
+      expiresAt: e.connectionExpiresAt,
+      expiresAtMs: t,
+      identity: _(e.identity)
     };
   }
-  #U(t) {
-    const e = this.#s();
-    this.#f(), this.#n = t;
-    const i = this.#n;
-    this.#w = this.#O(() => {
-      this.#n === i && (this.#n = null, this.#w = null, this.#o ? this.#i({ identity: null, status: "opening" }) : this.#i({ identity: null, status: "dormant" }));
-    }, Math.max(0, t.expiresAtMs - e)), this.#i({
-      connectionExpiresAt: t.expiresAt,
+  #V(e) {
+    const t = this.#i();
+    this.#h(), this.#n = e;
+    const s = this.#n;
+    this.#O = this.#w(() => {
+      this.#n === s && (this.#n = null, this.#O = null, this.#o ? this.#s({ identity: null, status: "opening" }) : this.#s({ identity: null, status: "dormant" }));
+    }, Math.max(0, e.expiresAtMs - t)), this.#s({
+      connectionExpiresAt: e.expiresAt,
       identity: this.#n.identity,
       status: "connected"
     });
   }
-  #z(t, e) {
-    const i = t.priorConnection;
-    i?.expiresAtMs > this.#s() ? (this.#n = i, this.#i({
-      connectionExpiresAt: i.expiresAt,
-      ...e ? { error: L(e) } : {},
-      identity: i.identity,
+  #J(e, t) {
+    const s = e.priorConnection;
+    s?.expiresAtMs > this.#i() ? (this.#n = s, this.#s({
+      connectionExpiresAt: s.expiresAt,
+      ...t ? { error: C(t) } : {},
+      identity: s.identity,
       status: "connected"
-    })) : e ? (this.#f(), this.#i({ error: L(e), identity: null, status: "error" })) : (this.#f(), this.#i({ identity: null, status: "dormant" }));
+    })) : t ? (this.#h(), this.#s({ error: C(t), identity: null, status: "error" })) : (this.#h(), this.#s({ identity: null, status: "dormant" }));
   }
-  #F() {
-    !this.#n || this.#n.expiresAtMs > this.#s() || (this.#f(), this.#o ? this.#i({ identity: null, status: "opening" }) : this.#i({ identity: null, status: "dormant" }));
+  #Y() {
+    !this.#n || this.#n.expiresAtMs > this.#i() || (this.#h(), this.#o ? this.#s({ identity: null, status: "opening" }) : this.#s({ identity: null, status: "dormant" }));
   }
-  #f() {
-    this.#n = null, this.#d(this.#w), this.#w = null;
+  #h() {
+    this.#n = null, this.#d(this.#O), this.#O = null;
   }
-  #i(t) {
-    const e = A(t);
-    if (this.#V = e, this.#P.push(e), !this.#x) {
-      this.#x = !0;
+  #s(e) {
+    const t = _(e);
+    if (this.#U = t, this.#C.push(t), !this.#P) {
+      this.#P = !0;
       try {
-        for (; this.#P.length !== 0; ) {
-          const i = this.#P.shift();
-          for (const s of [...this.#_])
+        for (; this.#C.length !== 0; ) {
+          const s = this.#C.shift();
+          for (const i of [...this.#L])
             try {
-              s(X(i));
+              i(ce(s));
             } catch {
             }
         }
       } finally {
-        this.#x = !1;
+        this.#P = !1;
       }
     }
   }
-  #c(t) {
-    return !this.#r && t.active && this.#o === t && t.generation === this.#L;
+  #c(e) {
+    return !this.#r && e.active && this.#o === e && e.generation === this.#v;
   }
-  #e(t) {
-    return this.#r ? c("DESTROYED") : t !== this.#R ? c("REPLACED") : null;
+  #t(e) {
+    return this.#r ? c("DESTROYED") : e !== this.#m ? c("REPLACED") : null;
   }
-  #s() {
-    return this.#t.now();
+  #i() {
+    return this.#e.now();
   }
-  #j(t) {
-    const e = new this.#t.AbortController();
-    return t.controllers.add(e), this.#b.add(e), e;
+  #g(e) {
+    const t = new this.#e.AbortController();
+    return e.controllers.add(t), this.#b.add(t), t;
   }
-  #g(t, e) {
-    t.controllers.delete(e), this.#b.delete(e);
+  #D(e, t) {
+    e.controllers.delete(t), this.#b.delete(t);
   }
-  #O(t, e) {
-    let i;
-    return i = this.#t.setTimeout(() => {
-      this.#p.delete(i), t();
-    }, Math.max(0, e)), this.#p.add(i), i;
+  #w(e, t) {
+    let s;
+    return s = this.#e.setTimeout(() => {
+      this.#R.delete(s), e();
+    }, Math.max(0, t)), this.#R.add(s), s;
   }
-  #X(t, e) {
-    const i = this.#t.setInterval(t, e);
-    return this.#p.add(i), i;
+  #W(e, t) {
+    const s = this.#e.setInterval(e, t);
+    return this.#R.add(s), s;
   }
-  #d(t, e = !1) {
-    t != null && (e ? this.#t.clearInterval(t) : this.#t.clearTimeout(t), this.#p.delete(t));
+  #d(e, t = !1) {
+    e != null && (t ? this.#e.clearInterval(e) : this.#e.clearTimeout(e), this.#R.delete(e));
   }
-  #S(t) {
-    this.#d(t.expiryTimer), this.#d(t.pollTimer, !0), t.expiryTimer = null, t.pollTimer = null;
+  #S(e) {
+    this.#d(e.expiryTimer), this.#d(e.pollTimer, !0), e.expiryTimer = null, e.pollTimer = null;
   }
-  #D(t) {
-    if (!(t.cleanupFinished || this.#y.has(t)))
-      for (this.#y.add(t); this.#y.size > Vt; ) {
-        const e = this.#y.values().next().value;
-        for (const i of e.controllers) i.abort();
-        this.#a(e);
+  #j(e) {
+    if (!(e.cleanupFinished || this.#y.has(e)))
+      for (this.#y.add(e); this.#y.size > bt; ) {
+        const t = this.#y.values().next().value;
+        for (const s of t.controllers) s.abort();
+        this.#a(t);
       }
   }
-  async #E(t) {
-    if (t.cleanupFinished || t.cleanupStarted || this.#r)
-      return t.cleanup.promise;
-    t.cleanupStarted = !0, this.#D(t);
-    let e = 100, i = !0;
-    for (; !this.#r && !t.cleanupFinished && (i || this.#s() <= t.registrationDeadlineMs); ) {
-      i = !1;
-      const s = await this.#B(t);
-      if (t.cleanupFinished) return t.cleanup.promise;
-      if (s === "done")
-        return this.#a(t), t.cleanup.promise;
-      const o = t.registrationDeadlineMs - this.#s();
+  async #E(e) {
+    if (e.cleanupFinished || e.cleanupStarted || this.#r)
+      return e.cleanup.promise;
+    e.cleanupStarted = !0, this.#j(e);
+    let t = 100, s = !0;
+    for (; !this.#r && !e.cleanupFinished && (s || this.#i() <= e.registrationDeadlineMs); ) {
+      s = !1;
+      const i = await this.#F(e);
+      if (e.cleanupFinished) return e.cleanup.promise;
+      if (i === "done")
+        return this.#a(e), e.cleanup.promise;
+      const o = e.registrationDeadlineMs - this.#i();
       if (o <= 0) break;
       await new Promise((n) => {
-        t.retryResolve = n, t.retryTimer = this.#O(() => {
-          t.retryResolve = null, n();
-        }, Math.min(e, o));
-      }), t.retryResolve = null, t.retryTimer = null, e = Math.min(e * 2, 4e3);
+        e.retryResolve = n, e.retryTimer = this.#w(() => {
+          e.retryResolve = null, n();
+        }, Math.min(t, o));
+      }), e.retryResolve = null, e.retryTimer = null, t = Math.min(t * 2, 4e3);
     }
-    return this.#a(t), t.cleanup.promise;
+    return this.#a(e), e.cleanup.promise;
   }
-  async #B(t) {
-    if (!t.verifier || !t.challenge) return "done";
-    const e = this.#j(t), i = t.registrationDeadlineMs - this.#s(), s = i > 0 ? Math.min(4e3, i) : 1e3, o = this.#O(() => e.abort(), Math.max(1, s));
+  async #F(e) {
+    if (!e.verifier || !e.challenge) return "done";
+    const t = this.#g(e), s = e.registrationDeadlineMs - this.#i(), i = s > 0 ? Math.min(4e3, s) : 1e3, o = this.#w(() => t.abort(), Math.max(1, i));
     let n = null;
     try {
-      const l = this.#t.fetch(
-        `${v}/relay/v1/transactions/${t.transactionId}/cancel`,
-        x({
-          codeVerifier: t.verifier,
+      const a = this.#e.fetch(
+        `${x}/relay/v1/transactions/${e.transactionId}/cancel`,
+        B({
+          codeVerifier: e.verifier,
           schemaVersion: 1,
-          state: t.state,
-          transactionId: t.transactionId
-        }, e.signal)
+          state: e.state,
+          transactionId: e.transactionId
+        }, t.signal)
       );
-      n = await D(
-        l,
-        e.signal,
-        I
+      n = await V(
+        a,
+        t.signal,
+        N
       );
-      const a = n.status;
-      return w(e, n), n = null, a === 204 || a === 400 || a === 403 || a === 409 || a === 410 ? "done" : "retry";
+      const l = n.status;
+      return L(t, n), n = null, l === 204 || l === 400 || l === 403 || l === 409 || l === 410 ? "done" : "retry";
     } catch {
-      return n && w(e, n), "retry";
+      return n && L(t, n), "retry";
     } finally {
       try {
-        e.abort();
+        t.abort();
       } catch {
       }
-      this.#d(o), this.#g(t, e);
+      this.#d(o), this.#D(e, t);
     }
   }
-  #H(t) {
-    let e;
+  #X(e) {
+    let t;
     try {
-      e = this.#t.fetch(
-        `${v}/relay/v1/transactions/${t.transactionId}/cancel`,
+      t = this.#e.fetch(
+        `${x}/relay/v1/transactions/${e.transactionId}/cancel`,
         {
-          ...x({
-            codeVerifier: t.verifier,
+          ...B({
+            codeVerifier: e.verifier,
             schemaVersion: 1,
-            state: t.state,
-            transactionId: t.transactionId
+            state: e.state,
+            transactionId: e.transactionId
           }),
           // Let the browser finish the tiny revocation after local teardown or unload.
           keepalive: !0
@@ -1188,29 +1345,29 @@ class zt {
     } catch {
       return;
     }
-    F(Promise.resolve(e).then(I));
+    Q(Promise.resolve(t).then(N));
   }
-  #a(t) {
-    if (!t.cleanupFinished) {
-      t.cleanupFinished = !0, this.#d(t.retryTimer), t.retryResolve?.(), t.retryResolve = null, t.retryTimer = null, this.#d(t.operationTimer), t.operationTimer = null, this.#S(t);
-      for (const e of t.controllers)
-        e.abort(), this.#b.delete(e);
-      t.controllers.clear(), this.#y.delete(t), t.adapter = null, t.challenge = null, t.priorConnection = null, t.request = null, t.state = null, t.transactionExpiresAtMs = null, t.transactionId = null, t.verifier = null, t.cleanup.resolve();
+  #a(e) {
+    if (!e.cleanupFinished) {
+      e.cleanupFinished = !0, this.#d(e.retryTimer), e.retryResolve?.(), e.retryResolve = null, e.retryTimer = null, this.#d(e.operationTimer), e.operationTimer = null, this.#S(e);
+      for (const t of e.controllers)
+        t.abort(), this.#b.delete(t);
+      e.controllers.clear(), this.#y.delete(e), e.adapter = null, e.challenge = null, e.priorConnection = null, e.request = null, e.state = null, e.transactionExpiresAtMs = null, e.transactionId = null, e.verifier = null, e.cleanup.resolve();
     }
   }
   #Q() {
-    if (!(this.#Y || this.#r)) {
-      this.#Y = !0, this.#C = !0;
+    if (!(this.#$ || this.#r)) {
+      this.#$ = !0, this.#x = !0;
       try {
-        let t = null;
+        let e = null;
         try {
-          const o = this.#t.getStorage;
-          t = typeof o == "function" ? Reflect.apply(o, void 0, []) : this.#t.storage ?? null;
+          const o = this.#e.getStorage;
+          e = typeof o == "function" ? Reflect.apply(o, void 0, []) : this.#e.storage ?? null;
         } catch {
-          t = null, this.#l = !0;
+          e = null, this.#l = !0;
         }
         try {
-          (!t || typeof t.getItem != "function" || typeof t.removeItem != "function") && (this.#l = !0);
+          (!e || typeof e.getItem != "function" || typeof e.removeItem != "function") && (this.#l = !0);
         } catch {
           this.#l = !0;
         }
@@ -1218,117 +1375,117 @@ class zt {
           this.#u = null;
           return;
         }
-        if (this.#u = t, this.#Z(), this.#r || this.#l) {
+        if (this.#u = e, this.#Z(), this.#r || this.#l) {
           this.#u = null;
           return;
         }
-        const e = (o) => {
+        const t = (o) => {
           const n = this.#o;
           if (!n || !this.#c(n)) return;
-          const l = `${P}${n.state}`;
-          o?.key === l && this.#N(n, !0);
+          const a = `${k}${n.state}`;
+          o?.key === a && this.#N(n, !0);
         };
-        this.#I = e;
-        let i = !1, s = null;
+        this.#T = t;
+        let s = !1, i = null;
         try {
-          const o = this.#m?.addEventListener, n = this.#m?.removeEventListener;
+          const o = this.#p?.addEventListener, n = this.#p?.removeEventListener;
           if (typeof o != "function" || typeof n != "function")
             throw new TypeError("storage events unavailable");
-          s = () => Reflect.apply(
+          i = () => Reflect.apply(
             n,
-            this.#m,
-            ["storage", e]
-          ), this.#A = s, Reflect.apply(o, this.#m, ["storage", this.#I]), i = !0;
+            this.#p,
+            ["storage", t]
+          ), this.#A = i, Reflect.apply(o, this.#p, ["storage", this.#T]), s = !0;
         } catch {
           this.#l = !0;
         }
-        if (!i || this.#r || this.#l) {
+        if (!s || this.#r || this.#l) {
           try {
-            s?.();
+            i?.();
           } catch {
           }
-          this.#I = null, this.#A = null, this.#u = null;
+          this.#T = null, this.#A = null, this.#u = null;
         }
       } finally {
-        this.#C = !1;
+        this.#x = !1;
       }
     }
   }
   #Z() {
-    const t = this.#u;
-    if (!t) return;
-    let e;
+    const e = this.#u;
+    if (!e) return;
+    let t;
     try {
-      e = t.length;
+      t = e.length;
     } catch {
       return;
     }
-    if (!Number.isSafeInteger(e) || e < 0) return;
-    const i = Math.min(e, $t), s = [];
-    for (let o = 0; o < i && !this.#r && !this.#l; o += 1) {
+    if (!Number.isSafeInteger(t) || t < 0) return;
+    const s = Math.min(t, At), i = [];
+    for (let o = 0; o < s && !this.#r && !this.#l; o += 1) {
       let n;
       try {
-        n = t.key(o);
+        n = e.key(o);
       } catch {
         continue;
       }
-      s.push(n);
+      i.push(n);
     }
-    for (const o of s) {
+    for (const o of i) {
       if (this.#r || this.#l) return;
-      if (typeof o != "string" || !o.startsWith(P)) continue;
-      const n = o.slice(P.length);
-      if (_.test(n))
+      if (typeof o != "string" || !o.startsWith(k)) continue;
+      const n = o.slice(k.length);
+      if (P.test(n))
         try {
-          const l = t.getItem(o);
-          if (l === null) continue;
-          const a = j(
-            N(l, 2048),
+          const a = e.getItem(o);
+          if (a === null) continue;
+          const l = U(
+            $(a, 2048),
             ["code", "expiresAt", "schemaVersion", "state"],
             "CALLBACK_ERROR"
           );
-          if (a.schemaVersion !== 1 || a.state !== n || !_.test(a.code))
+          if (l.schemaVersion !== 1 || l.state !== n || !P.test(l.code))
             continue;
-          g(a.expiresAt, "CALLBACK_ERROR") <= this.#s() && t.removeItem(o);
+          M(l.expiresAt, "CALLBACK_ERROR") <= this.#i() && e.removeItem(o);
         } catch {
         }
     }
   }
 }
-function Xt(r) {
-  return new zt(r);
+function he(r) {
+  return new St(r);
 }
-function Ht(r, t = {}) {
-  const e = (s, o) => s !== 0 ? Promise.reject(c("INVALID_REQUEST")) : o(), i = {
-    connect(...s) {
-      return e(s.length, () => r.execute("connect", void 0));
+function de(r, e = {}) {
+  const t = (i, o) => i !== 0 ? Promise.reject(c("INVALID_REQUEST")) : o(), s = {
+    connect(...i) {
+      return t(i.length, () => r.execute("connect", void 0));
     },
-    destroy(...s) {
-      return e(s.length, () => r.destroy());
+    destroy(...i) {
+      return t(i.length, () => r.destroy());
     },
-    disconnect(...s) {
-      return e(s.length, () => r.disconnect());
+    disconnect(...i) {
+      return t(i.length, () => r.disconnect());
     },
-    getSnapshot(...s) {
-      if (s.length !== 0) throw c("INVALID_REQUEST");
+    getSnapshot(...i) {
+      if (i.length !== 0) throw c("INVALID_REQUEST");
       return r.getSnapshot();
     },
-    openAccount(...s) {
-      return e(s.length, () => r.execute("account", void 0));
+    openAccount(...i) {
+      return t(i.length, () => r.execute("account", void 0));
     },
-    subscribe(s, ...o) {
+    subscribe(i, ...o) {
       if (o.length !== 0) throw c("INVALID_REQUEST");
-      return r.subscribe(s);
+      return r.subscribe(i);
     }
   };
-  for (const [s, o] of Object.entries(t))
-    i[s] = function(l, ...a) {
-      return a.length !== 0 ? Promise.reject(c("INVALID_REQUEST")) : r.execute(o, l);
+  for (const [i, o] of Object.entries(e))
+    s[i] = function(a, ...l) {
+      return l.length !== 0 ? Promise.reject(c("INVALID_REQUEST")) : r.execute(o, a);
     };
-  return Object.freeze(i);
+  return Object.freeze(s);
 }
-const Qt = Object.freeze([
-  "orbpro-pages-v1",
+const xt = Object.freeze([
+  "digitalarsenal-pages-v1",
   "sdn-asset-models-pages-v1",
   "sdn-asset-review-v1",
   "sdn-flatbuffers-pages-v1",
@@ -1339,41 +1496,108 @@ const Qt = Object.freeze([
   "sdn-standards-web-v1",
   "spaceaware-web-v1"
 ]);
-function Zt(r) {
-  let t;
+function Ct(r) {
+  let e;
   try {
-    const e = Reflect.ownKeys(r);
-    if (r === null || typeof r != "object" || Array.isArray(r) || Object.getPrototypeOf(r) !== Object.prototype || e.length !== 1 || e[0] !== "clientId")
+    const t = Reflect.ownKeys(r);
+    if (r === null || typeof r != "object" || Array.isArray(r) || Object.getPrototypeOf(r) !== Object.prototype || t.length !== 1 || t[0] !== "clientId")
       throw c("INVALID_REQUEST");
-    t = Object.getOwnPropertyDescriptor(r, "clientId");
+    e = Object.getOwnPropertyDescriptor(r, "clientId");
   } catch {
     throw c("INVALID_REQUEST");
   }
-  if (!t?.enumerable || !("value" in t) || typeof t.value != "string")
+  if (!e?.enumerable || !("value" in e) || typeof e.value != "string")
     throw c("INVALID_REQUEST");
-  if (!Qt.includes(t.value)) throw c("INVALID_CLIENT");
-  return t.value;
+  if (!xt.includes(e.value)) throw c("INVALID_CLIENT");
+  return e.value;
 }
-const Gt = Object.freeze({
+const ye = Object.freeze({
   account: Object.freeze({
-    buildRequest: () => xt({}),
+    buildRequest: () => Je({}),
     kind: "account",
     operation: "sdn.wallet.account.v1",
-    parseResult: Nt
+    parseResult: We
   }),
   connect: Object.freeze({
-    buildRequest: () => Ct({}),
+    buildRequest: () => ze({}),
     kind: "connect",
     operation: "sdn.wallet.connect.v1",
-    parseResult: Pt
+    parseResult: He
   })
 });
-function te(r) {
+function Le(r, e) {
+  if (et(r) !== e) throw c("INVALID_REQUEST");
+}
+function Te({ operation: r, buildRequest: e, parseRequest: t, parseResult: s, openResult: i }) {
+  return Object.freeze({
+    buildRequest: e,
+    kind: "typed",
+    operation: r,
+    parseResult: s,
+    async seal(o, n) {
+      let a;
+      try {
+        a = await ht(n);
+      } catch {
+        throw c("CRYPTO_UNAVAILABLE");
+      }
+      return Object.freeze({
+        request: t({ ...o, replyPublicKeyHex: a.publicKeyHex }),
+        async open(l) {
+          const f = l.fields.map((d) => d.status === "opened" ? I(d.ciphertextBase64url, 1, E.fieldBytes, "reply") : null);
+          let h;
+          try {
+            h = await a.open(l.replyEphemeralPublicKeyHex, f);
+          } catch {
+            throw c("CRYPTO_UNAVAILABLE");
+          }
+          return i(h);
+        }
+      });
+    }
+  });
+}
+const Pt = (r) => Te({
+  operation: "sdn.wallet.field-open.v1",
+  buildRequest(e) {
+    const t = tt(e);
+    for (const s of t.fields) Le(s.context, r);
+    return t;
+  },
+  parseRequest: rt,
+  parseResult: st,
+  openResult: (e) => Object.freeze(e.map((t) => Object.freeze(t === null ? { refused: "NOT_ADDRESSED_TO_ACCOUNT" } : { plaintext: t })))
+}), Nt = (r) => Te({
+  operation: "sdn.wallet.key-unwrap.v1",
+  buildRequest(e) {
+    const t = it(e);
+    return Le(t.context, r), t;
+  },
+  parseRequest: nt,
+  parseResult: ot,
+  openResult([e]) {
+    if (e === null) throw c("NOT_ADDRESSED_TO_ACCOUNT");
+    if (e.length !== 32) throw c("RELAY_ERROR");
+    return Object.freeze({ contentKey: e });
+  }
+}), gt = Object.freeze({
+  "sdn-flatbuffers-pages-v1": Object.freeze({ method: "openFields", adapter: Pt("flatbuffers") }),
+  "sdn-flatsql-pages-v1": Object.freeze({ method: "unwrapKey", adapter: Nt("flatsql") })
+});
+function Dt(r) {
   if (arguments.length !== 1) throw c("INVALID_REQUEST");
-  const t = Zt(r), e = Xt({ adapters: Gt, clientId: t });
-  return Ht(e);
+  const e = Ct(r), t = gt[e];
+  if (!t) {
+    const i = he({ adapters: ye, clientId: e });
+    return de(i);
+  }
+  const s = he({
+    adapters: Object.freeze({ ...ye, sealed: t.adapter }),
+    clientId: e
+  });
+  return de(s, { [t.method]: "sealed" });
 }
 export {
-  st as WALLET_CLIENT_ERRORS,
-  te as createWalletClient
+  Oe as WALLET_CLIENT_ERRORS,
+  Dt as createWalletClient
 };