@bananalink-sdk/protocol 1.2.7

package/dist/index.cjs

@@ -0,0 +1,615 @@
+'use strict';
+
+var chunkVXLUSU5B_cjs = require('./chunk-VXLUSU5B.cjs');
+var chunkGI3BUPIH_cjs = require('./chunk-GI3BUPIH.cjs');
+require('./chunk-A6FLEJ7R.cjs');
+var chunkWGEGR3DF_cjs = require('./chunk-WGEGR3DF.cjs');
+
+// src/types/wallet-messages.ts
+function isClaimSessionPayload(payload) {
+  return payload?.type === "claim_session";
+}
+chunkWGEGR3DF_cjs.__name(isClaimSessionPayload, "isClaimSessionPayload");
+function isPrefetchMetadataPayload(payload) {
+  return payload?.type === "prefetch_metadata";
+}
+chunkWGEGR3DF_cjs.__name(isPrefetchMetadataPayload, "isPrefetchMetadataPayload");
+function isConnectionRejectedPayload(payload) {
+  return payload?.type === "connection_rejected";
+}
+chunkWGEGR3DF_cjs.__name(isConnectionRejectedPayload, "isConnectionRejectedPayload");
+function isAuthenticateConnectionPayload(payload) {
+  return payload?.type === "authenticate_connection";
+}
+chunkWGEGR3DF_cjs.__name(isAuthenticateConnectionPayload, "isAuthenticateConnectionPayload");
+function isWalletReconnectPayload(payload) {
+  return payload?.type === "wallet_reconnect";
+}
+chunkWGEGR3DF_cjs.__name(isWalletReconnectPayload, "isWalletReconnectPayload");
+function isWalletHandshakeMessage(message) {
+  return message?.type === "wallet_handshake";
+}
+chunkWGEGR3DF_cjs.__name(isWalletHandshakeMessage, "isWalletHandshakeMessage");
+function isConnectionRejectedMessage(message) {
+  return message?.type === "connection_rejected";
+}
+chunkWGEGR3DF_cjs.__name(isConnectionRejectedMessage, "isConnectionRejectedMessage");
+function isConnectionAuthenticatedMessage(message) {
+  return message?.type === "connection_authenticated";
+}
+chunkWGEGR3DF_cjs.__name(isConnectionAuthenticatedMessage, "isConnectionAuthenticatedMessage");
+
+// src/types/client-messages.ts
+function isClientReconnectPayload(payload) {
+  return payload?.type === "client_reconnect";
+}
+chunkWGEGR3DF_cjs.__name(isClientReconnectPayload, "isClientReconnectPayload");
+function isCloseSessionPayload(payload) {
+  return payload?.type === "close_session";
+}
+chunkWGEGR3DF_cjs.__name(isCloseSessionPayload, "isCloseSessionPayload");
+
+// src/types/relay-messages.ts
+function isSessionClosedAck(message) {
+  return message?.type === "session_closed_ack";
+}
+chunkWGEGR3DF_cjs.__name(isSessionClosedAck, "isSessionClosedAck");
+function isSessionClosedNotification(message) {
+  return message?.type === "session_closed_notification";
+}
+chunkWGEGR3DF_cjs.__name(isSessionClosedNotification, "isSessionClosedNotification");
+function isReconnectedMessage(message) {
+  return message?.type === "reconnected";
+}
+chunkWGEGR3DF_cjs.__name(isReconnectedMessage, "isReconnectedMessage");
+
+// src/utils/public-keys.ts
+function compressPublicKey(publicKey) {
+  const keyWithoutPrefix = publicKey.startsWith("AES-GCM:") ? publicKey.slice(8) : publicKey;
+  return keyWithoutPrefix.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+chunkWGEGR3DF_cjs.__name(compressPublicKey, "compressPublicKey");
+function decompressPublicKey(compressedKey) {
+  let base64Key = compressedKey.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = base64Key.length % 4;
+  if (padding > 0) {
+    base64Key += "=".repeat(4 - padding);
+  }
+  return base64Key.startsWith("AES-GCM:") ? base64Key : `AES-GCM:${base64Key}`;
+}
+chunkWGEGR3DF_cjs.__name(decompressPublicKey, "decompressPublicKey");
+
+// src/utils/url-encoding.ts
+var PROVIDER_SHORTCODES = {
+  "uwebsockets": "u",
+  // Legacy - API may still return this
+  "websocket": "w",
+  "pusher": "p",
+  "ably": "a"
+};
+var PRODUCTION_RELAY_URLS = [
+  "wss://relay.banana.link/v1",
+  "https://relay.banana.link/v1"
+];
+var RELAY_SHORTCODES = {
+  "wss://relay.dev.banana.link/v1": "d",
+  "https://relay.dev.banana.link/v1": "d",
+  "wss://relay.staging.banana.link/v1": "s",
+  // Future staging environment
+  "https://relay.staging.banana.link/v1": "s"
+};
+function encodeUrlParameter(value) {
+  return encodeURIComponent(value);
+}
+chunkWGEGR3DF_cjs.__name(encodeUrlParameter, "encodeUrlParameter");
+function buildQueryString(params) {
+  const pairs = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) {
+      pairs.push(`${encodeUrlParameter(key)}=${encodeUrlParameter(value)}`);
+    }
+  }
+  return pairs.join("&");
+}
+chunkWGEGR3DF_cjs.__name(buildQueryString, "buildQueryString");
+function encodeCompactConnectionString(payload) {
+  const params = {
+    s: payload.sessionId,
+    // sessionId -> s
+    k: compressPublicKey(payload.publicKey)
+    // publicKey -> k (compressed)
+  };
+  if (payload.providerId) {
+    params.p = PROVIDER_SHORTCODES[payload.providerId] || payload.providerId;
+  }
+  if (payload.relayUrl) {
+    if (PRODUCTION_RELAY_URLS.includes(payload.relayUrl)) ; else if (RELAY_SHORTCODES[payload.relayUrl]) {
+      params.r = RELAY_SHORTCODES[payload.relayUrl];
+    } else {
+      params.r = payload.relayUrl;
+    }
+  }
+  const queryString = buildQueryString(params);
+  return `${chunkGI3BUPIH_cjs.DEEPLINK_SCHEME}://connect?${queryString}`;
+}
+chunkWGEGR3DF_cjs.__name(encodeCompactConnectionString, "encodeCompactConnectionString");
+function encodeConnectionString(payload) {
+  const params = {
+    sessionId: payload.sessionId,
+    publicKey: payload.publicKey
+  };
+  if (payload.providerId) {
+    params.providerId = payload.providerId;
+  }
+  if (payload.relayUrl) {
+    params.relay = payload.relayUrl;
+  }
+  const queryString = buildQueryString(params);
+  return `${chunkGI3BUPIH_cjs.DEEPLINK_SCHEME}://connect?${queryString}`;
+}
+chunkWGEGR3DF_cjs.__name(encodeConnectionString, "encodeConnectionString");
+function encodeUniversalLink(payload, options = {}) {
+  const {
+    baseUrl = "https://banana.link",
+    fallbackUrl = "https://banana.link/download"
+  } = options;
+  const params = {
+    sessionId: payload.sessionId,
+    key: payload.publicKey,
+    // Use 'key' instead of 'publicKey' for universal links
+    fallback: fallbackUrl
+  };
+  if (payload.providerId) {
+    params.provider = payload.providerId;
+  }
+  if (payload.relayUrl) {
+    params.relay = payload.relayUrl;
+  }
+  const queryString = buildQueryString(params);
+  return `${baseUrl}/connect?${queryString}`;
+}
+chunkWGEGR3DF_cjs.__name(encodeUniversalLink, "encodeUniversalLink");
+
+// src/utils/url-decoding.ts
+var PROVIDER_SHORTCODES_REVERSE = {
+  "u": "websocket",
+  // Decode legacy 'u' to new 'websocket' name
+  "w": "websocket",
+  "p": "pusher",
+  "a": "ably"
+};
+var RELAY_SHORTCODES_REVERSE = {
+  "d": "wss://relay.dev.banana.link/v1",
+  "s": "wss://relay.staging.banana.link/v1"
+};
+function decodeUrlParameter(value) {
+  return decodeURIComponent(value);
+}
+chunkWGEGR3DF_cjs.__name(decodeUrlParameter, "decodeUrlParameter");
+function parseQueryString(query) {
+  const params = {};
+  const cleanQuery = query.startsWith("?") ? query.slice(1) : query;
+  if (!cleanQuery) {
+    return params;
+  }
+  for (const pair of cleanQuery.split("&")) {
+    const [key, ...valueParts] = pair.split("=");
+    if (key) {
+      const value = valueParts.join("=");
+      params[decodeUrlParameter(key)] = decodeUrlParameter(value);
+    }
+  }
+  return params;
+}
+chunkWGEGR3DF_cjs.__name(parseQueryString, "parseQueryString");
+function decodeConnectionString(connectionString) {
+  let url;
+  try {
+    url = new URL(connectionString);
+  } catch {
+    throw new Error(`Invalid connection string format: ${connectionString}`);
+  }
+  const params = parseQueryString(url.search);
+  const sessionId = params.sessionId || params.s;
+  let publicKey = params.publicKey || params.key || params.k;
+  let providerId = params.providerId || params.provider || params.p;
+  let relayUrl = params.relay || params.r;
+  if (!sessionId || !publicKey) {
+    throw new Error("Missing required parameters: sessionId and publicKey");
+  }
+  if (params.k && !params.publicKey && !params.key) {
+    publicKey = decompressPublicKey(params.k);
+  }
+  if (params.p && !params.providerId && !params.provider) {
+    providerId = PROVIDER_SHORTCODES_REVERSE[params.p] || params.p;
+  }
+  if (!relayUrl) {
+    relayUrl = "wss://relay.banana.link/v1";
+  } else if (RELAY_SHORTCODES_REVERSE[relayUrl]) {
+    relayUrl = RELAY_SHORTCODES_REVERSE[relayUrl];
+  }
+  if (publicKey && !publicKey.startsWith("AES-GCM:")) {
+    publicKey = `AES-GCM:${publicKey}`;
+  }
+  return {
+    sessionId,
+    publicKey,
+    providerId: providerId || void 0,
+    relayUrl: relayUrl || void 0
+  };
+}
+chunkWGEGR3DF_cjs.__name(decodeConnectionString, "decodeConnectionString");
+function isValidConnectionString(connectionString) {
+  try {
+    decodeConnectionString(connectionString);
+    return true;
+  } catch {
+    return false;
+  }
+}
+chunkWGEGR3DF_cjs.__name(isValidConnectionString, "isValidConnectionString");
+
+// src/utils/wallet-session-claim.ts
+var _WalletSessionClaimManager = class _WalletSessionClaimManager {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  /**
+   * Generate a new wallet session claim with provided nonce
+   * @param sessionId - Session identifier
+   * @param sessionNonce - Pre-generated cryptographically secure nonce (use @bananalink-sdk/crypto)
+   * @returns Generated wallet session claim
+   */
+  async generateClaim(sessionId, sessionNonce) {
+    const claim = {
+      sessionNonce,
+      timestamp: Date.now()
+    };
+    await this.storage.store(sessionId, claim);
+    return claim;
+  }
+  /**
+   * Retrieve an existing wallet session claim
+   * @param sessionId - Session identifier
+   * @returns Stored wallet session claim or null if not found
+   */
+  async getClaim(sessionId) {
+    return this.storage.retrieve(sessionId);
+  }
+  /**
+   * Validate a wallet session claim for reconnection
+   * @param claim - Claim to validate
+   * @param storedClaim - Previously stored claim
+   * @returns Validation result
+   */
+  validateReconnectionClaim(claim, storedClaim) {
+    if (claim.sessionNonce !== storedClaim.sessionNonce) {
+      return {
+        valid: false,
+        reason: "Session nonce mismatch - invalid reconnection attempt"
+      };
+    }
+    const MAX_RECONNECTION_AGE = 24 * 60 * 60 * 1e3;
+    const claimAge = Date.now() - claim.timestamp;
+    if (claimAge > MAX_RECONNECTION_AGE) {
+      return {
+        valid: false,
+        reason: "Session claim too old - please create a new session"
+      };
+    }
+    return { valid: true };
+  }
+  /**
+   * Remove a wallet session claim (on session end)
+   * @param sessionId - Session identifier
+   */
+  async removeClaim(sessionId) {
+    await this.storage.remove(sessionId);
+  }
+  /**
+   * Clear all stored claims
+   */
+  async clearAllClaims() {
+    await this.storage.clear();
+  }
+};
+chunkWGEGR3DF_cjs.__name(_WalletSessionClaimManager, "WalletSessionClaimManager");
+var WalletSessionClaimManager = _WalletSessionClaimManager;
+function createWalletMessageEnvelope(sessionId, claim, payload) {
+  return {
+    sessionId,
+    walletSessionClaim: claim,
+    payload
+  };
+}
+chunkWGEGR3DF_cjs.__name(createWalletMessageEnvelope, "createWalletMessageEnvelope");
+function stripWalletSessionClaim(envelope) {
+  const { walletSessionClaim, ...messageWithoutClaim } = envelope;
+  return messageWithoutClaim;
+}
+chunkWGEGR3DF_cjs.__name(stripWalletSessionClaim, "stripWalletSessionClaim");
+function validateClaimTimestamp(timestamp, maxAge = 30 * 1e3) {
+  const now = Date.now();
+  const age = Math.abs(now - timestamp);
+  return age <= maxAge;
+}
+chunkWGEGR3DF_cjs.__name(validateClaimTimestamp, "validateClaimTimestamp");
+function validateWalletMessageEnvelope(envelope) {
+  const errors = [];
+  if (!envelope.sessionId) {
+    errors.push("Missing session ID");
+  }
+  if (!envelope.walletSessionClaim) {
+    errors.push("Missing wallet session claim");
+  } else {
+    if (!envelope.walletSessionClaim.sessionNonce) {
+      errors.push("Missing session nonce in wallet session claim");
+    }
+    if (!envelope.walletSessionClaim.timestamp) {
+      errors.push("Missing timestamp in wallet session claim");
+    } else if (!validateClaimTimestamp(envelope.walletSessionClaim.timestamp)) {
+      errors.push("Wallet session claim timestamp is too old or invalid");
+    }
+  }
+  if (!envelope.payload) {
+    errors.push("Missing message payload");
+  } else if (!envelope.payload.type) {
+    errors.push("Missing payload type");
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+chunkWGEGR3DF_cjs.__name(validateWalletMessageEnvelope, "validateWalletMessageEnvelope");
+
+// src/utils/client-session-claim.ts
+var _ClientSessionClaimManager = class _ClientSessionClaimManager {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  /**
+   * Generate a new client session claim with provided nonce
+   * @param sessionId - Session identifier
+   * @param claimNonce - Pre-generated cryptographically secure nonce (use @bananalink-sdk/crypto)
+   * @returns Generated client session claim
+   */
+  async generateClaim(sessionId, claimNonce) {
+    const claim = {
+      claimNonce,
+      timestamp: Date.now()
+    };
+    await this.storage.store(sessionId, claim);
+    return claim;
+  }
+  /**
+   * Retrieve an existing client session claim
+   * @param sessionId - Session identifier
+   * @returns Stored client session claim or null if not found
+   */
+  async getClaim(sessionId) {
+    return this.storage.retrieve(sessionId);
+  }
+  /**
+   * Validate a client session claim for reconnection
+   * @param claim - Claim to validate
+   * @param storedClaim - Previously stored claim
+   * @returns Validation result
+   */
+  validateReconnectionClaim(claim, storedClaim) {
+    if (claim.claimNonce !== storedClaim.claimNonce) {
+      return {
+        valid: false,
+        reason: "Client claim nonce mismatch - invalid reconnection attempt"
+      };
+    }
+    const MAX_RECONNECTION_AGE = 24 * 60 * 60 * 1e3;
+    const claimAge = Date.now() - claim.timestamp;
+    if (claimAge > MAX_RECONNECTION_AGE) {
+      return {
+        valid: false,
+        reason: "Client session claim too old - please create a new session"
+      };
+    }
+    return { valid: true };
+  }
+  /**
+   * Remove a client session claim (on session end)
+   * @param sessionId - Session identifier
+   */
+  async removeClaim(sessionId) {
+    await this.storage.remove(sessionId);
+  }
+  /**
+   * Clear all stored claims
+   */
+  async clearAllClaims() {
+    await this.storage.clear();
+  }
+};
+chunkWGEGR3DF_cjs.__name(_ClientSessionClaimManager, "ClientSessionClaimManager");
+var ClientSessionClaimManager = _ClientSessionClaimManager;
+function createClientMessageEnvelope(sessionId, claim, payload) {
+  return {
+    sessionId,
+    clientSessionClaim: claim,
+    payload
+  };
+}
+chunkWGEGR3DF_cjs.__name(createClientMessageEnvelope, "createClientMessageEnvelope");
+function stripClientSessionClaim(envelope) {
+  const { clientSessionClaim, ...messageWithoutClaim } = envelope;
+  return messageWithoutClaim;
+}
+chunkWGEGR3DF_cjs.__name(stripClientSessionClaim, "stripClientSessionClaim");
+function validateClientClaimTimestamp(timestamp, maxAge = 30 * 1e3) {
+  const now = Date.now();
+  const age = Math.abs(now - timestamp);
+  return age <= maxAge;
+}
+chunkWGEGR3DF_cjs.__name(validateClientClaimTimestamp, "validateClientClaimTimestamp");
+function validateClientMessageEnvelope(envelope) {
+  const errors = [];
+  if (!envelope.sessionId) {
+    errors.push("Missing session ID");
+  }
+  if (!envelope.clientSessionClaim) {
+    errors.push("Missing client session claim");
+  } else {
+    if (!envelope.clientSessionClaim.claimNonce) {
+      errors.push("Missing claim nonce in client session claim");
+    }
+    if (!envelope.clientSessionClaim.timestamp) {
+      errors.push("Missing timestamp in client session claim");
+    } else if (!validateClientClaimTimestamp(envelope.clientSessionClaim.timestamp)) {
+      errors.push("Client session claim timestamp is too old or invalid");
+    }
+  }
+  if (!envelope.payload) {
+    errors.push("Missing message payload");
+  } else if (!envelope.payload.type) {
+    errors.push("Missing payload type");
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+chunkWGEGR3DF_cjs.__name(validateClientMessageEnvelope, "validateClientMessageEnvelope");
+
+// src/utils/index.ts
+function generateSessionId() {
+  return chunkVXLUSU5B_cjs.generateUUID();
+}
+chunkWGEGR3DF_cjs.__name(generateSessionId, "generateSessionId");
+function isValidProtocolVersion(version) {
+  return version === "1";
+}
+chunkWGEGR3DF_cjs.__name(isValidProtocolVersion, "isValidProtocolVersion");
+function isValidSessionId(sessionId) {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(sessionId);
+}
+chunkWGEGR3DF_cjs.__name(isValidSessionId, "isValidSessionId");
+
+// package.json
+var package_default = {
+  version: "1.2.7"};
+
+// src/index.ts
+var VERSION = package_default.version;
+var PACKAGE_NAME = "@bananalink-sdk/protocol";
+
+Object.defineProperty(exports, "BANANALINK_CONSTANTS", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.BANANALINK_CONSTANTS; }
+});
+Object.defineProperty(exports, "CRYPTO_CONSTANTS", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.CRYPTO_CONSTANTS; }
+});
+Object.defineProperty(exports, "DEEPLINK_SCHEME", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.DEEPLINK_SCHEME; }
+});
+Object.defineProperty(exports, "DEEP_LINK_CONFIG", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.DEEP_LINK_CONFIG; }
+});
+Object.defineProperty(exports, "DEFAULT_RELAY_URL", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.DEFAULT_RELAY_URL; }
+});
+Object.defineProperty(exports, "DEFAULT_TIMEOUTS", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.DEFAULT_TIMEOUTS; }
+});
+Object.defineProperty(exports, "DEV_CONFIG", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.DEV_CONFIG; }
+});
+Object.defineProperty(exports, "ERROR_MESSAGES", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.ERROR_MESSAGES; }
+});
+Object.defineProperty(exports, "FRUITS", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.FRUITS; }
+});
+Object.defineProperty(exports, "HTTP_ENDPOINTS", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.HTTP_ENDPOINTS; }
+});
+Object.defineProperty(exports, "MESSAGE_FORMAT", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.MESSAGE_FORMAT; }
+});
+Object.defineProperty(exports, "MESSAGE_QUEUE_CONFIG", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.MESSAGE_QUEUE_CONFIG; }
+});
+Object.defineProperty(exports, "NETWORK_CONFIG", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.NETWORK_CONFIG; }
+});
+Object.defineProperty(exports, "PROTOCOL_V2_TIMEOUTS", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.PROTOCOL_V2_TIMEOUTS; }
+});
+Object.defineProperty(exports, "PROTOCOL_VERSION", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.PROTOCOL_VERSION; }
+});
+Object.defineProperty(exports, "QR_CONFIG", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.QR_CONFIG; }
+});
+Object.defineProperty(exports, "SECURITY_LIMITS", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.SECURITY_LIMITS; }
+});
+Object.defineProperty(exports, "WS_MESSAGE_TYPES", {
+  enumerable: true,
+  get: function () { return chunkGI3BUPIH_cjs.WS_MESSAGE_TYPES; }
+});
+exports.ClientSessionClaimManager = ClientSessionClaimManager;
+exports.PACKAGE_NAME = PACKAGE_NAME;
+exports.VERSION = VERSION;
+exports.WalletSessionClaimManager = WalletSessionClaimManager;
+exports.buildQueryString = buildQueryString;
+exports.compressPublicKey = compressPublicKey;
+exports.createClientMessageEnvelope = createClientMessageEnvelope;
+exports.createWalletMessageEnvelope = createWalletMessageEnvelope;
+exports.decodeConnectionString = decodeConnectionString;
+exports.decodeUrlParameter = decodeUrlParameter;
+exports.decompressPublicKey = decompressPublicKey;
+exports.encodeCompactConnectionString = encodeCompactConnectionString;
+exports.encodeConnectionString = encodeConnectionString;
+exports.encodeUniversalLink = encodeUniversalLink;
+exports.encodeUrlParameter = encodeUrlParameter;
+exports.generateSessionId = generateSessionId;
+exports.isAuthenticateConnectionPayload = isAuthenticateConnectionPayload;
+exports.isClaimSessionPayload = isClaimSessionPayload;
+exports.isClientReconnectPayload = isClientReconnectPayload;
+exports.isCloseSessionPayload = isCloseSessionPayload;
+exports.isConnectionAuthenticatedMessage = isConnectionAuthenticatedMessage;
+exports.isConnectionRejectedMessage = isConnectionRejectedMessage;
+exports.isConnectionRejectedPayload = isConnectionRejectedPayload;
+exports.isPrefetchMetadataPayload = isPrefetchMetadataPayload;
+exports.isReconnectedMessage = isReconnectedMessage;
+exports.isSessionClosedAck = isSessionClosedAck;
+exports.isSessionClosedNotification = isSessionClosedNotification;
+exports.isValidConnectionString = isValidConnectionString;
+exports.isValidProtocolVersion = isValidProtocolVersion;
+exports.isValidSessionId = isValidSessionId;
+exports.isWalletHandshakeMessage = isWalletHandshakeMessage;
+exports.isWalletReconnectPayload = isWalletReconnectPayload;
+exports.parseQueryString = parseQueryString;
+exports.stripClientSessionClaim = stripClientSessionClaim;
+exports.stripWalletSessionClaim = stripWalletSessionClaim;
+exports.validateClaimTimestamp = validateClaimTimestamp;
+exports.validateClientClaimTimestamp = validateClientClaimTimestamp;
+exports.validateClientMessageEnvelope = validateClientMessageEnvelope;
+exports.validateWalletMessageEnvelope = validateWalletMessageEnvelope;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map