hd-wallet-ui 2.0.20 → 2.0.26

package/dist/client/asset-review.js

@@ -0,0 +1,1570 @@
+const Pe = Object.freeze({
+  cm: 0.01,
+  km: 1e3,
+  m: 1,
+  mm: 1e-3
+}), Ne = Object.freeze({
+  metersPerSourceUnit: Pe,
+  quaternionNormTolerance: 1e-6,
+  scaleComponentExclusiveMin: 0,
+  scaleComponentInclusiveMax: 1e6,
+  translationComponentAbsMax: 1e6,
+  upAxes: Object.freeze(["X_UP", "Y_UP", "Z_UP"])
+}), De = Object.freeze({ reviewedTransform: Ne, schemaVersion: 1 }), g = new TextEncoder(), ye = Object.getPrototypeOf(Uint8Array.prototype);
+Object.getOwnPropertyDescriptor(ye, "buffer").get;
+Object.getOwnPropertyDescriptor(ye, "length").get;
+Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
+typeof SharedArrayBuffer > "u" || Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength").get;
+const w = "sdn-bip32-slip10-purpose-v1", J = "password-scrypt-v2", x = "ed25519-over-sha256-jcs-v1", pe = "https://review.spacedatanetwork.org", Re = "sdn-asset-review-v1", ke = "asset-review:assets.ipfs.01", je = "asset-review-authority:assets.ipfs.01", Me = "sdn-login:sdn.spaceaware.io", Ve = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u, b = /^[0-9a-f]{64}$/u, Ye = /^[0-9a-f]{128}$/u, M = /^sha256:[0-9a-f]{64}$/u, $e = /^[1-9A-HJ-NP-Za-km-z]+$/u, Ue = /^b[a-z2-7]{58}$/u, X = "abcdefghijklmnopqrstuvwxyz234567", Ee = 131072, Fe = [
+  "accountFingerprint",
+  "accountIndex",
+  "accountLabel",
+  "accountPeerId",
+  "accountXpub",
+  "identityScheme",
+  "keys",
+  "schemaVersion",
+  "seedProfile"
+], qe = [
+  "bip32Fingerprint",
+  "curve",
+  "derivation",
+  "encoding",
+  "identityScheme",
+  "keyId",
+  "path",
+  "publicKeyHex",
+  "purpose",
+  "seedProfile",
+  "signatureProfile"
+], Be = [
+  "connectionExpiresAt",
+  "event",
+  "identity",
+  "schemaVersion"
+], Je = [
+  "algorithm",
+  "canonicalEnvelope",
+  "encoding",
+  "identityScheme",
+  "keyId",
+  "schemaVersion",
+  "signatureHex",
+  "signatureProfile",
+  "signedDigestSha256"
+], W = [
+  "audience",
+  "clientId",
+  "expiresAt",
+  "identityScheme",
+  "issuedAt",
+  "keyId",
+  "nonce",
+  "protocolVersion",
+  "publicKeyHex",
+  "purpose",
+  "requestOrigin",
+  "serviceInstance",
+  "signatureProfile"
+], Q = [
+  "audience",
+  "candidateKey",
+  "challengeId",
+  "clientId",
+  "decision",
+  "expiresAt",
+  "issuedAt",
+  "metadataSha256",
+  "modelBytes",
+  "modelCid",
+  "modelSha256",
+  "nonce",
+  "previousDecisionHead",
+  "protocolVersion",
+  "requestOrigin"
+], We = [
+  "metersPerSourceUnit",
+  "rotation",
+  "scale",
+  "sourceUnits",
+  "translation",
+  "upAxis"
+];
+function c(i) {
+  throw new TypeError(i);
+}
+function K(i) {
+  if (i === null || typeof i != "object" || Array.isArray(i)) return !1;
+  const e = Object.getPrototypeOf(i);
+  return e === Object.prototype || e === null;
+}
+function v(i, e) {
+  typeof i != "string" && c(`${e} must be a string`);
+  for (let t = 0; t < i.length; t += 1) {
+    const n = i.charCodeAt(t);
+    let r = n;
+    if (n >= 55296 && n <= 56319) {
+      const s = i.charCodeAt(t + 1);
+      s >= 56320 && s <= 57343 || c(`${e} contains an unpaired surrogate`), r = 65536 + (n - 55296 << 10) + (s - 56320), t += 1;
+    } else n >= 56320 && n <= 57343 && c(`${e} contains an unpaired surrogate`);
+    ((r & 65535) === 65534 || (r & 65535) === 65535 || r >= 64976 && r <= 65007) && c(`${e} contains a Unicode noncharacter`);
+  }
+  return i;
+}
+function Ae(i) {
+  typeof i != "string" && c("wire JSON must be a string"), g.encode(i).byteLength > Ee && c("wire JSON is too large"), i.charCodeAt(0) === 65279 && c("wire JSON must not contain a BOM");
+  let e = 0, t = 0;
+  const n = () => {
+    for (; e < i.length && /[\u0009\u000a\u000d\u0020]/u.test(i[e]); ) e += 1;
+  }, r = () => {
+    i[e] !== '"' && c("invalid JSON string");
+    const l = e;
+    for (e += 1; e < i.length; ) {
+      const u = i.charCodeAt(e);
+      if (u === 34) {
+        e += 1;
+        let h;
+        try {
+          h = JSON.parse(i.slice(l, e));
+        } catch {
+          c("invalid JSON string");
+        }
+        return v(h, "JSON string");
+      }
+      u < 32 && c("invalid JSON control character"), u === 92 && (e += 1, e >= i.length && c("unterminated JSON escape")), e += 1;
+    }
+    c("unterminated JSON string");
+  }, s = (l = 0) => {
+    l > 32 && c("wire JSON nesting is too deep"), t += 1, t > 4096 && c("wire JSON contains too many values"), n();
+    const u = i[e];
+    if (u === '"') return r();
+    if (u === "{") {
+      e += 1;
+      const m = /* @__PURE__ */ Object.create(null), y = /* @__PURE__ */ new Set();
+      if (n(), i[e] === "}")
+        return e += 1, m;
+      for (; e < i.length; ) {
+        n();
+        const R = r();
+        if (y.has(R) && c(`duplicate JSON field: ${R}`), y.add(R), n(), i[e] !== ":" && c("missing JSON object colon"), e += 1, m[R] = s(l + 1), n(), i[e] === "}")
+          return e += 1, m;
+        i[e] !== "," && c("invalid JSON object separator"), e += 1;
+      }
+      c("unterminated JSON object");
+    }
+    if (u === "[") {
+      e += 1;
+      const m = [];
+      if (n(), i[e] === "]")
+        return e += 1, m;
+      for (; e < i.length; ) {
+        if (m.push(s(l + 1)), n(), i[e] === "]")
+          return e += 1, m;
+        i[e] !== "," && c("invalid JSON array separator"), e += 1;
+      }
+      c("unterminated JSON array");
+    }
+    for (const [m, y] of [["true", !0], ["false", !1], ["null", null]])
+      if (i.startsWith(m, e))
+        return e += m.length, y;
+    const h = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(i.slice(e));
+    h || c("invalid JSON value"), e += h[0].length;
+    const d = Number(h[0]);
+    return Number.isFinite(d) || c("wire JSON number must be finite"), d;
+  };
+  n();
+  const o = s();
+  return n(), e !== i.length && c("wire JSON contains trailing bytes"), o;
+}
+function be(i) {
+  return typeof i == "string" ? Ae(i) : i;
+}
+function Ke(i, e) {
+  if (i.byteLength !== e.byteLength) return !1;
+  let t = 0;
+  for (let n = 0; n < i.byteLength; n += 1) t |= i[n] ^ e[n];
+  return t === 0;
+}
+function E(i, e, t) {
+  const n = be(i);
+  K(n) || c(`${t} must be a JSON object`), Object.getOwnPropertySymbols(n).length !== 0 && c(`${t} has an unknown symbol field`);
+  const r = Object.getOwnPropertyNames(n).sort(), s = [...e].sort(), o = g.encode(r.join("\0")), l = g.encode(s.join("\0"));
+  Ke(o, l) || c(`${t} has missing or unknown fields`);
+  for (const u of r) {
+    const h = Object.getOwnPropertyDescriptor(n, u);
+    (!h || !h.enumerable || !("value" in h)) && c(`${t}.${u} must be an enumerable data field`), h.value === void 0 && c(`${t}.${u} must not be undefined`);
+  }
+  return n;
+}
+function V(i) {
+  if (!i || typeof i != "object" || Object.isFrozen(i)) return i;
+  for (const e of Object.values(i)) V(e);
+  return Object.freeze(i);
+}
+function S(i) {
+  return V(Object.fromEntries([...i].sort(([e], [t]) => e < t ? -1 : e > t ? 1 : 0)));
+}
+function G(i, e, t) {
+  (!Array.isArray(i) || Object.getPrototypeOf(i) !== Array.prototype || i.length !== e) && c(`${t} must be a plain array with exactly ${e} values`);
+  const n = [...Array.from({ length: e }, (s, o) => String(o)), "length"], r = Reflect.ownKeys(i);
+  (r.length !== n.length || r.some((s, o) => s !== n[o])) && c(`${t} must be a dense plain array`);
+  for (let s = 0; s < e; s += 1) {
+    const o = Object.getOwnPropertyDescriptor(i, String(s));
+    (!o || !o.enumerable || !("value" in o) || o.value === void 0) && c(`${t} must contain enumerable data values`);
+  }
+}
+function ze(i) {
+  const e = E(
+    i,
+    ["reviewedTransform", "schemaVersion"],
+    "asset review protocol policy"
+  );
+  f(e.schemaVersion, 1, "asset review protocol schemaVersion");
+  const t = E(e.reviewedTransform, [
+    "metersPerSourceUnit",
+    "quaternionNormTolerance",
+    "scaleComponentExclusiveMin",
+    "scaleComponentInclusiveMax",
+    "translationComponentAbsMax",
+    "upAxes"
+  ], "asset review transform policy"), n = E(
+    t.metersPerSourceUnit,
+    ["cm", "km", "m", "mm"],
+    "asset review unit policy"
+  );
+  for (const [r, s] of Object.entries(n))
+    (typeof s != "number" || !Number.isFinite(s) || s <= 0) && c(`asset review unit policy ${r} must be positive and finite`);
+  for (const [r, s] of [
+    ["quaternionNormTolerance", t.quaternionNormTolerance],
+    ["scaleComponentExclusiveMin", t.scaleComponentExclusiveMin],
+    ["scaleComponentInclusiveMax", t.scaleComponentInclusiveMax],
+    ["translationComponentAbsMax", t.translationComponentAbsMax]
+  ])
+    (typeof s != "number" || !Number.isFinite(s)) && c(`asset review transform policy ${r} must be finite`);
+  return (t.quaternionNormTolerance <= 0 || t.scaleComponentInclusiveMax <= t.scaleComponentExclusiveMin || t.translationComponentAbsMax <= 0) && c("asset review transform policy bounds are inconsistent"), G(t.upAxes, 3, "asset review up-axis policy"), t.upAxes.join("\0") !== "X_UP\0Y_UP\0Z_UP" && c("asset review up-axis policy is invalid"), S([
+    ["metersPerSourceUnit", S(Object.entries(n))],
+    ["quaternionNormTolerance", t.quaternionNormTolerance],
+    ["scaleComponentExclusiveMin", t.scaleComponentExclusiveMin],
+    ["scaleComponentInclusiveMax", t.scaleComponentInclusiveMax],
+    ["translationComponentAbsMax", t.translationComponentAbsMax],
+    ["upAxes", Object.freeze(Array.from({ length: 3 }, (r, s) => t.upAxes[s]))]
+  ]);
+}
+const L = ze(De);
+function f(i, e, t) {
+  return i !== e && c(`${t} must equal ${JSON.stringify(e)}`), i;
+}
+function ve(i, e, t) {
+  return e.includes(i) || c(`${t} is not an allowed value`), i;
+}
+function p(i, e, t) {
+  return v(i, t), e.test(i) || c(`${t} has an invalid encoding`), i;
+}
+function T(i, e) {
+  return v(i, e), (!Ve.test(i) || new Date(i).toISOString() !== i) && c(`${e} must be exact RFC3339 milliseconds UTC`), i;
+}
+function ee(i, e) {
+  const t = Date.parse(i), n = Date.parse(e);
+  n > t && n - t <= 3e5 || c("request lifetime must be in (0, 300] seconds");
+}
+function He(i) {
+  let e = 0, t = 0, n = "";
+  for (const r of i)
+    for (e = e << 8 | r, t += 8; t >= 5; )
+      t -= 5, n += X[e >>> t & 31], e &= (1 << t) - 1;
+  return t !== 0 && (n += X[e << 5 - t & 31]), n;
+}
+function Xe(i, e) {
+  v(i, "modelCid"), Ue.test(i) || c("modelCid must be canonical CIDv1 raw sha2-256 base32");
+  let t = 0, n = 0;
+  const r = [];
+  for (const l of i.slice(1)) {
+    const u = X.indexOf(l);
+    u < 0 && c("modelCid contains invalid base32"), t = t << 5 | u, n += 5, n >= 8 && (n -= 8, r.push(t >>> n & 255), t &= (1 << n) - 1);
+  }
+  (n !== 0 && t !== 0 || r.length !== 36) && c("modelCid has noncanonical base32 tail bits or length");
+  const s = Uint8Array.from(r);
+  (s[0] !== 1 || s[1] !== 85 || s[2] !== 18 || s[3] !== 32) && c("modelCid must encode CIDv1 raw sha2-256 with a 32-byte digest"), `b${He(s)}` !== i && c("modelCid base32 is not canonical");
+  let o = 0;
+  for (let l = 0; l < 32; l += 1) {
+    const u = Number.parseInt(e.slice(l * 2, l * 2 + 2), 16);
+    o |= s[l + 4] ^ u;
+  }
+  return o !== 0 && c("modelCid digest does not match modelSha256"), i;
+}
+function Z(i) {
+  return i === null || typeof i == "boolean" ? JSON.stringify(i) : typeof i == "string" ? (v(i, "canonical JSON string"), JSON.stringify(i)) : typeof i == "number" ? (Number.isFinite(i) || c("canonical JSON numbers must be finite"), JSON.stringify(i)) : Array.isArray(i) ? `[${i.map(Z).join(",")}]` : (K(i) || c("canonical JSON contains an unsupported value"), `{${Object.keys(i).sort().map((e) => `${JSON.stringify(e)}:${Z(i[e])}`).join(",")}}`);
+}
+function te(i, e) {
+  for (const t of ["identityScheme", "keyId", "signatureProfile"])
+    i[t] !== e[t] && c(`canonicalEnvelope ${t} must match the signature result`);
+}
+function Qe(i, e) {
+  const n = E(i, [
+    "audience",
+    "challengeSha256",
+    "clientId",
+    "expiresAt",
+    "identityScheme",
+    "issuedAt",
+    "keyId",
+    "kind",
+    "nonce",
+    "protocolVersion",
+    "requestOrigin",
+    "signatureProfile"
+  ], "SDN login canonicalEnvelope");
+  te(n, e), f(n.audience, Me, "SDN login envelope audience"), p(n.challengeSha256, b, "SDN login envelope challengeSha256"), f(n.clientId, "sdn-node-console-v1", "SDN login envelope clientId"), T(n.issuedAt, "SDN login envelope issuedAt"), T(n.expiresAt, "SDN login envelope expiresAt"), ee(n.issuedAt, n.expiresAt), f(n.identityScheme, w, "SDN login envelope identityScheme"), p(n.keyId, M, "SDN login envelope keyId"), f(n.kind, "sdn-login", "SDN login envelope kind"), p(n.nonce, b, "SDN login envelope nonce"), f(n.protocolVersion, 2, "SDN login envelope protocolVersion"), f(n.requestOrigin, "https://sdn.spaceaware.io", "SDN login envelope requestOrigin"), f(n.signatureProfile, x, "SDN login envelope signatureProfile");
+}
+function Ze(i, e) {
+  const t = E(
+    i,
+    [...W, "kind"],
+    "authority activation canonicalEnvelope"
+  );
+  te(t, e), f(t.kind, "asset-review-authority-activation", "activation envelope kind"), Se(Object.fromEntries(W.map((n) => [n, t[n]])));
+}
+function Ge(i, e) {
+  const t = i?.decision === "approve" ? ["note", "reviewedTransform"] : i?.decision === "disapprove" ? ["reason"] : [], n = [...Q, ...t], r = E(i, [
+    ...n,
+    "identityScheme",
+    "keyId",
+    "kind",
+    "purpose",
+    "signatureProfile"
+  ], "asset review decision canonicalEnvelope");
+  te(r, e), f(r.identityScheme, w, "decision envelope identityScheme"), p(r.keyId, M, "decision envelope keyId"), f(r.kind, "asset-review-attestation", "decision envelope kind"), f(r.purpose, "asset-review-approval", "decision envelope purpose"), f(r.signatureProfile, x, "decision envelope signatureProfile"), Ie(Object.fromEntries(n.map((s) => [s, r[s]])));
+}
+function et(i, e, t) {
+  v(i, "canonicalEnvelope"), g.encode(i).byteLength > Ee && c("canonicalEnvelope is too large");
+  const n = Ae(i);
+  return (!K(n) || n.kind !== e) && c("canonicalEnvelope kind does not match the operation"), Z(n) !== i && c("canonicalEnvelope must be exact JCS"), e === "sdn-login" ? Qe(n, t) : e === "asset-review-authority-activation" ? Ze(n, t) : e === "asset-review-attestation" ? Ge(n, t) : c("canonicalEnvelope operation is not registered"), i;
+}
+function tt(i, e) {
+  const t = E(i, qe, `identity key ${e.purpose}`);
+  return f(t.purpose, e.purpose, "key purpose"), f(t.identityScheme, w, "key identityScheme"), f(t.seedProfile, J, "key seedProfile"), f(t.signatureProfile, e.signatureProfile, "key signatureProfile"), f(t.curve, e.curve, "key curve"), f(t.derivation, "slip10", "key derivation"), f(t.path, e.path, "key path"), f(t.encoding, "raw", "key encoding"), p(t.publicKeyHex, b, "key publicKeyHex"), f(t.bip32Fingerprint, null, "key bip32Fingerprint"), p(t.keyId, M, "key keyId"), S([
+    ["bip32Fingerprint", null],
+    ["curve", t.curve],
+    ["derivation", "slip10"],
+    ["encoding", "raw"],
+    ["identityScheme", w],
+    ["keyId", t.keyId],
+    ["path", t.path],
+    ["publicKeyHex", t.publicKeyHex],
+    ["purpose", t.purpose],
+    ["seedProfile", J],
+    ["signatureProfile", t.signatureProfile]
+  ]);
+}
+function it(i) {
+  const e = E(i, Fe, "WalletPublicIdentity");
+  f(e.schemaVersion, 1, "identity schemaVersion"), f(e.identityScheme, w, "identity identityScheme"), f(e.seedProfile, J, "identity seedProfile"), e.accountIndex !== 0 && c("public wallet identity must use account 0"), f(e.accountLabel, null, "identity accountLabel"), v(e.accountXpub, "identity accountXpub"), /^xpub[1-9A-HJ-NP-Za-km-z]{107}$/u.test(e.accountXpub) || c("identity accountXpub is invalid"), v(e.accountPeerId, "identity accountPeerId"), (!e.accountPeerId.startsWith("16Uiu2H") || e.accountPeerId.length < 40 || e.accountPeerId.length > 64 || !$e.test(e.accountPeerId)) && c("identity accountPeerId is invalid"), p(e.accountFingerprint, /^[0-9a-f]{8}$/u, "identity accountFingerprint"), G(e.keys, 3, "public identity keys array");
+  const t = [
+    {
+      purpose: "asset-review-approval",
+      curve: "ed25519",
+      signatureProfile: x,
+      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: x,
+      path: "m/44'/0'/0'/0'/0'"
+    }
+  ], n = Array.from(
+    { length: 3 },
+    (r, s) => tt(e.keys[s], t[s])
+  );
+  return S([
+    ["accountFingerprint", e.accountFingerprint],
+    ["accountIndex", 0],
+    ["accountLabel", null],
+    ["accountPeerId", e.accountPeerId],
+    ["accountXpub", e.accountXpub],
+    ["identityScheme", w],
+    ["keys", V(n)],
+    ["schemaVersion", 1],
+    ["seedProfile", J]
+  ]);
+}
+function Oe(i, e) {
+  const t = E(i, Be, `${e} result`);
+  f(t.schemaVersion, 1, "connection result schemaVersion"), ve(t.event, ["connected", "disconnected"], "connection event"), e === "connect" && t.event !== "connected" && c("connect result must be connected");
+  let n = null, r = null;
+  return t.event === "connected" ? (n = it(t.identity), r = T(t.connectionExpiresAt, "connectionExpiresAt")) : (t.identity !== null || t.connectionExpiresAt !== null) && c("disconnected result must clear identity and expiry"), S([
+    ["connectionExpiresAt", r],
+    ["event", t.event],
+    ["identity", n],
+    ["schemaVersion", 1]
+  ]);
+}
+function we(i, e) {
+  const t = E(i, Je, "canonical signature");
+  return f(t.schemaVersion, 1, "signature schemaVersion"), p(t.keyId, M, "signature keyId"), f(t.identityScheme, w, "signature identityScheme"), f(t.algorithm, "ed25519", "signature algorithm"), f(t.encoding, "raw", "signature encoding"), f(t.signatureProfile, x, "signature profile"), et(t.canonicalEnvelope, e, t), p(t.signedDigestSha256, b, "signedDigestSha256"), p(t.signatureHex, Ye, "signatureHex"), S([
+    ["algorithm", "ed25519"],
+    ["canonicalEnvelope", t.canonicalEnvelope],
+    ["encoding", "raw"],
+    ["identityScheme", w],
+    ["keyId", t.keyId],
+    ["schemaVersion", 1],
+    ["signatureHex", t.signatureHex],
+    ["signatureProfile", x],
+    ["signedDigestSha256", t.signedDigestSha256]
+  ]);
+}
+function Se(i) {
+  const e = E(i, W, "authority activation request");
+  return f(e.protocolVersion, 1, "activation protocolVersion"), f(e.audience, je, "activation audience"), f(e.requestOrigin, pe, "activation requestOrigin"), f(e.clientId, Re, "activation clientId"), f(e.serviceInstance, "assets.ipfs.01/asset-review-attestation", "activation serviceInstance"), f(e.purpose, "asset-review-authority-activation", "activation purpose"), p(e.nonce, b, "activation nonce"), T(e.issuedAt, "activation issuedAt"), T(e.expiresAt, "activation expiresAt"), ee(e.issuedAt, e.expiresAt), p(e.publicKeyHex, b, "activation publicKeyHex"), p(e.keyId, M, "activation keyId"), f(e.identityScheme, w, "activation identityScheme"), f(e.signatureProfile, x, "activation signatureProfile"), S(W.map((t) => [t, e[t]]));
+}
+function z(i, e, t) {
+  G(i, e, `${t} array`);
+  const n = Array.from({ length: e }, (r, s) => {
+    const o = i[s];
+    return (typeof o != "number" || !Number.isFinite(o)) && c(`${t} values must be finite numbers`), o;
+  });
+  return V(n);
+}
+function nt(i) {
+  const e = E(i, We, "reviewedTransform"), t = z(e.translation, 3, "translation"), n = z(e.rotation, 4, "rotation"), r = z(e.scale, 3, "scale");
+  t.some((o) => Math.abs(o) > L.translationComponentAbsMax) && c("translation values exceed the reviewed transform policy"), r.some((o) => o <= L.scaleComponentExclusiveMin || o > L.scaleComponentInclusiveMax) && c("scale values exceed the reviewed transform policy");
+  const s = Math.hypot(...n);
+  return Math.abs(s - 1) > L.quaternionNormTolerance && c("rotation must be a unit quaternion within the reviewed tolerance"), ve(e.upAxis, L.upAxes, "upAxis"), v(e.sourceUnits, "sourceUnits"), Object.hasOwn(L.metersPerSourceUnit, e.sourceUnits) || c("sourceUnits is not allowed by the reviewed transform policy"), (typeof e.metersPerSourceUnit != "number" || !Number.isFinite(e.metersPerSourceUnit) || e.metersPerSourceUnit !== L.metersPerSourceUnit[e.sourceUnits]) && c("metersPerSourceUnit must exactly match sourceUnits"), S([
+    ["metersPerSourceUnit", e.metersPerSourceUnit],
+    ["rotation", n],
+    ["scale", r],
+    ["sourceUnits", e.sourceUnits],
+    ["translation", t],
+    ["upAxis", e.upAxis]
+  ]);
+}
+function se(i) {
+  return i >= 9 && i <= 13 || i === 32 || i === 160 || i === 5760 || i >= 8192 && i <= 8202 || i === 8232 || i === 8233 || i === 8239 || i === 8287 || i === 12288 || i === 65279;
+}
+function oe(i, e, t) {
+  if (t && i === null) return null;
+  v(i, e), (i.length === 0 || g.encode(i).byteLength > 2e3) && c(`${e} has an invalid length`);
+  const n = Array.from(i, (r) => r.codePointAt(0));
+  return (se(n[0]) || se(n[n.length - 1])) && c(`${e} must already be trimmed`), i;
+}
+function Ie(i) {
+  const e = be(i);
+  K(e) || c("asset review decision request must be a JSON object");
+  const t = Object.getOwnPropertyDescriptor(e, "decision");
+  (!t || !t.enumerable || !("value" in t) || t.value === void 0) && c("asset review decision request has an invalid decision field");
+  const n = t.value, r = n === "approve" ? ["note", "reviewedTransform"] : n === "disapprove" ? ["reason"] : [], s = E(e, [...Q, ...r], "asset review decision request");
+  f(s.protocolVersion, 1, "decision protocolVersion"), f(s.audience, ke, "decision audience"), f(s.requestOrigin, pe, "decision requestOrigin"), f(s.clientId, Re, "decision clientId"), p(s.challengeId, b, "challengeId"), p(s.nonce, b, "decision nonce"), T(s.issuedAt, "decision issuedAt"), T(s.expiresAt, "decision expiresAt"), ee(s.issuedAt, s.expiresAt), p(s.modelSha256, b, "modelSha256"), p(s.metadataSha256, b, "metadataSha256"), s.previousDecisionHead !== null && p(s.previousDecisionHead, b, "previousDecisionHead"), Xe(s.modelCid, s.modelSha256), (!Number.isSafeInteger(s.modelBytes) || s.modelBytes <= 0) && c("modelBytes must be a positive safe integer"), v(s.candidateKey, "candidateKey");
+  const o = "asset-review:", l = `:${s.modelSha256}`;
+  (!s.candidateKey.startsWith(o) || !s.candidateKey.endsWith(l) || g.encode(s.candidateKey).byteLength > 206) && c("candidateKey does not bind the model digest");
+  const u = s.candidateKey.slice(o.length, -l.length);
+  (!/^[a-z0-9-]+\/[a-z0-9][a-z0-9-]*$/u.test(u) || g.encode(u).byteLength > 128) && c("candidateKey entityId is invalid");
+  const h = Q.map((m) => [m, s[m]]);
+  return n === "approve" ? (h.push(["note", oe(s.note, "note", !0)]), h.push(["reviewedTransform", nt(s.reviewedTransform)])) : h.push(["reason", oe(s.reason, "reason", !1)]), Object.values(s).filter((m) => typeof m == "string").reduce((m, y) => m + g.encode(y).byteLength, 0) > 16384 && c("decision request strings exceed 16 KiB"), S(h);
+}
+function ge(i, e) {
+  return E(i, [], e), V({});
+}
+function rt(i = {}) {
+  return ge(i, "wallet connect request");
+}
+function st(i) {
+  return Oe(i, "connect");
+}
+function ot(i = {}) {
+  return ge(i, "wallet account request");
+}
+function ct(i) {
+  return Oe(i, "account");
+}
+function at(i) {
+  return Se(i);
+}
+function lt(i) {
+  return we(i, "asset-review-authority-activation");
+}
+function ut(i) {
+  return Ie(i);
+}
+function ht(i) {
+  return we(i, "asset-review-attestation");
+}
+const P = "https://wallet.spacedatanetwork.org", Y = "sdn.wallet.callback.v1:", D = /^[0-9a-f]{64}$/u, ce = /^[A-Za-z0-9_-]{43}$/u, ft = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u, dt = 250, mt = 3e4, yt = 3e5, pt = 9e5, Rt = 12e4, Et = 8, ae = 4096, le = 70 * 1024, At = 64, _e = 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."
+}), Le = new TextEncoder(), bt = new TextDecoder("utf-8", { fatal: !0 });
+class j extends Error {
+  constructor(e) {
+    super(_e[e]), this.name = "WalletClientError", Object.defineProperty(this, "code", {
+      configurable: !1,
+      enumerable: !0,
+      value: e,
+      writable: !1
+    });
+  }
+}
+function a(i) {
+  return Object.hasOwn(_e, i) ? new j(i) : new j("RELAY_ERROR");
+}
+function vt(i) {
+  if (i === null || typeof i != "object" || Array.isArray(i)) return !1;
+  const e = Object.getPrototypeOf(i);
+  return e === Object.prototype || e === null;
+}
+function U(i, e) {
+  if (typeof i != "string" || i.length > e || Le.encode(i).byteLength > e || i.charCodeAt(0) === 65279)
+    throw a("RELAY_ERROR");
+  let t = 0, n = 0;
+  const r = () => {
+    for (; t < i.length && /[\u0009\u000a\u000d\u0020]/u.test(i[t]); ) t += 1;
+  }, s = () => {
+    if (i[t] !== '"') throw a("RELAY_ERROR");
+    const u = t;
+    for (t += 1; t < i.length; ) {
+      const h = i.charCodeAt(t);
+      if (h === 34) {
+        t += 1;
+        let d;
+        try {
+          d = JSON.parse(i.slice(u, t));
+        } catch {
+          throw a("RELAY_ERROR");
+        }
+        for (let m = 0; m < d.length; m += 1) {
+          const y = d.charCodeAt(m);
+          if (y >= 55296 && y <= 56319) {
+            const R = d.charCodeAt(m + 1);
+            if (!(R >= 56320 && R <= 57343)) throw a("RELAY_ERROR");
+            m += 1;
+          } else if (y >= 56320 && y <= 57343)
+            throw a("RELAY_ERROR");
+        }
+        return d;
+      }
+      if (h < 32 || h === 92 && (t += 1, t >= i.length))
+        throw a("RELAY_ERROR");
+      t += 1;
+    }
+    throw a("RELAY_ERROR");
+  }, o = (u = 0) => {
+    if (u > 32 || ++n > 4096) throw a("RELAY_ERROR");
+    r();
+    const h = i[t];
+    if (h === '"') return s();
+    if (h === "{") {
+      t += 1;
+      const y = /* @__PURE__ */ Object.create(null), R = /* @__PURE__ */ new Set();
+      if (r(), i[t] === "}")
+        return t += 1, y;
+      for (; t < i.length; ) {
+        r();
+        const I = s();
+        if (R.has(I) || (R.add(I), r(), i[t] !== ":")) throw a("RELAY_ERROR");
+        if (t += 1, y[I] = o(u + 1), r(), i[t] === "}")
+          return t += 1, y;
+        if (i[t] !== ",") throw a("RELAY_ERROR");
+        t += 1;
+      }
+      throw a("RELAY_ERROR");
+    }
+    if (h === "[") {
+      t += 1;
+      const y = [];
+      if (r(), i[t] === "]")
+        return t += 1, y;
+      for (; t < i.length; ) {
+        if (y.push(o(u + 1)), r(), i[t] === "]")
+          return t += 1, y;
+        if (i[t] !== ",") throw a("RELAY_ERROR");
+        t += 1;
+      }
+      throw a("RELAY_ERROR");
+    }
+    for (const [y, R] of [["true", !0], ["false", !1], ["null", null]])
+      if (i.startsWith(y, t))
+        return t += y.length, R;
+    const d = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(i.slice(t));
+    if (!d) throw a("RELAY_ERROR");
+    t += d[0].length;
+    const m = Number(d[0]);
+    if (!Number.isFinite(m)) throw a("RELAY_ERROR");
+    return m;
+  };
+  r();
+  const l = o();
+  if (r(), t !== i.length) throw a("RELAY_ERROR");
+  return l;
+}
+function F(i, e, t = "RELAY_ERROR") {
+  if (!vt(i) || Object.getOwnPropertySymbols(i).length !== 0)
+    throw a(t);
+  const n = Object.getOwnPropertyNames(i).sort(), r = [...e].sort();
+  if (n.length !== r.length || n.some((s, o) => s !== r[o]))
+    throw a(t);
+  for (const s of n) {
+    const o = Object.getOwnPropertyDescriptor(i, s);
+    if (!o?.enumerable || !("value" in o) || o.value === void 0)
+      throw a(t);
+  }
+  return i;
+}
+function q(i, e = "RELAY_ERROR") {
+  if (typeof i != "string" || !ft.test(i))
+    throw a(e);
+  const t = Date.parse(i);
+  if (!Number.isFinite(t) || new Date(t).toISOString() !== i)
+    throw a(e);
+  return t;
+}
+function _(i) {
+  return Array.isArray(i) ? Object.freeze(i.map(_)) : i && typeof i == "object" ? Object.freeze(Object.fromEntries(
+    Object.entries(i).map(([e, t]) => [e, _(t)])
+  )) : i;
+}
+function ue(i) {
+  const e = {
+    identity: i.identity === null ? null : _(i.identity),
+    status: i.status
+  };
+  return i.connectionExpiresAt !== void 0 && (e.connectionExpiresAt = i.connectionExpiresAt), i.error !== void 0 && (e.error = _(i.error)), _(e);
+}
+function N(i) {
+  return Object.freeze({ code: i.code, message: i.message });
+}
+function he(i) {
+  const e = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  let t = 0, n = 0, r = "";
+  for (const s of i)
+    for (t = t << 8 | s, n += 8; n >= 6; )
+      n -= 6, r += e[t >>> n & 63], t &= (1 << n) - 1;
+  return n !== 0 && (r += e[t << 6 - n & 63]), r;
+}
+function fe(i) {
+  let e = "";
+  for (const t of i) e += t.toString(16).padStart(2, "0");
+  return e;
+}
+function H(i, e) {
+  const t = new Uint8Array(32);
+  return Reflect.apply(e, i, [t]), t;
+}
+function Ot(i) {
+  const e = i?.headers?.get?.("content-type");
+  return typeof e == "string" && /^application\/json(?:\s*;\s*charset=utf-8)?$/iu.test(e.trim());
+}
+function ie(i) {
+  try {
+    Promise.resolve(i).catch(() => {
+    });
+  } catch {
+  }
+}
+function k(i) {
+  try {
+    const e = i?.body, t = e?.cancel;
+    typeof t == "function" && ie(Reflect.apply(t, e, []));
+  } catch {
+  }
+}
+function xe(i) {
+  try {
+    const e = i?.cancel;
+    typeof e == "function" && ie(Reflect.apply(e, i, []));
+  } catch {
+  }
+}
+function wt(i) {
+  try {
+    const e = i?.releaseLock;
+    typeof e == "function" && Reflect.apply(e, i, []);
+  } catch {
+  }
+}
+function C(i, e, t = null) {
+  try {
+    i.abort();
+  } catch {
+  }
+  t && xe(t), k(e);
+}
+function B(i, e, t = null) {
+  let n;
+  try {
+    n = Promise.resolve(i);
+  } catch (r) {
+    return Promise.reject(r);
+  }
+  return new Promise((r, s) => {
+    let o = !1;
+    const l = () => {
+      try {
+        e.removeEventListener("abort", h);
+      } catch {
+      }
+    }, u = (d, m) => o ? !1 : (o = !0, l(), d(m), !0), h = () => {
+      u(s, a("RELAY_ERROR"));
+    };
+    try {
+      e.addEventListener("abort", h, { once: !0 }), e.aborted && h();
+    } catch {
+      h();
+    }
+    n.then(
+      (d) => {
+        if (o) {
+          try {
+            t?.(d);
+          } catch {
+          }
+          return;
+        }
+        u(r, d);
+      },
+      (d) => {
+        o || u(s, d);
+      }
+    );
+  });
+}
+async function de(i, e, t) {
+  let n = null;
+  const r = [];
+  let s = 0;
+  try {
+    if (!Ot(i) || typeof i?.body?.getReader != "function")
+      throw a("RELAY_ERROR");
+    for (n = i.body.getReader(); ; ) {
+      const u = n.read(), { done: h, value: d } = await B(u, t.signal);
+      if (h) break;
+      if (!(d instanceof Uint8Array) || (s += d.byteLength, s > e))
+        throw a("RELAY_ERROR");
+      r.push(d);
+    }
+    const o = new Uint8Array(s);
+    let l = 0;
+    for (const u of r)
+      o.set(u, l), l += u.byteLength;
+    return bt.decode(o);
+  } catch {
+    try {
+      t.abort();
+    } catch {
+    }
+    throw n && xe(n), a("RELAY_ERROR");
+  } finally {
+    n && wt(n);
+  }
+}
+function $(i, e) {
+  const t = {
+    body: JSON.stringify(i),
+    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 St(i, e, t) {
+  let n;
+  try {
+    n = U(i, 2048), F(n, ["code", "expiresAt", "schemaVersion", "state"], "CALLBACK_ERROR");
+  } catch {
+    throw a("CALLBACK_ERROR");
+  }
+  if (n.schemaVersion !== 1 || n.state !== e || !D.test(n.code))
+    throw a("CALLBACK_ERROR");
+  const r = q(n.expiresAt, "CALLBACK_ERROR");
+  if (r <= t || r - t > Rt)
+    throw a("CALLBACK_ERROR");
+  return { code: n.code, expiresAt: r, state: n.state };
+}
+function It() {
+  let i;
+  return { promise: new Promise((t) => {
+    i = t;
+  }), resolve: i };
+}
+function me() {
+  let i, e;
+  return { promise: new Promise((n, r) => {
+    i = r, e = n;
+  }), reject: i, resolve: e };
+}
+function gt() {
+  const i = 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 i?.localStorage ?? null;
+      } catch {
+        return null;
+      }
+    },
+    now: () => Date.now(),
+    setInterval: globalThis.setInterval.bind(globalThis),
+    setTimeout: globalThis.setTimeout.bind(globalThis),
+    window: i
+  });
+}
+class _t {
+  #j;
+  #M;
+  #x = !1;
+  #l = !1;
+  #V = !1;
+  #s = null;
+  #O = null;
+  #A = /* @__PURE__ */ new Set();
+  #e;
+  #w = null;
+  #i = !1;
+  #p = 0;
+  #S = 0;
+  #I = /* @__PURE__ */ new Set();
+  #T = [];
+  #o = null;
+  #C = !1;
+  #m = /* @__PURE__ */ new Set();
+  #Y = Object.freeze({ identity: null, status: "dormant" });
+  #u = null;
+  #g = null;
+  #b = null;
+  #R = /* @__PURE__ */ new Set();
+  #y;
+  constructor({ adapters: e, clientId: t, dependencies: n }) {
+    this.#j = e, this.#M = t, this.#e = n ?? gt(), this.#y = this.#e.window;
+  }
+  getSnapshot() {
+    return this.#F(), ue(this.#Y);
+  }
+  subscribe(e) {
+    if (typeof e != "function") throw a("INVALID_REQUEST");
+    if (this.#i) throw a("DESTROYED");
+    this.#I.add(e);
+    try {
+      e(this.getSnapshot());
+    } catch {
+    }
+    let t = !0;
+    return () => {
+      t && (t = !1, this.#I.delete(e));
+    };
+  }
+  execute(e, t) {
+    if (this.#i) return Promise.reject(a("DESTROYED"));
+    const n = this.#p, r = this.#j[e];
+    if (!r) return Promise.reject(a("INVALID_REQUEST"));
+    let s;
+    try {
+      s = r.buildRequest(t);
+    } catch {
+      const A = this.#t(n);
+      return A ? Promise.reject(A) : Promise.reject(a("INVALID_REQUEST"));
+    }
+    let o = this.#t(n);
+    if (o) return Promise.reject(o);
+    if (this.#x)
+      return this.#l = !0, Promise.reject(a("REPLACED"));
+    const l = ++this.#p;
+    if (this.#Q(), o = this.#t(l), o) return Promise.reject(o);
+    if (this.#l)
+      return Promise.reject(a("CALLBACK_ERROR"));
+    if (this.#F(), o = this.#t(l), o) return Promise.reject(o);
+    const u = this.#r();
+    if (o = this.#t(l), o) return Promise.reject(o);
+    const h = this.#s && this.#s.expiresAtMs > u ? this.#s : null;
+    if (o = this.#t(l), o) return Promise.reject(o);
+    const d = this.#o;
+    let m, y, R;
+    try {
+      const A = this.#e.crypto, O = A?.getRandomValues, Ce = A?.subtle?.digest, re = this.#y?.open;
+      if (o = this.#t(l), o) throw o;
+      if (typeof O != "function" || typeof Ce != "function" || typeof re != "function")
+        throw a("CRYPTO_UNAVAILABLE");
+      if (m = fe(H(A, O)), o = this.#t(l), o || (y = fe(H(A, O)), o = this.#t(l), o) || (R = he(H(A, O)), o = this.#t(l), o)) throw o;
+      if (!D.test(m) || !D.test(y) || !ce.test(R))
+        throw a("CRYPTO_UNAVAILABLE");
+      if (Reflect.apply(re, this.#y, [
+        `${P}/transaction/${m}`,
+        "_blank",
+        "noopener"
+      ]), o = this.#t(l), o) throw o;
+    } catch (A) {
+      if (o = this.#t(l), o) return Promise.reject(o);
+      let O;
+      try {
+        O = A instanceof j ? A : a("CRYPTO_UNAVAILABLE");
+      } catch {
+        O = a("CRYPTO_UNAVAILABLE");
+      }
+      return d && (this.#_(d, "REPLACED", !1), o = this.#t(l), o) ? Promise.reject(o) : (this.#$(null, O, h, r.kind), Promise.reject(O));
+    }
+    if (d && (this.#_(d, "REPLACED", !1), o = this.#t(l), o))
+      return Promise.reject(o);
+    const I = me(), Te = It(), ne = {
+      active: !0,
+      adapter: r,
+      callbackBusy: !1,
+      challenge: null,
+      cleanup: Te,
+      cleanupFinished: !1,
+      cleanupStarted: !1,
+      controllers: /* @__PURE__ */ new Set(),
+      expiryTimer: null,
+      generation: ++this.#S,
+      operationTimer: null,
+      phase: "hashing",
+      pollTimer: null,
+      priorConnection: h,
+      promise: I.promise,
+      registrationDeadlineMs: u + mt,
+      registrationOutcome: "none",
+      reject: I.reject,
+      request: s,
+      resolve: I.resolve,
+      retryResolve: null,
+      retryTimer: null,
+      state: y,
+      transactionExpiresAtMs: null,
+      transactionId: m,
+      verifier: R
+    };
+    return this.#o = ne, this.#n({
+      ...h ? {
+        connectionExpiresAt: h.expiresAt,
+        identity: h.identity
+      } : { identity: null },
+      status: "opening"
+    }), this.#J(ne), I.promise;
+  }
+  async disconnect() {
+    if (this.#i) throw a("DESTROYED");
+    const e = ++this.#p;
+    this.#f();
+    const t = this.#o;
+    let n = Promise.resolve();
+    t && (n = this.#_(t, "DISCONNECTED", !1));
+    let r = this.#t(e);
+    if (r)
+      throw await n, r;
+    if (this.#n({ identity: null, status: "dormant" }), await n, r = this.#t(e), r) throw r;
+  }
+  destroy() {
+    if (this.#w) return this.#w;
+    const e = me();
+    this.#w = e.promise, this.#p += 1;
+    try {
+      this.#B(), e.resolve();
+    } catch {
+      e.reject(a("RELAY_ERROR"));
+    }
+    return this.#w;
+  }
+  #B() {
+    this.#i = !0, this.#S += 1, this.#f();
+    const e = [], t = this.#o;
+    t && (t.active = !1, this.#o = null, this.#L(t), t.reject(a("DESTROYED")), t.challenge && t.verifier && e.push(t));
+    for (const n of this.#m)
+      n.challenge && n.verifier && e.push(n);
+    for (const n of this.#A) n.abort();
+    this.#A.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.#g = null, this.#b = null, this.#u = null, this.#I.clear();
+    for (const n of e) this.#X(n);
+    t && this.#a(t);
+    for (const n of [...this.#m]) this.#a(n);
+    this.#n({
+      error: N(a("DESTROYED")),
+      identity: null,
+      status: "error"
+    });
+  }
+  async #J(e) {
+    if (!(!this.#c(e) || e.cleanupFinished))
+      try {
+        e.operationTimer = this.#v(() => {
+          if (!e.cleanupFinished) {
+            if (e.phase === "hashing") {
+              this.#c(e) && this.#h(e, "CRYPTO_UNAVAILABLE", !1);
+              return;
+            }
+            if (e.phase === "registering")
+              for (const l of e.controllers) l.abort();
+          }
+        }, Math.max(0, e.registrationDeadlineMs - this.#r()));
+        const t = await this.#e.crypto.subtle.digest(
+          "SHA-256",
+          Le.encode(e.verifier)
+        ), n = he(new Uint8Array(t));
+        if (!ce.test(n)) throw a("CRYPTO_UNAVAILABLE");
+        if (!this.#c(e)) {
+          e.registrationOutcome = "not-started", this.#a(e);
+          return;
+        }
+        e.challenge = n, e.phase = "registering";
+        const r = this.#N(e);
+        let s, o = null;
+        try {
+          try {
+            const u = this.#e.fetch(
+              `${P}/relay/v1/transactions`,
+              $({
+                clientId: this.#M,
+                codeChallenge: e.challenge,
+                codeChallengeMethod: "S256",
+                operation: e.adapter.operation,
+                request: e.request,
+                schemaVersion: 1,
+                state: e.state,
+                transactionId: e.transactionId
+              }, r.signal)
+            );
+            o = await B(
+              u,
+              r.signal,
+              k
+            );
+          } catch {
+            e.registrationOutcome = "ambiguous", e.active ? this.#h(e, "RELAY_ERROR") : this.#E(e);
+            return;
+          }
+          e.registrationOutcome = "ambiguous";
+          let l;
+          try {
+            l = o.status;
+          } catch {
+            C(r, o), e.active ? this.#h(e, "RELAY_ERROR") : this.#E(e);
+            return;
+          }
+          if (l !== 201) {
+            e.registrationOutcome = "definitive-failure", C(r, o), e.active ? this.#h(e, "RELAY_ERROR", !1) : this.#a(e);
+            return;
+          }
+          try {
+            const u = await de(
+              o,
+              ae,
+              r
+            ), h = F(
+              U(u, ae),
+              ["expiresAt", "schemaVersion", "transactionId"]
+            );
+            if (h.schemaVersion !== 1 || h.transactionId !== e.transactionId)
+              throw a("RELAY_ERROR");
+            s = q(h.expiresAt);
+            const d = this.#r();
+            if (s <= d || s - d > yt)
+              throw a("RELAY_ERROR");
+          } catch {
+            e.registrationOutcome = "ambiguous", C(r, o), e.active ? this.#h(e, "RELAY_ERROR") : this.#E(e);
+            return;
+          }
+        } finally {
+          try {
+            r.abort();
+          } catch {
+          }
+          this.#D(e, r), this.#d(e.operationTimer), e.operationTimer = null;
+        }
+        if (e.transactionExpiresAtMs = s, e.registrationOutcome = "registered", !this.#c(e)) {
+          this.#E(e);
+          return;
+        }
+        e.phase = "waiting-callback", e.expiryTimer = this.#v(() => {
+          this.#c(e) && this.#h(e, "WALLET_NOT_COMPLETED");
+        }, Math.max(0, e.transactionExpiresAtMs - this.#r())), e.pollTimer = this.#H(() => {
+          this.#P(e, !1);
+        }, dt), await this.#P(e, !1);
+      } catch (t) {
+        if (!e.active) {
+          e.registrationOutcome === "ambiguous" || e.registrationOutcome === "registered" ? this.#E(e) : this.#a(e);
+          return;
+        }
+        const n = t instanceof j ? t.code : e.phase === "hashing" ? "CRYPTO_UNAVAILABLE" : "RELAY_ERROR";
+        this.#h(e, n, e.registrationOutcome !== "none");
+      }
+  }
+  async #P(e, t) {
+    if (!this.#c(e) || e.phase !== "waiting-callback" || e.callbackBusy || !this.#u) return;
+    const n = `${Y}${e.state}`;
+    let r;
+    try {
+      r = this.#u.getItem(n);
+    } catch {
+      t && this.#h(e, "CALLBACK_ERROR");
+      return;
+    }
+    if (r === null) return;
+    e.callbackBusy = !0;
+    let s;
+    try {
+      s = St(r, e.state, this.#r()), 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 o = this.#N(e);
+    let l = null;
+    try {
+      const u = this.#e.fetch(
+        `${P}/relay/v1/codes/redeem`,
+        $({
+          code: s.code,
+          codeVerifier: e.verifier,
+          schemaVersion: 1,
+          state: e.state,
+          transactionId: e.transactionId
+        }, o.signal)
+      );
+      if (l = await B(
+        u,
+        o.signal,
+        k
+      ), l.status !== 200) throw a("RELAY_ERROR");
+      const h = await de(
+        l,
+        le,
+        o
+      ), d = F(
+        U(h, le),
+        ["result", "schemaVersion", "transactionId"]
+      );
+      if (d.schemaVersion !== 1 || d.transactionId !== e.transactionId)
+        throw a("RELAY_ERROR");
+      let m;
+      try {
+        m = e.adapter.parseResult(d.result);
+      } catch {
+        throw a("RELAY_ERROR");
+      }
+      if (!this.#c(e)) return;
+      this.#W(e, m);
+    } catch (u) {
+      if (l && C(o, l), !this.#c(e)) return;
+      const h = u instanceof j ? u.code : "RELAY_ERROR";
+      this.#h(e, h);
+    } finally {
+      try {
+        o.abort();
+      } catch {
+      }
+      this.#D(e, o);
+    }
+  }
+  #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.#L(e);
+    let r = t;
+    e.adapter.kind === "connect" ? (this.#U(n), r = _(t.identity)) : e.adapter.kind === "account" ? (t.event === "connected" ? this.#U(n) : (this.#f(), this.#n({ identity: null, status: "dormant" })), r = void 0) : this.#z(e, void 0), e.resolve(r), this.#a(e);
+  }
+  #h(e, t, n = !0) {
+    this.#c(e) && this.#_(e, t, !0, n);
+  }
+  #_(e, t, n, r = !0) {
+    if (!e.active) return e.cleanup.promise;
+    const s = this.#p;
+    e.active = !1, this.#o === e && (this.#o = null), this.#S += 1, this.#L(e);
+    for (const u of e.controllers)
+      e.phase !== "registering" && u.abort();
+    const o = this.#t(s), l = o ?? a(t);
+    return e.reject(l), n && !o && this.#$(e, l, e.priorConnection, e.adapter.kind), this.#i ? (e.challenge && e.verifier && this.#q(e), this.#a(e), e.cleanup.promise) : (!r || 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.#k(e) : (this.#k(e), this.#E(e)), e.cleanup.promise);
+  }
+  #$(e, t, n, r) {
+    if (n?.expiresAtMs > this.#r()) {
+      this.#s = n, this.#n({
+        connectionExpiresAt: n.expiresAt,
+        error: N(t),
+        identity: n.identity,
+        status: "connected"
+      });
+      return;
+    }
+    this.#f(), this.#n({
+      error: N(t),
+      identity: null,
+      status: "error"
+    });
+  }
+  #K(e) {
+    const t = q(e.connectionExpiresAt), n = this.#r();
+    if (t <= n || t - n > pt)
+      throw a("RELAY_ERROR");
+    return {
+      expiresAt: e.connectionExpiresAt,
+      expiresAtMs: t,
+      identity: _(e.identity)
+    };
+  }
+  #U(e) {
+    const t = this.#r();
+    this.#f(), this.#s = e;
+    const n = this.#s;
+    this.#O = this.#v(() => {
+      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.#r() ? (this.#s = n, this.#n({
+      connectionExpiresAt: n.expiresAt,
+      ...t ? { error: N(t) } : {},
+      identity: n.identity,
+      status: "connected"
+    })) : t ? (this.#f(), this.#n({ error: N(t), identity: null, status: "error" })) : (this.#f(), this.#n({ identity: null, status: "dormant" }));
+  }
+  #F() {
+    !this.#s || this.#s.expiresAtMs > this.#r() || (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 = _(e);
+    if (this.#Y = t, this.#T.push(t), !this.#C) {
+      this.#C = !0;
+      try {
+        for (; this.#T.length !== 0; ) {
+          const n = this.#T.shift();
+          for (const r of [...this.#I])
+            try {
+              r(ue(n));
+            } catch {
+            }
+        }
+      } finally {
+        this.#C = !1;
+      }
+    }
+  }
+  #c(e) {
+    return !this.#i && e.active && this.#o === e && e.generation === this.#S;
+  }
+  #t(e) {
+    return this.#i ? a("DESTROYED") : e !== this.#p ? a("REPLACED") : null;
+  }
+  #r() {
+    return this.#e.now();
+  }
+  #N(e) {
+    const t = new this.#e.AbortController();
+    return e.controllers.add(t), this.#A.add(t), t;
+  }
+  #D(e, t) {
+    e.controllers.delete(t), this.#A.delete(t);
+  }
+  #v(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));
+  }
+  #L(e) {
+    this.#d(e.expiryTimer), this.#d(e.pollTimer, !0), e.expiryTimer = null, e.pollTimer = null;
+  }
+  #k(e) {
+    if (!(e.cleanupFinished || this.#m.has(e)))
+      for (this.#m.add(e); this.#m.size > Et; ) {
+        const t = this.#m.values().next().value;
+        for (const n of t.controllers) n.abort();
+        this.#a(t);
+      }
+  }
+  async #E(e) {
+    if (e.cleanupFinished || e.cleanupStarted || this.#i)
+      return e.cleanup.promise;
+    e.cleanupStarted = !0, this.#k(e);
+    let t = 100, n = !0;
+    for (; !this.#i && !e.cleanupFinished && (n || this.#r() <= e.registrationDeadlineMs); ) {
+      n = !1;
+      const r = await this.#q(e);
+      if (e.cleanupFinished) return e.cleanup.promise;
+      if (r === "done")
+        return this.#a(e), e.cleanup.promise;
+      const s = e.registrationDeadlineMs - this.#r();
+      if (s <= 0) break;
+      await new Promise((o) => {
+        e.retryResolve = o, e.retryTimer = this.#v(() => {
+          e.retryResolve = null, o();
+        }, Math.min(t, s));
+      }), e.retryResolve = null, e.retryTimer = null, t = Math.min(t * 2, 4e3);
+    }
+    return this.#a(e), e.cleanup.promise;
+  }
+  async #q(e) {
+    if (!e.verifier || !e.challenge) return "done";
+    const t = this.#N(e), n = e.registrationDeadlineMs - this.#r(), r = n > 0 ? Math.min(4e3, n) : 1e3, s = this.#v(() => t.abort(), Math.max(1, r));
+    let o = null;
+    try {
+      const l = this.#e.fetch(
+        `${P}/relay/v1/transactions/${e.transactionId}/cancel`,
+        $({
+          codeVerifier: e.verifier,
+          schemaVersion: 1,
+          state: e.state,
+          transactionId: e.transactionId
+        }, t.signal)
+      );
+      o = await B(
+        l,
+        t.signal,
+        k
+      );
+      const u = o.status;
+      return C(t, o), o = null, u === 204 || u === 400 || u === 403 || u === 409 || u === 410 ? "done" : "retry";
+    } catch {
+      return o && C(t, o), "retry";
+    } finally {
+      try {
+        t.abort();
+      } catch {
+      }
+      this.#d(s), this.#D(e, t);
+    }
+  }
+  #X(e) {
+    let t;
+    try {
+      t = this.#e.fetch(
+        `${P}/relay/v1/transactions/${e.transactionId}/cancel`,
+        {
+          ...$({
+            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;
+    }
+    ie(Promise.resolve(t).then(k));
+  }
+  #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.#L(e);
+      for (const t of e.controllers)
+        t.abort(), this.#A.delete(t);
+      e.controllers.clear(), this.#m.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.#V || this.#i)) {
+      this.#V = !0, this.#x = !0;
+      try {
+        let e = null;
+        try {
+          const s = this.#e.getStorage;
+          e = typeof s == "function" ? Reflect.apply(s, 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.#i || this.#l) {
+          this.#u = null;
+          return;
+        }
+        if (this.#u = e, this.#Z(), this.#i || this.#l) {
+          this.#u = null;
+          return;
+        }
+        const t = (s) => {
+          const o = this.#o;
+          if (!o || !this.#c(o)) return;
+          const l = `${Y}${o.state}`;
+          s?.key === l && this.#P(o, !0);
+        };
+        this.#g = t;
+        let n = !1, r = null;
+        try {
+          const s = this.#y?.addEventListener, o = this.#y?.removeEventListener;
+          if (typeof s != "function" || typeof o != "function")
+            throw new TypeError("storage events unavailable");
+          r = () => Reflect.apply(
+            o,
+            this.#y,
+            ["storage", t]
+          ), this.#b = r, Reflect.apply(s, this.#y, ["storage", this.#g]), n = !0;
+        } catch {
+          this.#l = !0;
+        }
+        if (!n || this.#i || this.#l) {
+          try {
+            r?.();
+          } catch {
+          }
+          this.#g = null, this.#b = null, this.#u = null;
+        }
+      } finally {
+        this.#x = !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, At), r = [];
+    for (let s = 0; s < n && !this.#i && !this.#l; s += 1) {
+      let o;
+      try {
+        o = e.key(s);
+      } catch {
+        continue;
+      }
+      r.push(o);
+    }
+    for (const s of r) {
+      if (this.#i || this.#l) return;
+      if (typeof s != "string" || !s.startsWith(Y)) continue;
+      const o = s.slice(Y.length);
+      if (D.test(o))
+        try {
+          const l = e.getItem(s);
+          if (l === null) continue;
+          const u = F(
+            U(l, 2048),
+            ["code", "expiresAt", "schemaVersion", "state"],
+            "CALLBACK_ERROR"
+          );
+          if (u.schemaVersion !== 1 || u.state !== o || !D.test(u.code))
+            continue;
+          q(u.expiresAt, "CALLBACK_ERROR") <= this.#r() && e.removeItem(s);
+        } catch {
+        }
+    }
+  }
+}
+function Lt(i) {
+  return new _t(i);
+}
+function xt(i, e = {}) {
+  const t = (r, s) => r !== 0 ? Promise.reject(a("INVALID_REQUEST")) : s(), n = {
+    connect(...r) {
+      return t(r.length, () => i.execute("connect", void 0));
+    },
+    destroy(...r) {
+      return t(r.length, () => i.destroy());
+    },
+    disconnect(...r) {
+      return t(r.length, () => i.disconnect());
+    },
+    getSnapshot(...r) {
+      if (r.length !== 0) throw a("INVALID_REQUEST");
+      return i.getSnapshot();
+    },
+    openAccount(...r) {
+      return t(r.length, () => i.execute("account", void 0));
+    },
+    subscribe(r, ...s) {
+      if (s.length !== 0) throw a("INVALID_REQUEST");
+      return i.subscribe(r);
+    }
+  };
+  for (const [r, s] of Object.entries(e))
+    n[r] = function(l, ...u) {
+      return u.length !== 0 ? Promise.reject(a("INVALID_REQUEST")) : i.execute(s, l);
+    };
+  return Object.freeze(n);
+}
+const Tt = Object.freeze({
+  account: Object.freeze({
+    buildRequest: () => ot({}),
+    kind: "account",
+    operation: "sdn.wallet.account.v1",
+    parseResult: ct
+  }),
+  connect: Object.freeze({
+    buildRequest: () => rt({}),
+    kind: "connect",
+    operation: "sdn.wallet.connect.v1",
+    parseResult: st
+  })
+}), Ct = Object.freeze({
+  ...Tt,
+  assetReviewApproval: Object.freeze({
+    buildRequest: ut,
+    kind: "typed",
+    operation: "sdn.asset-review.decision.v1",
+    parseResult: ht
+  }),
+  authorityActivation: Object.freeze({
+    buildRequest: at,
+    kind: "typed",
+    operation: "sdn.asset-review.authority-activation.v1",
+    parseResult: lt
+  })
+});
+function Pt() {
+  if (arguments.length !== 0) throw a("INVALID_REQUEST");
+  const i = Lt({
+    adapters: Ct,
+    clientId: "sdn-asset-review-v1"
+  });
+  return xt(i, {
+    requestAssetReviewApproval: "assetReviewApproval",
+    requestAuthorityActivation: "authorityActivation"
+  });
+}
+export {
+  _e as WALLET_CLIENT_ERRORS,
+  Pt as createAssetReviewWalletClient
+};