hd-wallet-ui 2.0.21 → 2.0.27

package/dist/client/sdn.js

@@ -0,0 +1,1542 @@
+const we = Object.freeze({
+  cm: 0.01,
+  km: 1e3,
+  m: 1,
+  mm: 1e-3
+}), ve = Object.freeze({
+  metersPerSourceUnit: we,
+  quaternionNormTolerance: 1e-6,
+  scaleComponentExclusiveMin: 0,
+  scaleComponentInclusiveMax: 1e6,
+  translationComponentAbsMax: 1e6,
+  upAxes: Object.freeze(["X_UP", "Y_UP", "Z_UP"])
+}), Le = Object.freeze({ reviewedTransform: ve, schemaVersion: 1 }), B = new TextEncoder(), le = Object.getPrototypeOf(Uint8Array.prototype), _e = Object.getOwnPropertyDescriptor(le, "buffer").get, Ie = Object.getOwnPropertyDescriptor(le, "length").get, Te = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get, G = typeof SharedArrayBuffer > "u" ? null : Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength").get, v = "sdn-bip32-slip10-purpose-v1", U = "password-scrypt-v2", N = "ed25519-over-sha256-jcs-v1", ee = "ed25519-raw-32-v1", W = "sdn-login:sdn.spaceaware.io", xe = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u, P = /^[0-9a-f]{64}$/u, ue = /^[0-9a-f]{128}$/u, F = /^sha256:[0-9a-f]{64}$/u, Ce = /^[1-9A-HJ-NP-Za-km-z]+$/u, he = 131072, Ne = [
+  "accountFingerprint",
+  "accountIndex",
+  "accountLabel",
+  "accountPeerId",
+  "accountXpub",
+  "identityScheme",
+  "keys",
+  "schemaVersion",
+  "seedProfile"
+], Pe = [
+  "bip32Fingerprint",
+  "curve",
+  "derivation",
+  "encoding",
+  "identityScheme",
+  "keyId",
+  "path",
+  "publicKeyHex",
+  "purpose",
+  "seedProfile",
+  "signatureProfile"
+], De = [
+  "connectionExpiresAt",
+  "event",
+  "identity",
+  "schemaVersion"
+], je = [
+  "algorithm",
+  "encoding",
+  "identityScheme",
+  "keyId",
+  "schemaVersion",
+  "signatureHex",
+  "signatureProfile"
+], ke = [
+  "algorithm",
+  "canonicalEnvelope",
+  "encoding",
+  "identityScheme",
+  "keyId",
+  "schemaVersion",
+  "signatureHex",
+  "signatureProfile",
+  "signedDigestSha256"
+];
+function a(r) {
+  throw new TypeError(r);
+}
+function z(r) {
+  if (r === null || typeof r != "object" || Array.isArray(r)) return !1;
+  const e = Object.getPrototypeOf(r);
+  return e === Object.prototype || e === null;
+}
+function w(r, e) {
+  typeof r != "string" && a(`${e} must be a string`);
+  for (let t = 0; t < r.length; t += 1) {
+    const n = r.charCodeAt(t);
+    let i = n;
+    if (n >= 55296 && n <= 56319) {
+      const o = r.charCodeAt(t + 1);
+      o >= 56320 && o <= 57343 || a(`${e} contains an unpaired surrogate`), i = 65536 + (n - 55296 << 10) + (o - 56320), t += 1;
+    } else n >= 56320 && n <= 57343 && a(`${e} contains an unpaired surrogate`);
+    ((i & 65535) === 65534 || (i & 65535) === 65535 || i >= 64976 && i <= 65007) && a(`${e} contains a Unicode noncharacter`);
+  }
+  return r;
+}
+function fe(r) {
+  typeof r != "string" && a("wire JSON must be a string"), B.encode(r).byteLength > he && a("wire JSON is too large"), r.charCodeAt(0) === 65279 && a("wire JSON must not contain a BOM");
+  let e = 0, t = 0;
+  const n = () => {
+    for (; e < r.length && /[\u0009\u000a\u000d\u0020]/u.test(r[e]); ) e += 1;
+  }, i = () => {
+    r[e] !== '"' && a("invalid JSON string");
+    const u = e;
+    for (e += 1; e < r.length; ) {
+      const l = r.charCodeAt(e);
+      if (l === 34) {
+        e += 1;
+        let f;
+        try {
+          f = JSON.parse(r.slice(u, e));
+        } catch {
+          a("invalid JSON string");
+        }
+        return w(f, "JSON string");
+      }
+      l < 32 && a("invalid JSON control character"), l === 92 && (e += 1, e >= r.length && a("unterminated JSON escape")), e += 1;
+    }
+    a("unterminated JSON string");
+  }, o = (u = 0) => {
+    u > 32 && a("wire JSON nesting is too deep"), t += 1, t > 4096 && a("wire JSON contains too many values"), n();
+    const l = r[e];
+    if (l === '"') return i();
+    if (l === "{") {
+      e += 1;
+      const d = /* @__PURE__ */ Object.create(null), p = /* @__PURE__ */ new Set();
+      if (n(), r[e] === "}")
+        return e += 1, d;
+      for (; e < r.length; ) {
+        n();
+        const m = i();
+        if (p.has(m) && a(`duplicate JSON field: ${m}`), p.add(m), n(), r[e] !== ":" && a("missing JSON object colon"), e += 1, d[m] = o(u + 1), n(), r[e] === "}")
+          return e += 1, d;
+        r[e] !== "," && a("invalid JSON object separator"), e += 1;
+      }
+      a("unterminated JSON object");
+    }
+    if (l === "[") {
+      e += 1;
+      const d = [];
+      if (n(), r[e] === "]")
+        return e += 1, d;
+      for (; e < r.length; ) {
+        if (d.push(o(u + 1)), n(), r[e] === "]")
+          return e += 1, d;
+        r[e] !== "," && a("invalid JSON array separator"), e += 1;
+      }
+      a("unterminated JSON array");
+    }
+    for (const [d, p] of [["true", !0], ["false", !1], ["null", null]])
+      if (r.startsWith(d, e))
+        return e += d.length, p;
+    const f = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(r.slice(e));
+    f || a("invalid JSON value"), e += f[0].length;
+    const h = Number(f[0]);
+    return Number.isFinite(h) || a("wire JSON number must be finite"), h;
+  };
+  n();
+  const s = o();
+  return n(), e !== r.length && a("wire JSON contains trailing bytes"), s;
+}
+function Ve(r) {
+  return typeof r == "string" ? fe(r) : r;
+}
+function $e(r, e) {
+  if (r.byteLength !== e.byteLength) return !1;
+  let t = 0;
+  for (let n = 0; n < r.byteLength; n += 1) t |= r[n] ^ e[n];
+  return t === 0;
+}
+function R(r, e, t) {
+  const n = Ve(r);
+  z(n) || a(`${t} must be a JSON object`), Object.getOwnPropertySymbols(n).length !== 0 && a(`${t} has an unknown symbol field`);
+  const i = Object.getOwnPropertyNames(n).sort(), o = [...e].sort(), s = B.encode(i.join("\0")), u = B.encode(o.join("\0"));
+  $e(s, u) || a(`${t} has missing or unknown fields`);
+  for (const l of i) {
+    const f = Object.getOwnPropertyDescriptor(n, l);
+    (!f || !f.enumerable || !("value" in f)) && a(`${t}.${l} must be an enumerable data field`), f.value === void 0 && a(`${t}.${l} must not be undefined`);
+  }
+  return n;
+}
+function J(r) {
+  if (!r || typeof r != "object" || Object.isFrozen(r)) return r;
+  for (const e of Object.values(r)) J(e);
+  return Object.freeze(r);
+}
+function g(r) {
+  return J(Object.fromEntries([...r].sort(([e], [t]) => e < t ? -1 : e > t ? 1 : 0)));
+}
+function de(r, e, t) {
+  (!Array.isArray(r) || Object.getPrototypeOf(r) !== Array.prototype || r.length !== e) && a(`${t} must be a plain array with exactly ${e} values`);
+  const n = [...Array.from({ length: e }, (o, s) => String(s)), "length"], i = Reflect.ownKeys(r);
+  (i.length !== n.length || i.some((o, s) => o !== n[s])) && a(`${t} must be a dense plain array`);
+  for (let o = 0; o < e; o += 1) {
+    const s = Object.getOwnPropertyDescriptor(r, String(o));
+    (!s || !s.enumerable || !("value" in s) || s.value === void 0) && a(`${t} must contain enumerable data values`);
+  }
+}
+function Me(r) {
+  const e = R(
+    r,
+    ["reviewedTransform", "schemaVersion"],
+    "asset review protocol policy"
+  );
+  y(e.schemaVersion, 1, "asset review protocol schemaVersion");
+  const t = R(e.reviewedTransform, [
+    "metersPerSourceUnit",
+    "quaternionNormTolerance",
+    "scaleComponentExclusiveMin",
+    "scaleComponentInclusiveMax",
+    "translationComponentAbsMax",
+    "upAxes"
+  ], "asset review transform policy"), n = R(
+    t.metersPerSourceUnit,
+    ["cm", "km", "m", "mm"],
+    "asset review unit policy"
+  );
+  for (const [i, o] of Object.entries(n))
+    (typeof o != "number" || !Number.isFinite(o) || o <= 0) && a(`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)) && a(`asset review transform policy ${i} must be finite`);
+  return (t.quaternionNormTolerance <= 0 || t.scaleComponentInclusiveMax <= t.scaleComponentExclusiveMin || t.translationComponentAbsMax <= 0) && a("asset review transform policy bounds are inconsistent"), de(t.upAxes, 3, "asset review up-axis policy"), t.upAxes.join("\0") !== "X_UP\0Y_UP\0Z_UP" && a("asset review up-axis policy is invalid"), g([
+    ["metersPerSourceUnit", g(Object.entries(n))],
+    ["quaternionNormTolerance", t.quaternionNormTolerance],
+    ["scaleComponentExclusiveMin", t.scaleComponentExclusiveMin],
+    ["scaleComponentInclusiveMax", t.scaleComponentInclusiveMax],
+    ["translationComponentAbsMax", t.translationComponentAbsMax],
+    ["upAxes", Object.freeze(Array.from({ length: 3 }, (i, o) => t.upAxes[o]))]
+  ]);
+}
+Me(Le);
+function y(r, e, t) {
+  return r !== e && a(`${t} must equal ${JSON.stringify(e)}`), r;
+}
+function ye(r, e, t) {
+  return e.includes(r) || a(`${t} is not an allowed value`), r;
+}
+function A(r, e, t) {
+  return w(r, t), e.test(r) || a(`${t} has an invalid encoding`), r;
+}
+function D(r, e) {
+  return w(r, e), (!xe.test(r) || new Date(r).toISOString() !== r) && a(`${e} must be exact RFC3339 milliseconds UTC`), r;
+}
+function pe(r, e) {
+  const t = Date.parse(r), n = Date.parse(e);
+  n > t && n - t <= 3e5 || a("request lifetime must be in (0, 300] seconds");
+}
+function H(r, e) {
+  (!ArrayBuffer.isView(r) || !(r instanceof Uint8Array) || Object.getPrototypeOf(r) !== Uint8Array.prototype) && a(`${e} must be a plain Uint8Array`), Ie.call(r) !== 32 && a(`${e} must be exactly 32 bytes`);
+  const n = Array.from({ length: 32 }, (h, d) => String(d)), i = Reflect.ownKeys(r);
+  (i.length !== n.length || i.some((h, d) => h !== n[d])) && a(`${e} Uint8Array must contain only 32 indexed bytes`);
+  const o = _e.call(r);
+  let s = !1;
+  if (G)
+    try {
+      G.call(o), s = !0;
+    } catch {
+      s = !1;
+    }
+  s && a(`${e} must not use SharedArrayBuffer storage`);
+  try {
+    Te.call(o);
+  } catch {
+    a(`${e} must use ArrayBuffer storage`);
+  }
+  const u = new Uint8Array(32);
+  for (let h = 0; h < 32; h += 1) {
+    const d = Object.getOwnPropertyDescriptor(r, String(h));
+    (!d || !d.enumerable || !("value" in d) || !Number.isInteger(d.value) || d.value < 0 || d.value > 255) && a(`${e} Uint8Array contains an invalid indexed byte`), u[h] = r[h];
+  }
+  let l = "";
+  for (let h = 0; h < 32; h += 1) l += String.fromCharCode(u[h]);
+  const f = globalThis.btoa(l).replace(/\+/gu, "-").replace(/\//gu, "_").replace(/=+$/gu, "");
+  return f.length !== 43 && a(`${e} did not encode to 43 base64url characters`), f;
+}
+function me(r, e) {
+  w(r, e), /^[A-Za-z0-9_-]{43}$/u.test(r) || a(`${e} must be canonical unpadded base64url`);
+  let t;
+  try {
+    t = globalThis.atob(`${r.replace(/-/gu, "+").replace(/_/gu, "/")}=`);
+  } catch {
+    a(`${e} must be valid base64url`);
+  }
+  const n = Uint8Array.from(t, (i) => i.charCodeAt(0));
+  return (n.byteLength !== 32 || H(n, e) !== r) && a(`${e} must canonically encode exactly 32 bytes`), r;
+}
+function K(r) {
+  return r === null || typeof r == "boolean" ? JSON.stringify(r) : typeof r == "string" ? (w(r, "canonical JSON string"), JSON.stringify(r)) : typeof r == "number" ? (Number.isFinite(r) || a("canonical JSON numbers must be finite"), JSON.stringify(r)) : Array.isArray(r) ? `[${r.map(K).join(",")}]` : (z(r) || a("canonical JSON contains an unsupported value"), `{${Object.keys(r).sort().map((e) => `${JSON.stringify(e)}:${K(r[e])}`).join(",")}}`);
+}
+function Ye(r, e) {
+  for (const t of ["identityScheme", "keyId", "signatureProfile"])
+    r[t] !== e[t] && a(`canonicalEnvelope ${t} must match the signature result`);
+}
+function Be(r, e) {
+  const n = R(r, [
+    "audience",
+    "challengeSha256",
+    "clientId",
+    "expiresAt",
+    "identityScheme",
+    "issuedAt",
+    "keyId",
+    "kind",
+    "nonce",
+    "protocolVersion",
+    "requestOrigin",
+    "signatureProfile"
+  ], "SDN login canonicalEnvelope");
+  Ye(n, e), y(n.audience, W, "SDN login envelope audience"), A(n.challengeSha256, P, "SDN login envelope challengeSha256"), y(n.clientId, "sdn-node-console-v1", "SDN login envelope clientId"), D(n.issuedAt, "SDN login envelope issuedAt"), D(n.expiresAt, "SDN login envelope expiresAt"), pe(n.issuedAt, n.expiresAt), y(n.identityScheme, v, "SDN login envelope identityScheme"), A(n.keyId, F, "SDN login envelope keyId"), y(n.kind, "sdn-login", "SDN login envelope kind"), A(n.nonce, P, "SDN login envelope nonce"), y(n.protocolVersion, 2, "SDN login envelope protocolVersion"), y(n.requestOrigin, "https://sdn.spaceaware.io", "SDN login envelope requestOrigin"), y(n.signatureProfile, N, "SDN login envelope signatureProfile");
+}
+function Ue(r, e, t) {
+  w(r, "canonicalEnvelope"), B.encode(r).byteLength > he && a("canonicalEnvelope is too large");
+  const n = fe(r);
+  return (!z(n) || n.kind !== e) && a("canonicalEnvelope kind does not match the operation"), K(n) !== r && a("canonicalEnvelope must be exact JCS"), Be(n, t), r;
+}
+function Fe(r, e) {
+  const t = R(r, Pe, `identity key ${e.purpose}`);
+  return y(t.purpose, e.purpose, "key purpose"), y(t.identityScheme, v, "key identityScheme"), y(t.seedProfile, U, "key seedProfile"), y(t.signatureProfile, e.signatureProfile, "key signatureProfile"), y(t.curve, e.curve, "key curve"), y(t.derivation, "slip10", "key derivation"), y(t.path, e.path, "key path"), y(t.encoding, "raw", "key encoding"), A(t.publicKeyHex, P, "key publicKeyHex"), y(t.bip32Fingerprint, null, "key bip32Fingerprint"), A(t.keyId, F, "key keyId"), g([
+    ["bip32Fingerprint", null],
+    ["curve", t.curve],
+    ["derivation", "slip10"],
+    ["encoding", "raw"],
+    ["identityScheme", v],
+    ["keyId", t.keyId],
+    ["path", t.path],
+    ["publicKeyHex", t.publicKeyHex],
+    ["purpose", t.purpose],
+    ["seedProfile", U],
+    ["signatureProfile", t.signatureProfile]
+  ]);
+}
+function Je(r) {
+  const e = R(r, Ne, "WalletPublicIdentity");
+  y(e.schemaVersion, 1, "identity schemaVersion"), y(e.identityScheme, v, "identity identityScheme"), y(e.seedProfile, U, "identity seedProfile"), e.accountIndex !== 0 && a("public wallet identity must use account 0"), y(e.accountLabel, null, "identity accountLabel"), w(e.accountXpub, "identity accountXpub"), /^xpub[1-9A-HJ-NP-Za-km-z]{107}$/u.test(e.accountXpub) || a("identity accountXpub is invalid"), w(e.accountPeerId, "identity accountPeerId"), (!e.accountPeerId.startsWith("16Uiu2H") || e.accountPeerId.length < 40 || e.accountPeerId.length > 64 || !Ce.test(e.accountPeerId)) && a("identity accountPeerId is invalid"), A(e.accountFingerprint, /^[0-9a-f]{8}$/u, "identity accountFingerprint"), de(e.keys, 3, "public identity keys array");
+  const t = [
+    {
+      purpose: "asset-review-approval",
+      curve: "ed25519",
+      signatureProfile: N,
+      path: "m/44'/0'/0'/2'/0'"
+    },
+    {
+      purpose: "contact-encryption",
+      curve: "x25519",
+      signatureProfile: null,
+      path: "m/44'/0'/0'/1'/0'"
+    },
+    {
+      purpose: "sdn-authentication",
+      curve: "ed25519",
+      signatureProfile: N,
+      path: "m/44'/0'/0'/0'/0'"
+    }
+  ], n = Array.from(
+    { length: 3 },
+    (i, o) => Fe(e.keys[o], t[o])
+  );
+  return g([
+    ["accountFingerprint", e.accountFingerprint],
+    ["accountIndex", 0],
+    ["accountLabel", null],
+    ["accountPeerId", e.accountPeerId],
+    ["accountXpub", e.accountXpub],
+    ["identityScheme", v],
+    ["keys", J(n)],
+    ["schemaVersion", 1],
+    ["seedProfile", U]
+  ]);
+}
+function Re(r, e) {
+  const t = R(r, De, `${e} result`);
+  y(t.schemaVersion, 1, "connection result schemaVersion"), ye(t.event, ["connected", "disconnected"], "connection event"), e === "connect" && t.event !== "connected" && a("connect result must be connected");
+  let n = null, i = null;
+  return t.event === "connected" ? (n = Je(t.identity), i = D(t.connectionExpiresAt, "connectionExpiresAt")) : (t.identity !== null || t.connectionExpiresAt !== null) && a("disconnected result must clear identity and expiry"), g([
+    ["connectionExpiresAt", i],
+    ["event", t.event],
+    ["identity", n],
+    ["schemaVersion", 1]
+  ]);
+}
+function qe(r) {
+  const e = R(r, je, "raw signature");
+  return y(e.schemaVersion, 1, "signature schemaVersion"), A(e.keyId, F, "signature keyId"), ye(e.identityScheme, [
+    "sdn-fast-password-auth-v1-legacy",
+    "sdn-bip39-auth-v1-legacy"
+  ], "raw signature identityScheme"), y(e.algorithm, "ed25519", "signature algorithm"), y(e.encoding, "raw", "signature encoding"), y(e.signatureProfile, ee, "signature profile"), A(e.signatureHex, ue, "signatureHex"), g([
+    ["algorithm", "ed25519"],
+    ["encoding", "raw"],
+    ["identityScheme", e.identityScheme],
+    ["keyId", e.keyId],
+    ["schemaVersion", 1],
+    ["signatureHex", e.signatureHex],
+    ["signatureProfile", ee]
+  ]);
+}
+function We(r, e) {
+  const t = R(r, ke, "canonical signature");
+  return y(t.schemaVersion, 1, "signature schemaVersion"), A(t.keyId, F, "signature keyId"), y(t.identityScheme, v, "signature identityScheme"), y(t.algorithm, "ed25519", "signature algorithm"), y(t.encoding, "raw", "signature encoding"), y(t.signatureProfile, N, "signature profile"), Ue(t.canonicalEnvelope, e, t), A(t.signedDigestSha256, P, "signedDigestSha256"), A(t.signatureHex, ue, "signatureHex"), g([
+    ["algorithm", "ed25519"],
+    ["canonicalEnvelope", t.canonicalEnvelope],
+    ["encoding", "raw"],
+    ["identityScheme", v],
+    ["keyId", t.keyId],
+    ["schemaVersion", 1],
+    ["signatureHex", t.signatureHex],
+    ["signatureProfile", N],
+    ["signedDigestSha256", t.signedDigestSha256]
+  ]);
+}
+function Ke(r) {
+  const e = R(r, ["challengeBase64url", "protocolVersion"], "SDN login v1 request");
+  return y(e.protocolVersion, 1, "SDN login v1 protocolVersion"), me(e.challengeBase64url, "challengeBase64url"), g([
+    ["challengeBase64url", e.challengeBase64url],
+    ["protocolVersion", 1]
+  ]);
+}
+function ze(r) {
+  const e = R(r, [
+    "audience",
+    "challengeBase64url",
+    "expiresAt",
+    "issuedAt",
+    "nonce",
+    "protocolVersion"
+  ], "SDN login v2 request");
+  return y(e.protocolVersion, 2, "SDN login v2 protocolVersion"), y(e.audience, W, "SDN login v2 audience"), me(e.challengeBase64url, "challengeBase64url"), A(e.nonce, P, "SDN login nonce"), D(e.issuedAt, "SDN login issuedAt"), D(e.expiresAt, "SDN login expiresAt"), pe(e.issuedAt, e.expiresAt), g([
+    ["audience", W],
+    ["challengeBase64url", e.challengeBase64url],
+    ["expiresAt", e.expiresAt],
+    ["issuedAt", e.issuedAt],
+    ["nonce", e.nonce],
+    ["protocolVersion", 2]
+  ]);
+}
+function Ae(r, e) {
+  return R(r, [], e), J({});
+}
+function He(r = {}) {
+  return Ae(r, "wallet connect request");
+}
+function Xe(r) {
+  return Re(r, "connect");
+}
+function Qe(r = {}) {
+  return Ae(r, "wallet account request");
+}
+function Ze(r) {
+  return Re(r, "account");
+}
+function Ge(r) {
+  const e = R(r, ["challenge", "protocolVersion"], "SDN login v1 public request");
+  return y(e.protocolVersion, 1, "SDN login v1 protocolVersion"), Ke({
+    challengeBase64url: H(e.challenge, "challenge"),
+    protocolVersion: 1
+  });
+}
+function et(r) {
+  return qe(r);
+}
+function tt(r) {
+  const e = R(r, [
+    "audience",
+    "challenge",
+    "expiresAt",
+    "issuedAt",
+    "nonce",
+    "protocolVersion"
+  ], "SDN login v2 public request");
+  return ze({
+    audience: e.audience,
+    challengeBase64url: H(e.challenge, "challenge"),
+    expiresAt: e.expiresAt,
+    issuedAt: e.issuedAt,
+    nonce: e.nonce,
+    protocolVersion: e.protocolVersion
+  });
+}
+function rt(r) {
+  return We(r, "sdn-login");
+}
+const _ = "https://wallet.spacedatanetwork.org", j = "sdn.wallet.callback.v1:", T = /^[0-9a-f]{64}$/u, te = /^[A-Za-z0-9_-]{43}$/u, nt = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u, it = 250, st = 3e4, ot = 3e5, ct = 9e5, at = 12e4, lt = 8, re = 4096, ne = 70 * 1024, ut = 64, Ee = 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.",
+  DISCONNECTED: "The wallet was disconnected.",
+  EXPIRED: "The wallet connection expired.",
+  INVALID_CLIENT: "This wallet client is not registered.",
+  INVALID_REQUEST: "The wallet request is invalid.",
+  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."
+}), be = new TextEncoder(), ht = new TextDecoder("utf-8", { fatal: !0 });
+class C extends Error {
+  constructor(e) {
+    super(Ee[e]), this.name = "WalletClientError", Object.defineProperty(this, "code", {
+      configurable: !1,
+      enumerable: !0,
+      value: e,
+      writable: !1
+    });
+  }
+}
+function c(r) {
+  return Object.hasOwn(Ee, r) ? new C(r) : new C("RELAY_ERROR");
+}
+function ft(r) {
+  if (r === null || typeof r != "object" || Array.isArray(r)) return !1;
+  const e = Object.getPrototypeOf(r);
+  return e === Object.prototype || e === null;
+}
+function V(r, e) {
+  if (typeof r != "string" || r.length > e || be.encode(r).byteLength > e || r.charCodeAt(0) === 65279)
+    throw c("RELAY_ERROR");
+  let t = 0, n = 0;
+  const i = () => {
+    for (; t < r.length && /[\u0009\u000a\u000d\u0020]/u.test(r[t]); ) t += 1;
+  }, o = () => {
+    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 {
+          h = JSON.parse(r.slice(l, t));
+        } catch {
+          throw c("RELAY_ERROR");
+        }
+        for (let d = 0; d < h.length; d += 1) {
+          const p = h.charCodeAt(d);
+          if (p >= 55296 && p <= 56319) {
+            const m = h.charCodeAt(d + 1);
+            if (!(m >= 56320 && m <= 57343)) throw c("RELAY_ERROR");
+            d += 1;
+          } else if (p >= 56320 && p <= 57343)
+            throw c("RELAY_ERROR");
+        }
+        return h;
+      }
+      if (f < 32 || f === 92 && (t += 1, t >= r.length))
+        throw c("RELAY_ERROR");
+      t += 1;
+    }
+    throw c("RELAY_ERROR");
+  }, s = (l = 0) => {
+    if (l > 32 || ++n > 4096) throw c("RELAY_ERROR");
+    i();
+    const f = r[t];
+    if (f === '"') return o();
+    if (f === "{") {
+      t += 1;
+      const p = /* @__PURE__ */ Object.create(null), m = /* @__PURE__ */ new Set();
+      if (i(), r[t] === "}")
+        return t += 1, p;
+      for (; t < r.length; ) {
+        i();
+        const O = o();
+        if (m.has(O) || (m.add(O), i(), r[t] !== ":")) throw c("RELAY_ERROR");
+        if (t += 1, p[O] = s(l + 1), i(), r[t] === "}")
+          return t += 1, p;
+        if (r[t] !== ",") throw c("RELAY_ERROR");
+        t += 1;
+      }
+      throw c("RELAY_ERROR");
+    }
+    if (f === "[") {
+      t += 1;
+      const p = [];
+      if (i(), r[t] === "]")
+        return t += 1, p;
+      for (; t < r.length; ) {
+        if (p.push(s(l + 1)), i(), r[t] === "]")
+          return t += 1, p;
+        if (r[t] !== ",") throw c("RELAY_ERROR");
+        t += 1;
+      }
+      throw c("RELAY_ERROR");
+    }
+    for (const [p, m] of [["true", !0], ["false", !1], ["null", null]])
+      if (r.startsWith(p, t))
+        return t += p.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;
+  };
+  i();
+  const u = s();
+  if (i(), t !== r.length) throw c("RELAY_ERROR");
+  return u;
+}
+function $(r, e, t = "RELAY_ERROR") {
+  if (!ft(r) || Object.getOwnPropertySymbols(r).length !== 0)
+    throw c(t);
+  const n = Object.getOwnPropertyNames(r).sort(), i = [...e].sort();
+  if (n.length !== i.length || n.some((o, s) => o !== i[s]))
+    throw c(t);
+  for (const o of n) {
+    const s = Object.getOwnPropertyDescriptor(r, o);
+    if (!s?.enumerable || !("value" in s) || s.value === void 0)
+      throw c(t);
+  }
+  return r;
+}
+function M(r, e = "RELAY_ERROR") {
+  if (typeof r != "string" || !nt.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 S(r) {
+  return Array.isArray(r) ? Object.freeze(r.map(S)) : r && typeof r == "object" ? Object.freeze(Object.fromEntries(
+    Object.entries(r).map(([e, t]) => [e, S(t)])
+  )) : r;
+}
+function ie(r) {
+  const e = {
+    identity: r.identity === null ? null : S(r.identity),
+    status: r.status
+  };
+  return r.connectionExpiresAt !== void 0 && (e.connectionExpiresAt = r.connectionExpiresAt), r.error !== void 0 && (e.error = S(r.error)), S(e);
+}
+function I(r) {
+  return Object.freeze({ code: r.code, message: r.message });
+}
+function se(r) {
+  const e = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  let t = 0, n = 0, i = "";
+  for (const o of r)
+    for (t = t << 8 | o, n += 8; n >= 6; )
+      n -= 6, i += e[t >>> n & 63], t &= (1 << n) - 1;
+  return n !== 0 && (i += e[t << 6 - n & 63]), i;
+}
+function oe(r) {
+  let e = "";
+  for (const t of r) e += t.toString(16).padStart(2, "0");
+  return e;
+}
+function q(r, e) {
+  const t = new Uint8Array(32);
+  return Reflect.apply(e, r, [t]), t;
+}
+function dt(r) {
+  const e = r?.headers?.get?.("content-type");
+  return typeof e == "string" && /^application\/json(?:\s*;\s*charset=utf-8)?$/iu.test(e.trim());
+}
+function X(r) {
+  try {
+    Promise.resolve(r).catch(() => {
+    });
+  } catch {
+  }
+}
+function x(r) {
+  try {
+    const e = r?.body, t = e?.cancel;
+    typeof t == "function" && X(Reflect.apply(t, e, []));
+  } catch {
+  }
+}
+function ge(r) {
+  try {
+    const e = r?.cancel;
+    typeof e == "function" && X(Reflect.apply(e, r, []));
+  } catch {
+  }
+}
+function yt(r) {
+  try {
+    const e = r?.releaseLock;
+    typeof e == "function" && Reflect.apply(e, r, []);
+  } catch {
+  }
+}
+function L(r, e, t = null) {
+  try {
+    r.abort();
+  } catch {
+  }
+  t && ge(t), x(e);
+}
+function Y(r, e, t = null) {
+  let n;
+  try {
+    n = Promise.resolve(r);
+  } catch (i) {
+    return Promise.reject(i);
+  }
+  return new Promise((i, o) => {
+    let s = !1;
+    const u = () => {
+      try {
+        e.removeEventListener("abort", f);
+      } catch {
+      }
+    }, l = (h, d) => s ? !1 : (s = !0, u(), h(d), !0), f = () => {
+      l(o, c("RELAY_ERROR"));
+    };
+    try {
+      e.addEventListener("abort", f, { once: !0 }), e.aborted && f();
+    } catch {
+      f();
+    }
+    n.then(
+      (h) => {
+        if (s) {
+          try {
+            t?.(h);
+          } catch {
+          }
+          return;
+        }
+        l(i, h);
+      },
+      (h) => {
+        s || l(o, h);
+      }
+    );
+  });
+}
+async function ce(r, e, t) {
+  let n = null;
+  const i = [];
+  let o = 0;
+  try {
+    if (!dt(r) || typeof r?.body?.getReader != "function")
+      throw c("RELAY_ERROR");
+    for (n = r.body.getReader(); ; ) {
+      const l = n.read(), { done: f, value: h } = await Y(l, t.signal);
+      if (f) break;
+      if (!(h instanceof Uint8Array) || (o += h.byteLength, o > e))
+        throw c("RELAY_ERROR");
+      i.push(h);
+    }
+    const s = new Uint8Array(o);
+    let u = 0;
+    for (const l of i)
+      s.set(l, u), u += l.byteLength;
+    return ht.decode(s);
+  } catch {
+    try {
+      t.abort();
+    } catch {
+    }
+    throw n && ge(n), c("RELAY_ERROR");
+  } finally {
+    n && yt(n);
+  }
+}
+function k(r, e) {
+  const t = {
+    body: JSON.stringify(r),
+    cache: "no-store",
+    credentials: "omit",
+    headers: { "Content-Type": "application/json" },
+    method: "POST",
+    mode: "cors",
+    redirect: "error",
+    referrerPolicy: "no-referrer"
+  };
+  return e !== void 0 && (t.signal = e), t;
+}
+function pt(r, e, t) {
+  let n;
+  try {
+    n = V(r, 2048), $(n, ["code", "expiresAt", "schemaVersion", "state"], "CALLBACK_ERROR");
+  } catch {
+    throw c("CALLBACK_ERROR");
+  }
+  if (n.schemaVersion !== 1 || n.state !== e || !T.test(n.code))
+    throw c("CALLBACK_ERROR");
+  const i = M(n.expiresAt, "CALLBACK_ERROR");
+  if (i <= t || i - t > at)
+    throw c("CALLBACK_ERROR");
+  return { code: n.code, expiresAt: i, state: n.state };
+}
+function mt() {
+  let r;
+  return { promise: new Promise((t) => {
+    r = t;
+  }), resolve: r };
+}
+function ae() {
+  let r, e;
+  return { promise: new Promise((n, i) => {
+    r = i, e = n;
+  }), reject: r, resolve: e };
+}
+function Rt() {
+  const r = globalThis.window;
+  return Object.freeze({
+    AbortController: globalThis.AbortController,
+    clearInterval: globalThis.clearInterval.bind(globalThis),
+    clearTimeout: globalThis.clearTimeout.bind(globalThis),
+    crypto: globalThis.crypto,
+    fetch: typeof globalThis.fetch == "function" ? globalThis.fetch.bind(globalThis) : void 0,
+    getStorage: () => {
+      try {
+        return r?.localStorage ?? null;
+      } catch {
+        return null;
+      }
+    },
+    now: () => Date.now(),
+    setInterval: globalThis.setInterval.bind(globalThis),
+    setTimeout: globalThis.setTimeout.bind(globalThis),
+    window: r
+  });
+}
+class At {
+  #k;
+  #V;
+  #T = !1;
+  #l = !1;
+  #$ = !1;
+  #s = null;
+  #O = null;
+  #E = /* @__PURE__ */ new Set();
+  #e;
+  #S = null;
+  #r = !1;
+  #m = 0;
+  #w = 0;
+  #v = /* @__PURE__ */ new Set();
+  #x = [];
+  #o = null;
+  #C = !1;
+  #y = /* @__PURE__ */ new Set();
+  #M = Object.freeze({ identity: null, status: "dormant" });
+  #u = null;
+  #L = null;
+  #b = null;
+  #R = /* @__PURE__ */ new Set();
+  #p;
+  constructor({ adapters: e, clientId: t, dependencies: n }) {
+    this.#k = e, this.#V = t, this.#e = n ?? Rt(), this.#p = this.#e.window;
+  }
+  getSnapshot() {
+    return this.#U(), ie(this.#M);
+  }
+  subscribe(e) {
+    if (typeof e != "function") throw c("INVALID_REQUEST");
+    if (this.#r) throw c("DESTROYED");
+    this.#v.add(e);
+    try {
+      e(this.getSnapshot());
+    } catch {
+    }
+    let t = !0;
+    return () => {
+      t && (t = !1, this.#v.delete(e));
+    };
+  }
+  execute(e, t) {
+    if (this.#r) return Promise.reject(c("DESTROYED"));
+    const n = this.#m, i = this.#k[e];
+    if (!i) return Promise.reject(c("INVALID_REQUEST"));
+    let o;
+    try {
+      o = i.buildRequest(t);
+    } catch {
+      const E = this.#t(n);
+      return E ? Promise.reject(E) : Promise.reject(c("INVALID_REQUEST"));
+    }
+    let s = this.#t(n);
+    if (s) return Promise.reject(s);
+    if (this.#T)
+      return this.#l = !0, Promise.reject(c("REPLACED"));
+    const u = ++this.#m;
+    if (this.#Q(), s = this.#t(u), s) return Promise.reject(s);
+    if (this.#l)
+      return Promise.reject(c("CALLBACK_ERROR"));
+    if (this.#U(), s = this.#t(u), s) return Promise.reject(s);
+    const l = this.#i();
+    if (s = this.#t(u), s) return Promise.reject(s);
+    const f = this.#s && this.#s.expiresAtMs > l ? this.#s : null;
+    if (s = this.#t(u), s) return Promise.reject(s);
+    const h = this.#o;
+    let d, p, m;
+    try {
+      const E = this.#e.crypto, b = E?.getRandomValues, Se = E?.subtle?.digest, Z = this.#p?.open;
+      if (s = this.#t(u), s) throw s;
+      if (typeof b != "function" || typeof Se != "function" || typeof Z != "function")
+        throw c("CRYPTO_UNAVAILABLE");
+      if (d = oe(q(E, b)), s = this.#t(u), s || (p = oe(q(E, b)), s = this.#t(u), s) || (m = se(q(E, b)), s = this.#t(u), s)) throw s;
+      if (!T.test(d) || !T.test(p) || !te.test(m))
+        throw c("CRYPTO_UNAVAILABLE");
+      if (Reflect.apply(Z, this.#p, [
+        `${_}/transaction/${d}`,
+        "_blank",
+        "noopener"
+      ]), s = this.#t(u), s) throw s;
+    } catch (E) {
+      if (s = this.#t(u), s) return Promise.reject(s);
+      let b;
+      try {
+        b = E instanceof C ? E : c("CRYPTO_UNAVAILABLE");
+      } catch {
+        b = c("CRYPTO_UNAVAILABLE");
+      }
+      return h && (this.#_(h, "REPLACED", !1), s = this.#t(u), s) ? Promise.reject(s) : (this.#Y(null, b, f, i.kind), Promise.reject(b));
+    }
+    if (h && (this.#_(h, "REPLACED", !1), s = this.#t(u), s))
+      return Promise.reject(s);
+    const O = ae(), Oe = mt(), Q = {
+      active: !0,
+      adapter: i,
+      callbackBusy: !1,
+      challenge: null,
+      cleanup: Oe,
+      cleanupFinished: !1,
+      cleanupStarted: !1,
+      controllers: /* @__PURE__ */ new Set(),
+      expiryTimer: null,
+      generation: ++this.#w,
+      operationTimer: null,
+      phase: "hashing",
+      pollTimer: null,
+      priorConnection: f,
+      promise: O.promise,
+      registrationDeadlineMs: l + st,
+      registrationOutcome: "none",
+      reject: O.reject,
+      request: o,
+      resolve: O.resolve,
+      retryResolve: null,
+      retryTimer: null,
+      state: p,
+      transactionExpiresAtMs: null,
+      transactionId: d,
+      verifier: m
+    };
+    return this.#o = Q, this.#n({
+      ...f ? {
+        connectionExpiresAt: f.expiresAt,
+        identity: f.identity
+      } : { identity: null },
+      status: "opening"
+    }), this.#q(Q), O.promise;
+  }
+  async disconnect() {
+    if (this.#r) throw c("DESTROYED");
+    const e = ++this.#m;
+    this.#f();
+    const t = this.#o;
+    let n = Promise.resolve();
+    t && (n = this.#_(t, "DISCONNECTED", !1));
+    let i = this.#t(e);
+    if (i)
+      throw await n, i;
+    if (this.#n({ identity: null, status: "dormant" }), await n, i = this.#t(e), i) throw i;
+  }
+  destroy() {
+    if (this.#S) return this.#S;
+    const e = ae();
+    this.#S = e.promise, this.#m += 1;
+    try {
+      this.#J(), e.resolve();
+    } catch {
+      e.reject(c("RELAY_ERROR"));
+    }
+    return this.#S;
+  }
+  #J() {
+    this.#r = !0, this.#w += 1, this.#f();
+    const e = [], t = this.#o;
+    t && (t.active = !1, this.#o = null, this.#I(t), t.reject(c("DESTROYED")), t.challenge && t.verifier && e.push(t));
+    for (const n of this.#y)
+      n.challenge && n.verifier && e.push(n);
+    for (const n of this.#E) n.abort();
+    this.#E.clear();
+    for (const n of this.#R)
+      this.#e.clearTimeout(n), this.#e.clearInterval(n);
+    if (this.#R.clear(), this.#b)
+      try {
+        this.#b();
+      } catch {
+      }
+    this.#L = null, this.#b = null, this.#u = null, this.#v.clear();
+    for (const n of e) this.#X(n);
+    t && this.#a(t);
+    for (const n of [...this.#y]) this.#a(n);
+    this.#n({
+      error: I(c("DESTROYED")),
+      identity: null,
+      status: "error"
+    });
+  }
+  async #q(e) {
+    if (!(!this.#c(e) || e.cleanupFinished))
+      try {
+        e.operationTimer = this.#g(() => {
+          if (!e.cleanupFinished) {
+            if (e.phase === "hashing") {
+              this.#c(e) && this.#h(e, "CRYPTO_UNAVAILABLE", !1);
+              return;
+            }
+            if (e.phase === "registering")
+              for (const u of e.controllers) u.abort();
+          }
+        }, Math.max(0, e.registrationDeadlineMs - this.#i()));
+        const t = await this.#e.crypto.subtle.digest(
+          "SHA-256",
+          be.encode(e.verifier)
+        ), n = se(new Uint8Array(t));
+        if (!te.test(n)) throw c("CRYPTO_UNAVAILABLE");
+        if (!this.#c(e)) {
+          e.registrationOutcome = "not-started", this.#a(e);
+          return;
+        }
+        e.challenge = n, e.phase = "registering";
+        const i = this.#P(e);
+        let o, s = null;
+        try {
+          try {
+            const l = this.#e.fetch(
+              `${_}/relay/v1/transactions`,
+              k({
+                clientId: this.#V,
+                codeChallenge: e.challenge,
+                codeChallengeMethod: "S256",
+                operation: e.adapter.operation,
+                request: e.request,
+                schemaVersion: 1,
+                state: e.state,
+                transactionId: e.transactionId
+              }, i.signal)
+            );
+            s = await Y(
+              l,
+              i.signal,
+              x
+            );
+          } catch {
+            e.registrationOutcome = "ambiguous", e.active ? this.#h(e, "RELAY_ERROR") : this.#A(e);
+            return;
+          }
+          e.registrationOutcome = "ambiguous";
+          let u;
+          try {
+            u = s.status;
+          } catch {
+            L(i, s), e.active ? this.#h(e, "RELAY_ERROR") : this.#A(e);
+            return;
+          }
+          if (u !== 201) {
+            e.registrationOutcome = "definitive-failure", L(i, s), e.active ? this.#h(e, "RELAY_ERROR", !1) : this.#a(e);
+            return;
+          }
+          try {
+            const l = await ce(
+              s,
+              re,
+              i
+            ), f = $(
+              V(l, re),
+              ["expiresAt", "schemaVersion", "transactionId"]
+            );
+            if (f.schemaVersion !== 1 || f.transactionId !== e.transactionId)
+              throw c("RELAY_ERROR");
+            o = M(f.expiresAt);
+            const h = this.#i();
+            if (o <= h || o - h > ot)
+              throw c("RELAY_ERROR");
+          } catch {
+            e.registrationOutcome = "ambiguous", L(i, s), e.active ? this.#h(e, "RELAY_ERROR") : this.#A(e);
+            return;
+          }
+        } finally {
+          try {
+            i.abort();
+          } catch {
+          }
+          this.#D(e, i), this.#d(e.operationTimer), e.operationTimer = null;
+        }
+        if (e.transactionExpiresAtMs = o, e.registrationOutcome = "registered", !this.#c(e)) {
+          this.#A(e);
+          return;
+        }
+        e.phase = "waiting-callback", e.expiryTimer = this.#g(() => {
+          this.#c(e) && this.#h(e, "WALLET_NOT_COMPLETED");
+        }, Math.max(0, e.transactionExpiresAtMs - this.#i())), e.pollTimer = this.#H(() => {
+          this.#N(e, !1);
+        }, it), await this.#N(e, !1);
+      } catch (t) {
+        if (!e.active) {
+          e.registrationOutcome === "ambiguous" || e.registrationOutcome === "registered" ? this.#A(e) : this.#a(e);
+          return;
+        }
+        const n = t instanceof C ? t.code : e.phase === "hashing" ? "CRYPTO_UNAVAILABLE" : "RELAY_ERROR";
+        this.#h(e, n, e.registrationOutcome !== "none");
+      }
+  }
+  async #N(e, t) {
+    if (!this.#c(e) || e.phase !== "waiting-callback" || e.callbackBusy || !this.#u) return;
+    const n = `${j}${e.state}`;
+    let i;
+    try {
+      i = this.#u.getItem(n);
+    } catch {
+      t && this.#h(e, "CALLBACK_ERROR");
+      return;
+    }
+    if (i === null) return;
+    e.callbackBusy = !0;
+    let o;
+    try {
+      o = pt(i, e.state, this.#i()), this.#u.removeItem(n);
+    } catch {
+      try {
+        this.#u.removeItem(n);
+      } catch {
+      }
+      this.#h(e, "CALLBACK_ERROR");
+      return;
+    }
+    if (!this.#c(e)) return;
+    e.phase = "redeeming", this.#d(e.pollTimer, !0), e.pollTimer = null;
+    const s = this.#P(e);
+    let u = null;
+    try {
+      const l = this.#e.fetch(
+        `${_}/relay/v1/codes/redeem`,
+        k({
+          code: o.code,
+          codeVerifier: e.verifier,
+          schemaVersion: 1,
+          state: e.state,
+          transactionId: e.transactionId
+        }, s.signal)
+      );
+      if (u = await Y(
+        l,
+        s.signal,
+        x
+      ), u.status !== 200) throw c("RELAY_ERROR");
+      const f = await ce(
+        u,
+        ne,
+        s
+      ), h = $(
+        V(f, ne),
+        ["result", "schemaVersion", "transactionId"]
+      );
+      if (h.schemaVersion !== 1 || h.transactionId !== e.transactionId)
+        throw c("RELAY_ERROR");
+      let d;
+      try {
+        d = e.adapter.parseResult(h.result);
+      } catch {
+        throw c("RELAY_ERROR");
+      }
+      if (!this.#c(e)) return;
+      this.#W(e, d);
+    } catch (l) {
+      if (u && L(s, u), !this.#c(e)) return;
+      const f = l instanceof C ? l.code : "RELAY_ERROR";
+      this.#h(e, f);
+    } finally {
+      try {
+        s.abort();
+      } catch {
+      }
+      this.#D(e, s);
+    }
+  }
+  #W(e, t) {
+    if (!this.#c(e)) return;
+    let n = null;
+    (e.adapter.kind === "connect" || e.adapter.kind === "account" && t.event === "connected") && (n = this.#K(t)), e.active = !1, this.#o = null, this.#I(e);
+    let i = t;
+    e.adapter.kind === "connect" ? (this.#B(n), i = S(t.identity)) : e.adapter.kind === "account" ? (t.event === "connected" ? this.#B(n) : (this.#f(), this.#n({ identity: null, status: "dormant" })), i = void 0) : this.#z(e, void 0), e.resolve(i), this.#a(e);
+  }
+  #h(e, t, n = !0) {
+    this.#c(e) && this.#_(e, t, !0, n);
+  }
+  #_(e, t, n, i = !0) {
+    if (!e.active) return e.cleanup.promise;
+    const o = this.#m;
+    e.active = !1, this.#o === e && (this.#o = null), this.#w += 1, this.#I(e);
+    for (const l of e.controllers)
+      e.phase !== "registering" && l.abort();
+    const s = this.#t(o), u = s ?? c(t);
+    return e.reject(u), n && !s && this.#Y(e, u, 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.#A(e)), e.cleanup.promise);
+  }
+  #Y(e, t, n, i) {
+    if (n?.expiresAtMs > this.#i()) {
+      this.#s = n, this.#n({
+        connectionExpiresAt: n.expiresAt,
+        error: I(t),
+        identity: n.identity,
+        status: "connected"
+      });
+      return;
+    }
+    this.#f(), this.#n({
+      error: I(t),
+      identity: null,
+      status: "error"
+    });
+  }
+  #K(e) {
+    const t = M(e.connectionExpiresAt), n = this.#i();
+    if (t <= n || t - n > ct)
+      throw c("RELAY_ERROR");
+    return {
+      expiresAt: e.connectionExpiresAt,
+      expiresAtMs: t,
+      identity: S(e.identity)
+    };
+  }
+  #B(e) {
+    const t = this.#i();
+    this.#f(), this.#s = e;
+    const n = this.#s;
+    this.#O = this.#g(() => {
+      this.#s === n && (this.#s = null, this.#O = null, this.#o ? this.#n({ identity: null, status: "opening" }) : this.#n({ identity: null, status: "dormant" }));
+    }, Math.max(0, e.expiresAtMs - t)), this.#n({
+      connectionExpiresAt: e.expiresAt,
+      identity: this.#s.identity,
+      status: "connected"
+    });
+  }
+  #z(e, t) {
+    const n = e.priorConnection;
+    n?.expiresAtMs > this.#i() ? (this.#s = n, this.#n({
+      connectionExpiresAt: n.expiresAt,
+      ...t ? { error: I(t) } : {},
+      identity: n.identity,
+      status: "connected"
+    })) : t ? (this.#f(), this.#n({ error: I(t), identity: null, status: "error" })) : (this.#f(), this.#n({ identity: null, status: "dormant" }));
+  }
+  #U() {
+    !this.#s || this.#s.expiresAtMs > this.#i() || (this.#f(), this.#o ? this.#n({ identity: null, status: "opening" }) : this.#n({ identity: null, status: "dormant" }));
+  }
+  #f() {
+    this.#s = null, this.#d(this.#O), this.#O = null;
+  }
+  #n(e) {
+    const t = S(e);
+    if (this.#M = t, this.#x.push(t), !this.#C) {
+      this.#C = !0;
+      try {
+        for (; this.#x.length !== 0; ) {
+          const n = this.#x.shift();
+          for (const i of [...this.#v])
+            try {
+              i(ie(n));
+            } catch {
+            }
+        }
+      } finally {
+        this.#C = !1;
+      }
+    }
+  }
+  #c(e) {
+    return !this.#r && e.active && this.#o === e && e.generation === this.#w;
+  }
+  #t(e) {
+    return this.#r ? c("DESTROYED") : e !== this.#m ? c("REPLACED") : null;
+  }
+  #i() {
+    return this.#e.now();
+  }
+  #P(e) {
+    const t = new this.#e.AbortController();
+    return e.controllers.add(t), this.#E.add(t), t;
+  }
+  #D(e, t) {
+    e.controllers.delete(t), this.#E.delete(t);
+  }
+  #g(e, t) {
+    let n;
+    return n = this.#e.setTimeout(() => {
+      this.#R.delete(n), e();
+    }, Math.max(0, t)), this.#R.add(n), n;
+  }
+  #H(e, t) {
+    const n = this.#e.setInterval(e, t);
+    return this.#R.add(n), n;
+  }
+  #d(e, t = !1) {
+    e != null && (t ? this.#e.clearInterval(e) : this.#e.clearTimeout(e), this.#R.delete(e));
+  }
+  #I(e) {
+    this.#d(e.expiryTimer), this.#d(e.pollTimer, !0), e.expiryTimer = null, e.pollTimer = null;
+  }
+  #j(e) {
+    if (!(e.cleanupFinished || this.#y.has(e)))
+      for (this.#y.add(e); this.#y.size > lt; ) {
+        const t = this.#y.values().next().value;
+        for (const n of t.controllers) n.abort();
+        this.#a(t);
+      }
+  }
+  async #A(e) {
+    if (e.cleanupFinished || e.cleanupStarted || this.#r)
+      return e.cleanup.promise;
+    e.cleanupStarted = !0, this.#j(e);
+    let t = 100, n = !0;
+    for (; !this.#r && !e.cleanupFinished && (n || this.#i() <= e.registrationDeadlineMs); ) {
+      n = !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((s) => {
+        e.retryResolve = s, e.retryTimer = this.#g(() => {
+          e.retryResolve = null, s();
+        }, Math.min(t, o));
+      }), e.retryResolve = null, e.retryTimer = null, t = Math.min(t * 2, 4e3);
+    }
+    return this.#a(e), e.cleanup.promise;
+  }
+  async #F(e) {
+    if (!e.verifier || !e.challenge) return "done";
+    const t = this.#P(e), n = e.registrationDeadlineMs - this.#i(), i = n > 0 ? Math.min(4e3, n) : 1e3, o = this.#g(() => t.abort(), Math.max(1, i));
+    let s = null;
+    try {
+      const u = this.#e.fetch(
+        `${_}/relay/v1/transactions/${e.transactionId}/cancel`,
+        k({
+          codeVerifier: e.verifier,
+          schemaVersion: 1,
+          state: e.state,
+          transactionId: e.transactionId
+        }, t.signal)
+      );
+      s = await Y(
+        u,
+        t.signal,
+        x
+      );
+      const l = s.status;
+      return L(t, s), s = null, l === 204 || l === 400 || l === 403 || l === 409 || l === 410 ? "done" : "retry";
+    } catch {
+      return s && L(t, s), "retry";
+    } finally {
+      try {
+        t.abort();
+      } catch {
+      }
+      this.#d(o), this.#D(e, t);
+    }
+  }
+  #X(e) {
+    let t;
+    try {
+      t = this.#e.fetch(
+        `${_}/relay/v1/transactions/${e.transactionId}/cancel`,
+        {
+          ...k({
+            codeVerifier: e.verifier,
+            schemaVersion: 1,
+            state: e.state,
+            transactionId: e.transactionId
+          }),
+          // Let the browser finish the tiny revocation after local teardown or unload.
+          keepalive: !0
+        }
+      );
+    } catch {
+      return;
+    }
+    X(Promise.resolve(t).then(x));
+  }
+  #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.#I(e);
+      for (const t of e.controllers)
+        t.abort(), this.#E.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.#$ || this.#r)) {
+      this.#$ = !0, this.#T = !0;
+      try {
+        let e = null;
+        try {
+          const o = this.#e.getStorage;
+          e = typeof o == "function" ? Reflect.apply(o, void 0, []) : this.#e.storage ?? null;
+        } catch {
+          e = null, this.#l = !0;
+        }
+        try {
+          (!e || typeof e.getItem != "function" || typeof e.removeItem != "function") && (this.#l = !0);
+        } catch {
+          this.#l = !0;
+        }
+        if (this.#r || this.#l) {
+          this.#u = null;
+          return;
+        }
+        if (this.#u = e, this.#Z(), this.#r || this.#l) {
+          this.#u = null;
+          return;
+        }
+        const t = (o) => {
+          const s = this.#o;
+          if (!s || !this.#c(s)) return;
+          const u = `${j}${s.state}`;
+          o?.key === u && this.#N(s, !0);
+        };
+        this.#L = t;
+        let n = !1, i = null;
+        try {
+          const o = this.#p?.addEventListener, s = this.#p?.removeEventListener;
+          if (typeof o != "function" || typeof s != "function")
+            throw new TypeError("storage events unavailable");
+          i = () => Reflect.apply(
+            s,
+            this.#p,
+            ["storage", t]
+          ), this.#b = i, Reflect.apply(o, this.#p, ["storage", this.#L]), n = !0;
+        } catch {
+          this.#l = !0;
+        }
+        if (!n || this.#r || this.#l) {
+          try {
+            i?.();
+          } catch {
+          }
+          this.#L = null, this.#b = null, this.#u = null;
+        }
+      } finally {
+        this.#T = !1;
+      }
+    }
+  }
+  #Z() {
+    const e = this.#u;
+    if (!e) return;
+    let t;
+    try {
+      t = e.length;
+    } catch {
+      return;
+    }
+    if (!Number.isSafeInteger(t) || t < 0) return;
+    const n = Math.min(t, ut), i = [];
+    for (let o = 0; o < n && !this.#r && !this.#l; o += 1) {
+      let s;
+      try {
+        s = e.key(o);
+      } catch {
+        continue;
+      }
+      i.push(s);
+    }
+    for (const o of i) {
+      if (this.#r || this.#l) return;
+      if (typeof o != "string" || !o.startsWith(j)) continue;
+      const s = o.slice(j.length);
+      if (T.test(s))
+        try {
+          const u = e.getItem(o);
+          if (u === null) continue;
+          const l = $(
+            V(u, 2048),
+            ["code", "expiresAt", "schemaVersion", "state"],
+            "CALLBACK_ERROR"
+          );
+          if (l.schemaVersion !== 1 || l.state !== s || !T.test(l.code))
+            continue;
+          M(l.expiresAt, "CALLBACK_ERROR") <= this.#i() && e.removeItem(o);
+        } catch {
+        }
+    }
+  }
+}
+function Et(r) {
+  return new At(r);
+}
+function bt(r, e = {}) {
+  const t = (i, o) => i !== 0 ? Promise.reject(c("INVALID_REQUEST")) : o(), n = {
+    connect(...i) {
+      return t(i.length, () => r.execute("connect", void 0));
+    },
+    destroy(...i) {
+      return t(i.length, () => r.destroy());
+    },
+    disconnect(...i) {
+      return t(i.length, () => r.disconnect());
+    },
+    getSnapshot(...i) {
+      if (i.length !== 0) throw c("INVALID_REQUEST");
+      return r.getSnapshot();
+    },
+    openAccount(...i) {
+      return t(i.length, () => r.execute("account", void 0));
+    },
+    subscribe(i, ...o) {
+      if (o.length !== 0) throw c("INVALID_REQUEST");
+      return r.subscribe(i);
+    }
+  };
+  for (const [i, o] of Object.entries(e))
+    n[i] = function(u, ...l) {
+      return l.length !== 0 ? Promise.reject(c("INVALID_REQUEST")) : r.execute(o, u);
+    };
+  return Object.freeze(n);
+}
+const gt = Object.freeze({
+  account: Object.freeze({
+    buildRequest: () => Qe({}),
+    kind: "account",
+    operation: "sdn.wallet.account.v1",
+    parseResult: Ze
+  }),
+  connect: Object.freeze({
+    buildRequest: () => He({}),
+    kind: "connect",
+    operation: "sdn.wallet.connect.v1",
+    parseResult: Xe
+  })
+}), Ot = Object.freeze({
+  ...gt,
+  sdnLoginV1: Object.freeze({
+    buildRequest: Ge,
+    kind: "typed",
+    operation: "sdn.auth.raw-challenge.v1",
+    parseResult: et
+  }),
+  sdnLoginV2: Object.freeze({
+    buildRequest: tt,
+    kind: "typed",
+    operation: "sdn.auth.jcs-envelope.v2",
+    parseResult: rt
+  })
+});
+function St() {
+  if (arguments.length !== 0) throw c("INVALID_REQUEST");
+  const r = Et({
+    adapters: Ot,
+    clientId: "sdn-node-console-v1"
+  });
+  return bt(r, {
+    requestSdnLoginV1: "sdnLoginV1",
+    requestSdnLoginV2: "sdnLoginV2"
+  });
+}
+export {
+  Ee as WALLET_CLIENT_ERRORS,
+  St as createSdnWalletClient
+};