@glyphteck/veyl 0.75.1 → 0.77.0

package/dist/accountprofiles.js

@@ -62,6 +62,9 @@ var ACCOUNT_CONNECTION_SLOW_MS = 4 * MS_PER_SECOND;
 var ACCOUNT_CONNECTION_UNAVAILABLE_MS = 15 * MS_PER_SECOND;
 var ACCOUNT_CONNECTION_RETRY_MIN_MS = MS_PER_SECOND;
 var ACCOUNT_CONNECTION_RETRY_MAX_MS = 30 * MS_PER_SECOND;
+var TICKET_MESSAGE_LIMIT = 4000;
+var TICKET_ATTACHMENT_LIMIT = 3;
+var TICKET_ATTACHMENT_MAX_BYTES = 5 * MIB_BYTES;
 var AUTOLOCK_MIN_MINUTES = 1;
 var AUTOLOCK_MAX_MINUTES = 60;
 var BTC_PRICE_FALLBACK = 80000;
@@ -69,6 +72,8 @@ var CHAT_MESSAGE_EDIT_WINDOW_MS = 10 * MINUTE_MS;
 var CHAT_SEND_CONNECTION_WAIT_MS = 30 * MS_PER_SECOND;
 var CALL_SPEAKING_THRESHOLD = 0.02;
 var CALL_SPEAKING_HOLD_MS = 320;
+var WEB_LAYOUT_SAVE_DELAY_MS = 2 * MS_PER_SECOND;
+var WEB_CHAT_LAYOUT_LIMIT = 32;
 var LOCAL_MEDIA_CACHE_MAX_BYTES = 512 * MIB_BYTES;
 var LOCAL_PROFILE_CACHE_MAX_ITEMS = 500;
 var LOCAL_PROFILE_CACHE_MAX_AGE_MS = 30 * DAY_MS;
@@ -177,6 +182,7 @@ var WALLET_PENDING_TRANSFER_CLAIM_COOLDOWN_MS = 15 * MS_PER_SECOND;
 var WALLET_SDK_BACKGROUND_QUIET_MS = MS_PER_SECOND;
 var WALLET_RECENT_TRANSFER_LIMIT = 100;
 var WALLET_TRANSFER_PAGE_LIMIT = 100;
+var WALLET_TOKEN_HISTORY_PAGE_SIZE = 50;
 var WALLET_TRANSFER_FETCH_THROTTLE_MS = 150;
 var WALLET_PENDING_TRANSFER_CLAIM_RETRY_MS = 3 * MS_PER_SECOND;
 var WALLET_SENT_TRANSFER_REFRESH_DELAY_MS = 3 * MS_PER_SECOND;

package/dist/auth.js

@@ -128,6 +128,158 @@ function hasAgreement(user, contract = CURRENT_AGREEMENT) {
   return isAgreementAccepted(user?.agreement, contract);
 }
 
+// ../../core/crypto/core.js
+"use client";
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+var MEM_KIB = 32 * 1024;
+function randomBytes(length) {
+  const out = new Uint8Array(length);
+  if (globalThis.crypto?.getRandomValues) {
+    globalThis.crypto.getRandomValues(out);
+    return out;
+  }
+  throw new Error("crypto.getRandomValues is not available in this environment");
+}
+function toBytes(value, label = "bytes") {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return encoder.encode(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  throw new Error(`Invalid ${label}`);
+}
+function toBytes32(k, label = "key") {
+  if (k instanceof Uint8Array) {
+    if (k.length !== 32)
+      throw new Error(`Invalid ${label} key length`);
+    return k;
+  }
+  if (typeof k === "string") {
+    return fromHex(k, label);
+  }
+  throw new Error(`${label} key must be Uint8Array or 64-char hex`);
+}
+function toHex(value) {
+  return Array.from(toBytes(value)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function fromHexBytes(hex, label = "hex") {
+  if (typeof hex !== "string" || hex.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(hex)) {
+    throw new Error(`Invalid ${label} hex`);
+  }
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0;i < out.length; i += 1) {
+    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function fromHex(hex, label = "hex") {
+  const bytes = fromHexBytes(hex, label);
+  if (bytes.length !== 32) {
+    throw new Error(`Invalid ${label} hex`);
+  }
+  return bytes;
+}
+function cleanBytes(...values) {
+  for (const value of values) {
+    try {
+      value?.fill?.(0);
+    } catch {}
+  }
+}
+
+// ../../core/crypto/base64.js
+"use client";
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var VALUE_BY_CHAR = new Map([...ALPHABET].map((char, index) => [char, index]));
+function bytesBase64Url(value, label = "base64url bytes") {
+  const bytes = toBytes(value, label);
+  let output = "";
+  for (let index = 0;index < bytes.length; index += 3) {
+    const a = bytes[index];
+    const hasB = index + 1 < bytes.length;
+    const hasC = index + 2 < bytes.length;
+    const b = hasB ? bytes[index + 1] : 0;
+    const c = hasC ? bytes[index + 2] : 0;
+    output += ALPHABET[a >>> 2];
+    output += ALPHABET[(a & 3) << 4 | b >>> 4];
+    if (hasB)
+      output += ALPHABET[(b & 15) << 2 | c >>> 6];
+    if (hasC)
+      output += ALPHABET[c & 63];
+  }
+  return output;
+}
+function base64UrlBytes(value, label = "base64url") {
+  const text = typeof value === "string" ? value.trim() : "";
+  if (!text || text.length % 4 === 1 || !/^[A-Za-z0-9_-]+$/u.test(text)) {
+    throw new Error(`invalid ${label}`);
+  }
+  const output = new Uint8Array(Math.floor(text.length * 6 / 8));
+  let bits = 0;
+  let bitCount = 0;
+  let offset = 0;
+  for (const char of text) {
+    const next = VALUE_BY_CHAR.get(char);
+    if (next == null)
+      throw new Error(`invalid ${label}`);
+    bits = bits << 6 | next;
+    bitCount += 6;
+    if (bitCount >= 8) {
+      bitCount -= 8;
+      output[offset++] = bits >>> bitCount & 255;
+      bits &= bitCount ? (1 << bitCount) - 1 : 0;
+    }
+  }
+  return output;
+}
+
+// ../../core/passkeyproof.js
+function binary(value, label) {
+  if (typeof value === "string") {
+    const bytes = base64UrlBytes(value, label);
+    if (bytesBase64Url(bytes) !== value) {
+      cleanBytes(bytes);
+      throw new Error(`invalid ${label}`);
+    }
+    return bytes;
+  }
+  return toBytes(value, label);
+}
+function encoded(value, label) {
+  return bytesBase64Url(binary(value, label));
+}
+function passkeyProof(credential) {
+  if (credential?.type !== "public-key" || !credential.response) {
+    throw new Error("invalid passkey credential");
+  }
+  const rawId = encoded(credential.rawId, "passkey id");
+  if (!rawId || credential.id !== rawId)
+    throw new Error("passkey id mismatch");
+  const source = credential.response;
+  const response = {
+    clientDataJSON: encoded(source.clientDataJSON, "passkey client data")
+  };
+  if (source.attestationObject != null) {
+    response.attestationObject = encoded(source.attestationObject, "passkey attestation");
+    const transports = typeof source.getTransports === "function" ? source.getTransports() : source.transports;
+    if (Array.isArray(transports))
+      response.transports = transports.filter((value) => typeof value === "string");
+  } else {
+    response.authenticatorData = encoded(source.authenticatorData, "passkey authenticator data");
+    response.signature = encoded(source.signature, "passkey signature");
+    response.userHandle = source.userHandle == null ? null : encoded(source.userHandle, "passkey user handle");
+  }
+  return { id: rawId, rawId, type: "public-key", response };
+}
+
 // ../../core/origins.js
 var ROOT_DOMAIN = "glyphteck.com";
 var VEYL_DEV_WEB_PORT_MIN = 3000;
@@ -139,7 +291,8 @@ var domains = Object.freeze({
   veylDev: `dev.veyl.${ROOT_DOMAIN}`,
   live: `live.veyl.${ROOT_DOMAIN}`,
   liveDev: `live.dev.veyl.${ROOT_DOMAIN}`,
-  bitcoin: `bitcoin.veyl.${ROOT_DOMAIN}`
+  bitcoin: `bitcoin.veyl.${ROOT_DOMAIN}`,
+  bitcoinHistory: `history.veyl.${ROOT_DOMAIN}`
 });
 function getVeylDevWebOrigin(port) {
   const value = Number(port);
@@ -161,6 +314,7 @@ var liveEndpoints = Object.freeze({
   dev: `wss://${domains.liveDev}`
 });
 var bitcoinEndpoint = `https://${domains.bitcoin}/current`;
+var bitcoinHistoryEndpoint = `https://${domains.bitcoinHistory}`;
 var appDomains = Object.freeze([
   domains.veyl
 ]);
@@ -170,12 +324,14 @@ var appLinkDomains = Object.freeze([
 ]);
 
 // ../../product/links.js
+var APP_STORE_ID = "6782957925";
 var links = Object.freeze({
   root: origins.root,
   rootDev: origins.rootDev,
   veyl: origins.veyl,
   veylDev: origins.veylDev,
   veylDevWeb: origins.veylDevWeb,
+  appStore: `https://apps.apple.com/app/id${APP_STORE_ID}`,
   terms: `${origins.veyl}/terms#terms`,
   contact: `mailto:contact@${ROOT_DOMAIN}`,
   regtestFaucet: "https://app.lightspark.com/regtest-faucet"
@@ -492,14 +648,14 @@ function openAuth(options = {}) {
     const result = await requireMethod(ceremony.create, "passkey creation")(publicKeyOptions, operation);
     if (!result)
       throw new Error("no credential received");
-    return result;
+    return passkeyProof(result);
   }
   async function getCredential(publicKeyOptions, operation = {}) {
     operation.onPrompt?.();
     const result = await requireMethod(ceremony.get, "passkey verification")(publicKeyOptions, operation);
     if (!result)
       throw new Error("no assertion received");
-    return result;
+    return passkeyProof(result);
   }
   async function register(operation = {}, tokenOnly = false) {
     try {