@morseai/sdk 0.1.0-beta.3

package/dist/index.mjs

@@ -0,0 +1,1606 @@
+import _sodium from 'libsodium-wrappers';
+import { ethers } from 'ethers';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/crypto-x25519.ts
+var crypto_x25519_exports = {};
+__export(crypto_x25519_exports, {
+  X25519_CIPHER_VERSION: () => X25519_CIPHER_VERSION,
+  createKeyCertificate: () => createKeyCertificate,
+  createSharedSignal: () => createSharedSignal,
+  deriveKeyPairFromWalletSignature: () => deriveKeyPairFromWalletSignature,
+  generateSignalId: () => generateSignalId,
+  openSharedSignal: () => openSharedSignal,
+  verifyKeyCertificate: () => verifyKeyCertificate
+});
+async function getSodium() {
+  if (!sodium) {
+    await _sodium.ready;
+    sodium = _sodium;
+  }
+  return sodium;
+}
+async function hkdfSha256(ikm, salt, info, length = 32) {
+  const saltBytes = typeof salt === "string" ? new TextEncoder().encode(salt) : new Uint8Array(salt);
+  const infoBytes = typeof info === "string" ? new TextEncoder().encode(info) : new Uint8Array(info);
+  const ikmCopy = new Uint8Array(ikm.length);
+  ikmCopy.set(ikm);
+  const saltCopy = new Uint8Array(saltBytes.length);
+  saltCopy.set(saltBytes);
+  const infoCopy = new Uint8Array(infoBytes.length);
+  infoCopy.set(infoBytes);
+  const crypto = globalThis.crypto;
+  const keyMaterial = await crypto.subtle.importKey(
+    "raw",
+    ikmCopy.buffer,
+    "HKDF",
+    false,
+    ["deriveBits"]
+  );
+  const derivedBits = await crypto.subtle.deriveBits(
+    {
+      name: "HKDF",
+      hash: "SHA-256",
+      salt: saltCopy.buffer,
+      info: infoCopy.buffer
+    },
+    keyMaterial,
+    length * 8
+  );
+  return new Uint8Array(derivedBits);
+}
+async function deriveKeyPairFromWalletSignature(walletAddress, domain, chainId, signMessage) {
+  await getSodium();
+  const message = `MORSE: derive encryption seed v1 | ${domain} | ${chainId} | ${walletAddress.toLowerCase()}`;
+  const signature = await signMessage(message);
+  const sigBytes = ethers.getBytes(signature);
+  const seed = await hkdfSha256(
+    sigBytes,
+    "MORSE_SEED_v1",
+    walletAddress.toLowerCase(),
+    32
+  );
+  const keypair = sodium.crypto_box_seed_keypair(seed);
+  return {
+    publicKey: keypair.publicKey,
+    privateKey: keypair.privateKey
+  };
+}
+function createKeyCertTypedData(walletAddress, x25519PublicKey, keyId, issuedAt, expiresAt, domain, chainId) {
+  return {
+    domain: {
+      name: "MORSE",
+      version: "1",
+      chainId
+    },
+    types: {
+      MorseKeyCert: [
+        { name: "walletAddress", type: "address" },
+        { name: "x25519PublicKey", type: "bytes32" },
+        { name: "keyId", type: "bytes32" },
+        { name: "issuedAt", type: "uint64" },
+        { name: "expiresAt", type: "uint64" },
+        { name: "domain", type: "string" }
+      ]
+    },
+    primaryType: "MorseKeyCert",
+    message: {
+      walletAddress: walletAddress.toLowerCase(),
+      x25519PublicKey: ethers.zeroPadValue(
+        ethers.hexlify(Buffer.from(x25519PublicKey, "base64")),
+        32
+      ),
+      keyId: `0x${keyId}`,
+      issuedAt,
+      expiresAt,
+      domain
+    }
+  };
+}
+async function createKeyCertificate(walletAddress, x25519PublicKey, domain, chainId, expiresAt, signTypedData) {
+  const issuedAt = Date.now();
+  const abiCoder = ethers.AbiCoder.defaultAbiCoder();
+  const keyIdInput = abiCoder.encode(
+    ["address", "bytes32", "uint64", "string", "uint256"],
+    [
+      walletAddress.toLowerCase(),
+      ethers.zeroPadValue(
+        ethers.hexlify(Buffer.from(x25519PublicKey, "base64")),
+        32
+      ),
+      expiresAt,
+      domain,
+      chainId
+    ]
+  );
+  const keyId = ethers.keccak256(keyIdInput).slice(2);
+  const typedData = createKeyCertTypedData(
+    walletAddress,
+    x25519PublicKey,
+    keyId,
+    issuedAt,
+    expiresAt,
+    domain,
+    chainId
+  );
+  const signature = await signTypedData(
+    typedData.domain,
+    typedData.types,
+    typedData.message
+  );
+  return {
+    walletAddress: walletAddress.toLowerCase(),
+    x25519PublicKey,
+    keyId,
+    expiresAt,
+    issuedAt,
+    domain,
+    chainId,
+    signature
+  };
+}
+function verifyKeyCertificate(cert) {
+  try {
+    const typedData = createKeyCertTypedData(
+      cert.walletAddress,
+      cert.x25519PublicKey,
+      cert.keyId,
+      cert.issuedAt,
+      cert.expiresAt,
+      cert.domain,
+      cert.chainId
+    );
+    const recovered = ethers.verifyTypedData(
+      typedData.domain,
+      typedData.types,
+      typedData.message,
+      cert.signature
+    );
+    return recovered.toLowerCase() === cert.walletAddress.toLowerCase();
+  } catch {
+    return false;
+  }
+}
+async function createSharedSignal(payloadBytes, recipientPubKey, walletTarget, walletCreator, expiresAt, signalId) {
+  await getSodium();
+  const dataKey = sodium.randombytes_buf(32);
+  const payloadNonce = sodium.randombytes_buf(sodium.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES);
+  const encryptedPayload = sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(
+    payloadBytes,
+    null,
+    null,
+    payloadNonce,
+    dataKey
+  );
+  const senderKeypair = sodium.crypto_box_keypair();
+  const sharedSecret = sodium.crypto_scalarmult(
+    senderKeypair.privateKey,
+    recipientPubKey
+  );
+  const salt = `MORSE_SEAL_${signalId}_v1`;
+  const info = "wrap_datakey";
+  const wrappingKey = await hkdfSha256(sharedSecret, salt, info, 32);
+  const sealedNonce = sodium.randombytes_buf(sodium.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES);
+  const expiresAtInt = Math.floor(Number(expiresAt));
+  const abiCoder = ethers.AbiCoder.defaultAbiCoder();
+  const senderEphemeralPubKeyHex = ethers.zeroPadValue(ethers.hexlify(senderKeypair.publicKey), 32);
+  const aad = abiCoder.encode(
+    ["string", "address", "address", "uint64", "string", "bytes32"],
+    [
+      signalId,
+      walletTarget.toLowerCase(),
+      walletCreator.toLowerCase(),
+      expiresAtInt,
+      X25519_CIPHER_VERSION,
+      senderEphemeralPubKeyHex
+    ]
+  );
+  const aadBytes = ethers.getBytes(aad);
+  const aadHash = ethers.keccak256(aad).slice(2);
+  const sealedDataKey = sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(
+    dataKey,
+    aadBytes,
+    null,
+    sealedNonce,
+    wrappingKey
+  );
+  return {
+    cipherVersion: X25519_CIPHER_VERSION,
+    encryptedPayload: Buffer.from(encryptedPayload).toString("base64"),
+    payloadNonce: Buffer.from(payloadNonce).toString("base64"),
+    sealedDataKey: Buffer.from(sealedDataKey).toString("base64"),
+    sealedNonce: Buffer.from(sealedNonce).toString("base64"),
+    senderEphemeralPublicKey: Buffer.from(senderKeypair.publicKey).toString("base64"),
+    aadHash
+  };
+}
+async function openSharedSignal(encryptedPayloadBase64, payloadNonceBase64, sealedDataKeyBase64, sealedNonceBase64, senderEphemeralPublicKeyBase64, signalId, walletTarget, walletCreator, expiresAt, aadHash, walletAddress, domain, chainId, signMessage) {
+  await getSodium();
+  const recipientKeypair = await deriveKeyPairFromWalletSignature(
+    walletAddress,
+    domain,
+    chainId,
+    signMessage
+  );
+  const senderEphemeralPub = ethers.getBytes(
+    `0x${Buffer.from(senderEphemeralPublicKeyBase64, "base64").toString("hex")}`
+  );
+  const sharedSecret = sodium.crypto_scalarmult(
+    recipientKeypair.privateKey,
+    senderEphemeralPub
+  );
+  const salt = `MORSE_SEAL_${signalId}_v1`;
+  const info = "wrap_datakey";
+  const wrappingKey = await hkdfSha256(sharedSecret, salt, info, 32);
+  const sealedDataKey = ethers.getBytes(`0x${Buffer.from(sealedDataKeyBase64, "base64").toString("hex")}`);
+  const sealedNonce = ethers.getBytes(`0x${Buffer.from(sealedNonceBase64, "base64").toString("hex")}`);
+  const expiresAtInt = Math.floor(Number(expiresAt));
+  const abiCoder = ethers.AbiCoder.defaultAbiCoder();
+  const aad = abiCoder.encode(
+    ["string", "address", "address", "uint64", "string", "bytes32"],
+    [
+      signalId,
+      walletTarget.toLowerCase(),
+      walletCreator.toLowerCase(),
+      expiresAtInt,
+      X25519_CIPHER_VERSION,
+      ethers.zeroPadValue(ethers.hexlify(senderEphemeralPub), 32)
+    ]
+  );
+  const aadBytes = ethers.getBytes(aad);
+  const computedAadHash = ethers.keccak256(aad).slice(2);
+  if (computedAadHash !== aadHash) {
+    throw new Error("AAD hash mismatch - possible tampering");
+  }
+  const dataKey = sodium.crypto_aead_xchacha20poly1305_ietf_decrypt(
+    null,
+    sealedDataKey,
+    aadBytes,
+    sealedNonce,
+    wrappingKey
+  );
+  const encryptedPayload = new Uint8Array(Buffer.from(encryptedPayloadBase64, "base64"));
+  const payloadNonce = new Uint8Array(Buffer.from(payloadNonceBase64, "base64"));
+  const payload = sodium.crypto_aead_xchacha20poly1305_ietf_decrypt(
+    null,
+    encryptedPayload,
+    null,
+    payloadNonce,
+    dataKey
+  );
+  return payload;
+}
+function generateSignalId() {
+  const bytes = new Uint8Array(16);
+  globalThis.crypto.getRandomValues(bytes);
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hex.substring(0, 20);
+}
+var sodium, X25519_CIPHER_VERSION;
+var init_crypto_x25519 = __esm({
+  "src/crypto-x25519.ts"() {
+    X25519_CIPHER_VERSION = "morse-x25519-xchacha20poly1305-v2";
+  }
+});
+
+// src/rate-limiter.ts
+var RateLimiter = class {
+  constructor(config) {
+    this.requests = /* @__PURE__ */ new Map();
+    this.maxRequests = config.maxRequests;
+    this.windowMs = config.windowMs;
+  }
+  async checkLimit(identifier = "default") {
+    const now = Date.now();
+    const requests = this.requests.get(identifier) || [];
+    const recentRequests = requests.filter((timestamp) => now - timestamp < this.windowMs);
+    if (recentRequests.length >= this.maxRequests) {
+      const oldestRequest = Math.min(...recentRequests);
+      const waitTime = this.windowMs - (now - oldestRequest);
+      throw new RateLimitError(
+        `Rate limit exceeded. Maximum ${this.maxRequests} requests per ${this.windowMs}ms. Retry after ${Math.ceil(waitTime / 1e3)}s.`,
+        waitTime
+      );
+    }
+    recentRequests.push(now);
+    this.requests.set(identifier, recentRequests);
+    this.cleanup(identifier, now);
+  }
+  cleanup(identifier, now) {
+    const requests = this.requests.get(identifier);
+    if (requests) {
+      const validRequests = requests.filter((timestamp) => now - timestamp < this.windowMs);
+      if (validRequests.length === 0) {
+        this.requests.delete(identifier);
+      } else {
+        this.requests.set(identifier, validRequests);
+      }
+    }
+  }
+  reset(identifier = "default") {
+    this.requests.delete(identifier);
+  }
+  resetAll() {
+    this.requests.clear();
+  }
+  getRemainingRequests(identifier = "default") {
+    const now = Date.now();
+    const requests = this.requests.get(identifier) || [];
+    const recentRequests = requests.filter((timestamp) => now - timestamp < this.windowMs);
+    return Math.max(0, this.maxRequests - recentRequests.length);
+  }
+};
+var RateLimitError = class extends Error {
+  constructor(message, retryAfterMs) {
+    super(message);
+    this.retryAfterMs = retryAfterMs;
+    this.name = "RateLimitError";
+  }
+};
+
+// src/errors.ts
+var MorseSDKError = class _MorseSDKError extends Error {
+  constructor(message, code, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "MorseSDKError";
+    Object.setPrototypeOf(this, _MorseSDKError.prototype);
+  }
+};
+var SignalNotFoundError = class _SignalNotFoundError extends MorseSDKError {
+  constructor(message = "Signal not found") {
+    super(message, "SIGNAL_NOT_FOUND", 404);
+    this.name = "SignalNotFoundError";
+    Object.setPrototypeOf(this, _SignalNotFoundError.prototype);
+  }
+};
+var SignalExpiredError = class _SignalExpiredError extends MorseSDKError {
+  constructor(message = "Signal has expired") {
+    super(message, "SIGNAL_EXPIRED", 400);
+    this.name = "SignalExpiredError";
+    Object.setPrototypeOf(this, _SignalExpiredError.prototype);
+  }
+};
+var SignalAlreadyUsedError = class _SignalAlreadyUsedError extends MorseSDKError {
+  constructor(message = "Signal has already been used") {
+    super(message, "SIGNAL_ALREADY_USED", 400);
+    this.name = "SignalAlreadyUsedError";
+    Object.setPrototypeOf(this, _SignalAlreadyUsedError.prototype);
+  }
+};
+var WalletNotAllowedError = class _WalletNotAllowedError extends MorseSDKError {
+  constructor(message = "Wallet not allowed to access this signal") {
+    super(message, "WALLET_NOT_ALLOWED", 401);
+    this.name = "WalletNotAllowedError";
+    Object.setPrototypeOf(this, _WalletNotAllowedError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends MorseSDKError {
+  constructor(message = "Validation error") {
+    super(message, "VALIDATION_ERROR", 400);
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends MorseSDKError {
+  constructor(message = "Network error", originalError) {
+    super(message, "NETWORK_ERROR", 0);
+    this.originalError = originalError;
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+function mapErrorResponse(error) {
+  if (error.code) {
+    switch (error.code) {
+      case "SIGNAL_NOT_FOUND":
+        return new SignalNotFoundError(error.message);
+      case "SIGNAL_EXPIRED":
+        return new SignalExpiredError(error.message);
+      case "SIGNAL_ALREADY_USED":
+        return new SignalAlreadyUsedError(error.message);
+      case "WALLET_NOT_ALLOWED":
+        return new WalletNotAllowedError(error.message);
+      case "VALIDATION_ERROR":
+        return new ValidationError(error.message);
+      default:
+        return new MorseSDKError(error.message || "Unknown error", error.code);
+    }
+  }
+  return new MorseSDKError(error.message || "Unknown error");
+}
+
+// src/logger.ts
+var Logger = class {
+  constructor() {
+    this.level = "warn";
+    this.levels = {
+      none: 0,
+      error: 1,
+      warn: 2,
+      info: 3,
+      debug: 4
+    };
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  getLevel() {
+    return this.level;
+  }
+  shouldLog(level) {
+    return this.levels[level] <= this.levels[this.level];
+  }
+  error(message, ...args) {
+    if (this.shouldLog("error")) {
+      console.error(`[MorseSDK] ${message}`, ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.shouldLog("warn")) {
+      console.warn(`[MorseSDK] ${message}`, ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.shouldLog("info")) {
+      console.info(`[MorseSDK] ${message}`, ...args);
+    }
+  }
+  debug(message, ...args) {
+    if (this.shouldLog("debug")) {
+      console.debug(`[MorseSDK] ${message}`, ...args);
+    }
+  }
+};
+var logger = new Logger();
+
+// src/crypto.ts
+var CIPHER_VERSION = "aes-gcm-256-v1";
+function getCrypto() {
+  if (typeof globalThis !== "undefined" && globalThis.crypto) {
+    return globalThis.crypto;
+  }
+  if (typeof window !== "undefined" && window.crypto) {
+    return window.crypto;
+  }
+  throw new Error("Web Crypto API is not available. Requires Node.js 15+ or a browser with Web Crypto support.");
+}
+function toBase64(data) {
+  const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  if (typeof btoa !== "undefined") {
+    return btoa(String.fromCharCode(...bytes));
+  }
+  throw new Error("Base64 encoding not available. Requires Node.js Buffer or browser btoa.");
+}
+function fromBase64(base64) {
+  if (typeof Buffer !== "undefined") {
+    return Uint8Array.from(Buffer.from(base64, "base64"));
+  }
+  if (typeof atob !== "undefined") {
+    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+  }
+  throw new Error("Base64 decoding not available. Requires Node.js Buffer or browser atob.");
+}
+function getCipherVersion() {
+  return CIPHER_VERSION;
+}
+async function generateKey() {
+  const crypto = getCrypto();
+  if (!crypto.subtle) {
+    throw new Error("Web Crypto API (crypto.subtle) is not available.");
+  }
+  return crypto.subtle.generateKey(
+    {
+      name: "AES-GCM",
+      length: 256
+    },
+    true,
+    ["encrypt", "decrypt"]
+  );
+}
+async function exportKey(key) {
+  const crypto = getCrypto();
+  const exported = await crypto.subtle.exportKey("raw", key);
+  const keyArray = new Uint8Array(exported);
+  return toBase64(keyArray);
+}
+async function importKey(keyBase64) {
+  const crypto = getCrypto();
+  const keyArray = fromBase64(keyBase64);
+  const keyBuffer = keyArray.buffer.slice(keyArray.byteOffset, keyArray.byteOffset + keyArray.byteLength);
+  return crypto.subtle.importKey(
+    "raw",
+    keyBuffer,
+    {
+      name: "AES-GCM",
+      length: 256
+    },
+    true,
+    ["encrypt", "decrypt"]
+  );
+}
+function generateIV() {
+  const crypto = getCrypto();
+  return crypto.getRandomValues(new Uint8Array(12));
+}
+async function encryptText(text, key) {
+  const crypto = getCrypto();
+  const encoder = new TextEncoder();
+  const data = encoder.encode(text);
+  const iv = generateIV();
+  const ivArray = new Uint8Array(iv);
+  const encrypted = await crypto.subtle.encrypt(
+    {
+      name: "AES-GCM",
+      iv: ivArray
+    },
+    key,
+    data
+  );
+  return {
+    encrypted: toBase64(new Uint8Array(encrypted)),
+    iv: toBase64(iv)
+  };
+}
+async function decryptText(encryptedBase64, ivBase64, key) {
+  const crypto = getCrypto();
+  const encrypted = fromBase64(encryptedBase64);
+  const iv = fromBase64(ivBase64);
+  const ivBuffer = iv.buffer.slice(iv.byteOffset, iv.byteOffset + iv.byteLength);
+  const encryptedBuffer = encrypted.buffer.slice(encrypted.byteOffset, encrypted.byteOffset + encrypted.byteLength);
+  const decrypted = await crypto.subtle.decrypt(
+    {
+      name: "AES-GCM",
+      iv: ivBuffer
+    },
+    key,
+    encryptedBuffer
+  );
+  const decoder = new TextDecoder();
+  return decoder.decode(decrypted);
+}
+async function encryptFile(fileData, key) {
+  const crypto = getCrypto();
+  let data;
+  if (fileData instanceof Buffer) {
+    data = fileData.buffer.slice(fileData.byteOffset, fileData.byteOffset + fileData.byteLength);
+  } else if (fileData instanceof Uint8Array) {
+    data = fileData.buffer.slice(fileData.byteOffset, fileData.byteOffset + fileData.byteLength);
+  } else {
+    data = fileData;
+  }
+  const iv = generateIV();
+  const ivBuffer = iv.buffer.slice(iv.byteOffset, iv.byteOffset + iv.byteLength);
+  const encrypted = await crypto.subtle.encrypt(
+    {
+      name: "AES-GCM",
+      iv: ivBuffer
+    },
+    key,
+    data
+  );
+  return {
+    encrypted,
+    iv: toBase64(iv)
+  };
+}
+async function decryptFile(encryptedData, ivBase64, key) {
+  const crypto = getCrypto();
+  const iv = fromBase64(ivBase64);
+  if (iv.length !== 12) {
+    throw new Error(`Invalid IV length: ${iv.length} bytes. Expected 12 bytes for AES-GCM.`);
+  }
+  const ivBuffer = iv.buffer.slice(iv.byteOffset, iv.byteOffset + iv.byteLength);
+  const dataBuffer = encryptedData;
+  const decrypted = await crypto.subtle.decrypt(
+    {
+      name: "AES-GCM",
+      iv: ivBuffer
+    },
+    key,
+    dataBuffer
+  );
+  return decrypted;
+}
+function generateShareableLink(baseUrl, signalId, keyBase64) {
+  return `${baseUrl}/view/${signalId}#k=${encodeURIComponent(keyBase64)}`;
+}
+
+// src/implementations/v1/MorseSDKV1.ts
+init_crypto_x25519();
+
+// src/wallet-key-service.ts
+var WalletKeyService = class {
+  constructor(baseUrl, apiKey, apiVersion = "v1") {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.apiVersion = apiVersion;
+  }
+  getApiUrl(path) {
+    return `${this.baseUrl}/${this.apiVersion}${path}`;
+  }
+  async getPublicKey(walletAddress) {
+    const url = this.getApiUrl(`/wallet-key-registry/${walletAddress.toLowerCase()}`);
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.apiKey
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        return {
+          walletAddress: walletAddress.toLowerCase(),
+          certificate: null,
+          exists: false
+        };
+      }
+      throw new Error(`Failed to fetch public key: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      walletAddress: data.walletAddress,
+      certificate: data.certificate || null,
+      exists: !!data.certificate
+    };
+  }
+  async publishPublicKey(certificate) {
+    const url = this.getApiUrl("/wallet-key-registry");
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.apiKey
+      },
+      body: JSON.stringify({ certificate })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: "Unknown error" }));
+      throw new Error(`Failed to publish public key: ${error.message || response.statusText}`);
+    }
+  }
+};
+
+// src/utils.ts
+function isValidSignalId(signalId) {
+  if (!signalId || typeof signalId !== "string") {
+    return false;
+  }
+  if (signalId.length < 8 || signalId.length > 64) {
+    return false;
+  }
+  return /^[a-zA-Z0-9_-]+$/.test(signalId);
+}
+function isValidWalletAddress(address) {
+  if (!address || typeof address !== "string") {
+    return false;
+  }
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+function validateSignalId(signalId) {
+  if (!isValidSignalId(signalId)) {
+    throw new Error(`Invalid signal ID: ${signalId}. Must be 8-64 alphanumeric characters.`);
+  }
+}
+function validateWalletAddress(address) {
+  if (!isValidWalletAddress(address)) {
+    throw new Error(`Invalid wallet address: ${address}. Must be a valid Ethereum address.`);
+  }
+}
+function formatExpiration(expiresAt) {
+  const date = new Date(expiresAt);
+  return date.toLocaleString();
+}
+function isSignalExpired(expiresAt) {
+  return new Date(expiresAt) < /* @__PURE__ */ new Date();
+}
+function getTimeUntilExpiration(expiresAt) {
+  return Math.max(0, new Date(expiresAt).getTime() - Date.now());
+}
+function parseExpiresIn(expiresIn) {
+  const match = expiresIn.match(/^(\d+)([smhd])$/);
+  if (!match) {
+    throw new Error(`Invalid expiresIn format: ${expiresIn}. Use format like "24h", "7d", "30m"`);
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const multipliers = {
+    s: 1e3,
+    m: 60 * 1e3,
+    h: 60 * 60 * 1e3,
+    d: 24 * 60 * 60 * 1e3
+  };
+  return value * multipliers[unit];
+}
+function filterActiveSignals(signals) {
+  const now = /* @__PURE__ */ new Date();
+  return signals.filter(
+    (signal) => signal.status === "active" && new Date(signal.expiresAt) > now
+  );
+}
+function sortSignalsByDate(signals, order = "desc") {
+  return [...signals].sort((a, b) => {
+    const dateA = new Date(a.createdAt).getTime();
+    const dateB = new Date(b.createdAt).getTime();
+    return order === "desc" ? dateB - dateA : dateA - dateB;
+  });
+}
+function getSignalUrl(baseUrl, signalId, keyBase64) {
+  const url = `${baseUrl}/#/signal/${signalId}`;
+  if (keyBase64) {
+    return `${url}#k=${encodeURIComponent(keyBase64)}`;
+  }
+  return url;
+}
+function extractSignalIdFromUrl(url) {
+  const match = url.match(/\/signal\/([a-zA-Z0-9_-]+)/);
+  return match ? match[1] : null;
+}
+
+// src/implementations/v1/MorseSDKV1.ts
+var API_BASE_URL = "https://api.morseai.tech";
+var FRONTEND_BASE_URL = "https://morseai.tech";
+var MorseSDKV1 = class {
+  constructor(config) {
+    this.version = "v1";
+    this.rateLimiter = null;
+    if (!config.apiKey) {
+      throw new Error("apiKey is required. Please provide an API key in the SDK configuration.");
+    }
+    if (!config.apiKey.startsWith("sk_")) {
+      throw new Error("Invalid API key format. API key must start with 'sk_'");
+    }
+    this.config = config;
+    this.timeout = config.timeout || 3e4;
+    this.retries = config.retries || 0;
+    this.retryDelay = config.retryDelay || 1e3;
+    if (config.rateLimit?.enabled !== false) {
+      const maxRequests = config.rateLimit?.maxRequests || 100;
+      const windowMs = config.rateLimit?.windowMs || 6e4;
+      this.rateLimiter = new RateLimiter({ maxRequests, windowMs });
+    }
+    logger.debug("MorseSDKV1 initialized", {
+      apiVersion: config.apiVersion || "v1",
+      timeout: this.timeout,
+      retries: this.retries,
+      rateLimitEnabled: this.rateLimiter !== null,
+      hasApiKey: !!config.apiKey
+    });
+  }
+  base64ToUint8Array(base64) {
+    if (typeof Buffer !== "undefined") {
+      return Uint8Array.from(Buffer.from(base64, "base64"));
+    }
+    if (typeof atob !== "undefined") {
+      return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+    }
+    throw new Error("Base64 decoding not available. Requires Node.js Buffer or browser atob.");
+  }
+  arrayBufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer);
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(bytes).toString("base64");
+    }
+    if (typeof btoa !== "undefined") {
+      return btoa(String.fromCharCode(...bytes));
+    }
+    throw new Error("Base64 encoding not available. Requires Node.js Buffer or browser btoa.");
+  }
+  sanitizeRequestOptions(options) {
+    const sanitized = { ...options };
+    if (sanitized.body) {
+      try {
+        const body = JSON.parse(sanitized.body);
+        const sanitizedBody = {};
+        if (body.wallet) {
+          sanitizedBody.wallet = {
+            address: body.wallet.address,
+            signature: "[REDACTED]",
+            message: body.wallet.message
+          };
+        }
+        if (body.encryptedText) {
+          sanitizedBody.encryptedText = "[REDACTED]";
+        }
+        if (body.payloadNonce) {
+          sanitizedBody.payloadNonce = "[REDACTED]";
+        }
+        if (body.sealedDataKey) {
+          sanitizedBody.sealedDataKey = "[REDACTED]";
+        }
+        if (body.file) {
+          sanitizedBody.file = {
+            ...body.file,
+            payloadNonce: body.file.payloadNonce ? "[REDACTED]" : null,
+            sealedDataKey: body.file.sealedDataKey ? "[REDACTED]" : null
+          };
+        }
+        if (body.signalId) {
+          sanitizedBody.signalId = body.signalId;
+        }
+        sanitized.body = JSON.stringify(sanitizedBody);
+      } catch {
+        sanitized.body = "[REDACTED - non-JSON body]";
+      }
+    }
+    return sanitized;
+  }
+  getApiUrl(path) {
+    const version = this.config.apiVersion || "v1";
+    return `${API_BASE_URL}/${version}${path}`;
+  }
+  async createAuthMessage(action, context = "") {
+    const timestamp = Date.now();
+    if (context) {
+      return `MORSE: ${action} ${context} at ${timestamp}`;
+    }
+    return `MORSE: ${action} at ${timestamp}`;
+  }
+  async signMessage(wallet, message) {
+    return await wallet.signMessage(message);
+  }
+  async makeRequest(url, options = {}) {
+    if (this.rateLimiter) {
+      try {
+        await this.rateLimiter.checkLimit();
+      } catch (error) {
+        if (error instanceof RateLimitError) {
+          logger.warn("Rate limit exceeded", {
+            url,
+            retryAfterMs: error.retryAfterMs
+          });
+          if (this.config.onError) {
+            this.config.onError(error);
+          }
+          throw error;
+        }
+        throw error;
+      }
+    }
+    logger.debug("Making request", {
+      url,
+      method: options.method || "GET",
+      hasBody: !!options.body
+    });
+    const requestOptions = {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.config.apiKey,
+        ...options.headers
+      }
+    };
+    if (this.config.onRequest) {
+      const sanitizedOptions = this.sanitizeRequestOptions(requestOptions);
+      this.config.onRequest(url, sanitizedOptions);
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(url, {
+          ...requestOptions,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (this.config.onResponse) {
+          this.config.onResponse(url, response);
+        }
+        if (!response.ok) {
+          const error = await response.json().catch(() => ({
+            status: "error",
+            code: "VALIDATION_ERROR",
+            message: `HTTP ${response.status}: ${response.statusText}`
+          }));
+          logger.error("Request failed", {
+            status: response.status,
+            code: error.code,
+            message: error.message,
+            attempt: attempt + 1
+          });
+          const mappedError = mapErrorResponse(error);
+          if (this.config.onError) {
+            this.config.onError(mappedError);
+          }
+          throw mappedError;
+        }
+        const data = await response.json();
+        logger.debug("Request successful", { url, attempt: attempt + 1 });
+        return data;
+      } catch (error) {
+        lastError = error;
+        if (error.name === "AbortError") {
+          const timeoutError = new NetworkError(`Request timeout after ${this.timeout}ms`, error);
+          if (this.config.onError) {
+            this.config.onError(timeoutError);
+          }
+          throw timeoutError;
+        }
+        if (error instanceof NetworkError || error.name?.includes("Error")) {
+          if (attempt < this.retries) {
+            logger.warn(`Request failed, retrying... (${attempt + 1}/${this.retries})`, { url });
+            await new Promise((resolve) => setTimeout(resolve, this.retryDelay * (attempt + 1)));
+            continue;
+          }
+          if (this.config.onError) {
+            this.config.onError(error);
+          }
+          throw error;
+        }
+        if (error.message?.includes("fetch") || error.message?.includes("network")) {
+          if (attempt < this.retries) {
+            logger.warn(`Network error, retrying... (${attempt + 1}/${this.retries})`, { url });
+            await new Promise((resolve) => setTimeout(resolve, this.retryDelay * (attempt + 1)));
+            continue;
+          }
+          const networkError = new NetworkError("Network request failed", error);
+          if (this.config.onError) {
+            this.config.onError(networkError);
+          }
+          throw networkError;
+        }
+        if (this.config.onError) {
+          this.config.onError(error);
+        }
+        throw error;
+      }
+    }
+    if (lastError) {
+      if (this.config.onError) {
+        this.config.onError(lastError);
+      }
+      throw lastError;
+    }
+    throw new NetworkError("Request failed after all retries");
+  }
+  async createSignal(wallet, options) {
+    validateWalletAddress(wallet.address);
+    if (options.walletTarget) {
+      validateWalletAddress(options.walletTarget);
+    }
+    if (options.shareWithRecipient && !options.walletTarget) {
+      throw new Error("walletTarget is required when shareWithRecipient is true");
+    }
+    if (!options.hasFile && !options.hasMessage) {
+      throw new Error("Either hasFile or hasMessage must be true");
+    }
+    logger.info("Creating signal", {
+      hasFile: options.hasFile,
+      hasMessage: options.hasMessage,
+      mode: options.mode
+    });
+    const tempSignalId = "temp-" + Date.now();
+    const authMessage = await this.createAuthMessage("create", `signal ${tempSignalId}`);
+    const signature = await this.signMessage(wallet, authMessage);
+    const requestBody = {
+      ...options,
+      wallet: {
+        address: wallet.address,
+        signature,
+        message: authMessage
+      }
+    };
+    const result = await this.makeRequest(
+      this.getApiUrl("/signals"),
+      {
+        method: "POST",
+        body: JSON.stringify(requestBody)
+      }
+    );
+    logger.info("Signal created", { signalId: result.signalId });
+    return result;
+  }
+  async openSignal(wallet, signalId) {
+    validateSignalId(signalId);
+    validateWalletAddress(wallet.address);
+    logger.info("Opening signal", { signalId });
+    const authMessage = await this.createAuthMessage("open", `signal ${signalId}`);
+    const signature = await this.signMessage(wallet, authMessage);
+    const requestBody = {
+      signalId,
+      wallet: {
+        address: wallet.address,
+        signature,
+        message: authMessage
+      }
+    };
+    const result = await this.makeRequest(
+      this.getApiUrl("/signals/open"),
+      {
+        method: "POST",
+        body: JSON.stringify(requestBody)
+      }
+    );
+    logger.info("Signal opened", { signalId, hasFile: !!result.file });
+    return result;
+  }
+  async openSignalDecrypted(wallet, signalId, keyBase64) {
+    validateSignalId(signalId);
+    validateWalletAddress(wallet.address);
+    const encryptedResponse = await this.openSignal(wallet, signalId);
+    const isX25519Signal = Boolean(
+      encryptedResponse.sealedDataKey && encryptedResponse.sealedNonce && encryptedResponse.senderEphemeralPublicKey
+    );
+    let message = null;
+    let fileData = null;
+    let keySource = "derived";
+    if (isX25519Signal) {
+      const { openSharedSignal: openSharedSignal2 } = await Promise.resolve().then(() => (init_crypto_x25519(), crypto_x25519_exports));
+      const walletTarget = encryptedResponse.walletTarget || wallet.address;
+      const walletCreator = encryptedResponse.walletCreator || wallet.address;
+      const expiresAtMs = new Date(encryptedResponse.expiresAt).getTime();
+      const keyService = new WalletKeyService(API_BASE_URL, this.config.apiKey, this.config.apiVersion || "v1");
+      const certResponse = await keyService.getPublicKey(wallet.address);
+      const domain = certResponse.certificate?.domain || "morseai.tech";
+      const chainId = certResponse.certificate?.chainId || 1;
+      if (encryptedResponse.encryptedText && encryptedResponse.payloadNonce) {
+        const decryptedBytes = await openSharedSignal2(
+          encryptedResponse.encryptedText,
+          encryptedResponse.payloadNonce,
+          encryptedResponse.sealedDataKey,
+          encryptedResponse.sealedNonce,
+          encryptedResponse.senderEphemeralPublicKey,
+          signalId,
+          walletTarget,
+          walletCreator,
+          expiresAtMs,
+          encryptedResponse.aadHash || "",
+          wallet.address,
+          domain,
+          chainId,
+          wallet.signMessage
+        );
+        message = new TextDecoder().decode(decryptedBytes);
+      }
+      if (encryptedResponse.file) {
+        const fileResponse = await this.downloadFile(wallet, signalId);
+        const encryptedFileBase64 = fileResponse.file;
+        const fileSealedDataKey = encryptedResponse.file.sealedDataKey || encryptedResponse.sealedDataKey;
+        const fileSealedNonce = encryptedResponse.file.sealedNonce || encryptedResponse.sealedNonce;
+        const fileSenderEphemeralPublicKey = encryptedResponse.file.senderEphemeralPublicKey || encryptedResponse.senderEphemeralPublicKey;
+        const fileAadHash = encryptedResponse.file.aadHash || encryptedResponse.aadHash || "";
+        if (fileSealedDataKey && fileSealedNonce && fileSenderEphemeralPublicKey && encryptedResponse.file.payloadNonce) {
+          const decryptedFileBytes = await openSharedSignal2(
+            encryptedFileBase64,
+            encryptedResponse.file.payloadNonce,
+            fileSealedDataKey,
+            fileSealedNonce,
+            fileSenderEphemeralPublicKey,
+            `${signalId}-file`,
+            // Use hyphen like frontend
+            walletTarget.toLowerCase(),
+            walletCreator.toLowerCase(),
+            expiresAtMs,
+            fileAadHash,
+            wallet.address,
+            domain,
+            chainId,
+            wallet.signMessage
+          );
+          fileData = decryptedFileBytes.buffer.slice(
+            decryptedFileBytes.byteOffset,
+            decryptedFileBytes.byteOffset + decryptedFileBytes.byteLength
+          );
+        } else {
+          throw new Error("File encryption format not supported for this signal type");
+        }
+      }
+      keySource = "derived";
+    } else {
+      if (!keyBase64 || typeof keyBase64 !== "string" || keyBase64.length < 32) {
+        throw new Error("This signal requires an encryption key. Please provide the key from the URL fragment (#k=...).");
+      }
+      const key = await importKey(keyBase64);
+      if (encryptedResponse.encryptedText && encryptedResponse.payloadNonce) {
+        message = await decryptText(encryptedResponse.encryptedText, encryptedResponse.payloadNonce, key);
+      }
+      if (encryptedResponse.file) {
+        const fileResponse = await this.downloadFile(wallet, signalId);
+        const encryptedFileData = this.base64ToUint8Array(fileResponse.file);
+        const buffer = encryptedFileData.buffer.slice(
+          encryptedFileData.byteOffset,
+          encryptedFileData.byteOffset + encryptedFileData.byteLength
+        );
+        fileData = await decryptFile(buffer, encryptedResponse.file.payloadNonce, key);
+      }
+      keySource = "provided";
+    }
+    return {
+      message,
+      file: encryptedResponse.file && fileData ? {
+        data: fileData,
+        originalName: encryptedResponse.file.originalName,
+        mimeType: encryptedResponse.file.mimeType,
+        sizeBytes: encryptedResponse.file.sizeBytes
+      } : null,
+      expiresAt: encryptedResponse.expiresAt,
+      onChainNotification: encryptedResponse.onChainNotification,
+      keySource
+    };
+  }
+  async listMySignals(wallet) {
+    const authMessage = await this.createAuthMessage("view", "vault");
+    const signature = await this.signMessage(wallet, authMessage);
+    const params = new URLSearchParams({
+      walletAddress: wallet.address,
+      walletSignature: signature,
+      walletMessage: authMessage
+    });
+    return this.makeRequest(
+      `${this.getApiUrl("/signals/my-signals")}?${params.toString()}`,
+      {
+        method: "GET"
+      }
+    );
+  }
+  async uploadFile(wallet, options) {
+    const authMessage = await this.createAuthMessage("upload", "file");
+    const signature = await this.signMessage(wallet, authMessage);
+    const requestBody = {
+      ...options,
+      wallet: {
+        address: wallet.address,
+        signature,
+        message: authMessage
+      }
+    };
+    return this.makeRequest(
+      this.getApiUrl("/files/upload"),
+      {
+        method: "POST",
+        body: JSON.stringify(requestBody)
+      }
+    );
+  }
+  async downloadFile(wallet, signalId) {
+    const authMessage = await this.createAuthMessage("download", `file ${signalId}`);
+    const signature = await this.signMessage(wallet, authMessage);
+    const requestBody = {
+      signalId,
+      wallet: {
+        address: wallet.address,
+        signature,
+        message: authMessage
+      }
+    };
+    return this.makeRequest(
+      this.getApiUrl("/files/download"),
+      {
+        method: "POST",
+        body: JSON.stringify(requestBody)
+      }
+    );
+  }
+  async downloadFileDecrypted(wallet, signalId, keyBase64) {
+    const encryptedResponse = await this.openSignal(wallet, signalId);
+    if (!encryptedResponse.file) {
+      throw new Error("Signal does not have a file");
+    }
+    const fileResponse = await this.downloadFile(wallet, signalId);
+    const key = await importKey(keyBase64);
+    const encryptedFileData = this.base64ToUint8Array(fileResponse.file);
+    const buffer = encryptedFileData.buffer.slice(
+      encryptedFileData.byteOffset,
+      encryptedFileData.byteOffset + encryptedFileData.byteLength
+    );
+    const decryptedData = await decryptFile(buffer, encryptedResponse.file.payloadNonce, key);
+    return {
+      data: decryptedData,
+      originalName: fileResponse.originalName,
+      mimeType: fileResponse.mimeType,
+      sizeBytes: fileResponse.sizeBytes
+    };
+  }
+  async createSignalEncrypted(wallet, options) {
+    validateWalletAddress(wallet.address);
+    const shareWithRecipient = options.mode === "shared_wallet";
+    if (options.mode === "shared_wallet" && !options.walletTarget) {
+      throw new Error("walletTarget is required when mode is 'shared_wallet'");
+    }
+    if (options.walletTarget) {
+      validateWalletAddress(options.walletTarget);
+    }
+    if (!options.message && !options.file) {
+      throw new Error("Either message or file must be provided");
+    }
+    if (!options.expiresIn && !options.expiresAt) {
+      throw new Error(
+        "Either expiresIn or expiresAt must be provided.\n  - expiresIn: relative time (e.g., '24h', '7d', '1h')\n  - expiresAt: specific date (ISO 8601, e.g., '2026-12-31T23:59:59.000Z')"
+      );
+    }
+    if (options.expiresIn && options.expiresAt) {
+      throw new Error("Cannot provide both expiresIn and expiresAt. Use only one.");
+    }
+    const mergedOptions = {
+      ...options,
+      shareWithRecipient
+    };
+    if (shareWithRecipient && options.walletTarget) {
+      return this.createSharedSignalEncrypted(wallet, mergedOptions);
+    }
+    return this.createPrivateSignalEncrypted(wallet, mergedOptions);
+  }
+  async createPrivateSignalEncrypted(wallet, options) {
+    const key = await generateKey();
+    const keyBase64 = await exportKey(key);
+    let encryptedText;
+    let payloadNonce;
+    let fileOptions;
+    if (options.message) {
+      const encrypted = await encryptText(options.message, key);
+      encryptedText = encrypted.encrypted;
+      payloadNonce = encrypted.iv;
+    }
+    if (options.file) {
+      const uploadResult = await this.uploadFileEncrypted(
+        wallet,
+        options.file.data,
+        options.file.originalName,
+        options.file.mimeType,
+        key
+      );
+      const encrypted = await encryptFile(options.file.data, key);
+      fileOptions = {
+        storagePath: uploadResult.storagePath,
+        payloadNonce: encrypted.iv,
+        originalName: options.file.originalName,
+        mimeType: options.file.mimeType,
+        sizeBytes: uploadResult.sizeBytes
+      };
+    }
+    const signalOptions = {
+      walletTarget: options.walletTarget,
+      shareWithRecipient: options.shareWithRecipient,
+      mode: options.mode,
+      hasFile: !!options.file,
+      hasMessage: !!options.message,
+      cipherVersion: getCipherVersion(),
+      encryptedText,
+      payloadNonce,
+      file: fileOptions,
+      onChainNotification: options.onChainNotification,
+      expiresAt: options.expiresAt,
+      expiresIn: options.expiresIn
+    };
+    const result = await this.createSignal(wallet, signalOptions);
+    const shareableLink = generateShareableLink(FRONTEND_BASE_URL, result.signalId, keyBase64);
+    return {
+      ...result,
+      keyBase64,
+      shareableLink
+    };
+  }
+  async createSharedSignalEncrypted(wallet, options) {
+    const walletTarget = options.walletTarget;
+    const walletCreator = wallet.address;
+    const signalId = options.signalId || generateSignalId();
+    let expiresAtMs;
+    if (options.expiresAt) {
+      expiresAtMs = new Date(options.expiresAt).getTime();
+    } else if (options.expiresIn) {
+      const match = options.expiresIn.match(/^(\d+)([smhd])$/);
+      if (!match) throw new Error("Invalid expiresIn format");
+      const value = parseInt(match[1], 10);
+      const unit = match[2];
+      const multipliers = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+      expiresAtMs = Date.now() + value * multipliers[unit];
+    } else {
+      expiresAtMs = Date.now() + 24 * 60 * 60 * 1e3;
+    }
+    const keyService = new WalletKeyService(API_BASE_URL, this.config.apiKey, this.config.apiVersion || "v1");
+    const recipientKeyResponse = await keyService.getPublicKey(walletTarget);
+    if (!recipientKeyResponse.exists || !recipientKeyResponse.certificate) {
+      throw new Error(
+        `Public key not found for recipient ${walletTarget}. The recipient needs to publish their public key first. They can do this by opening any shared signal sent to them, or visiting the app.`
+      );
+    }
+    if (!verifyKeyCertificate(recipientKeyResponse.certificate)) {
+      throw new Error("Recipient's key certificate signature verification failed");
+    }
+    if (Date.now() > recipientKeyResponse.certificate.expiresAt) {
+      throw new Error("Recipient's key certificate has expired");
+    }
+    const recipientPubKey = Buffer.from(recipientKeyResponse.certificate.x25519PublicKey, "base64");
+    let payloadText = "";
+    if (options.message) {
+      payloadText = options.message;
+    }
+    const payloadBytes = new TextEncoder().encode(payloadText);
+    const sealedResult = await createSharedSignal(
+      payloadBytes,
+      new Uint8Array(recipientPubKey),
+      walletTarget,
+      walletCreator,
+      expiresAtMs,
+      signalId
+    );
+    let fileOptions;
+    if (options.file) {
+      const fileBytes = options.file.data instanceof ArrayBuffer ? new Uint8Array(options.file.data) : new Uint8Array(options.file.data);
+      const fileSealedResult = await createSharedSignal(
+        fileBytes,
+        new Uint8Array(recipientPubKey),
+        walletTarget,
+        walletCreator,
+        expiresAtMs,
+        signalId + "_file"
+      );
+      const uploadResult = await this.uploadFile(wallet, {
+        file: fileSealedResult.encryptedPayload,
+        originalName: options.file.originalName,
+        mimeType: options.file.mimeType
+      });
+      fileOptions = {
+        storagePath: uploadResult.storagePath,
+        payloadNonce: fileSealedResult.payloadNonce,
+        originalName: options.file.originalName,
+        mimeType: options.file.mimeType,
+        sizeBytes: uploadResult.sizeBytes,
+        sealedDataKey: fileSealedResult.sealedDataKey,
+        sealedNonce: fileSealedResult.sealedNonce,
+        senderEphemeralPublicKey: fileSealedResult.senderEphemeralPublicKey,
+        aadHash: fileSealedResult.aadHash
+      };
+    }
+    const signalOptions = {
+      signalId,
+      walletTarget,
+      shareWithRecipient: true,
+      mode: "shared_wallet",
+      hasFile: !!options.file,
+      hasMessage: !!options.message,
+      cipherVersion: sealedResult.cipherVersion,
+      encryptedText: options.message ? sealedResult.encryptedPayload : void 0,
+      payloadNonce: options.message ? sealedResult.payloadNonce : void 0,
+      sealedDataKey: sealedResult.sealedDataKey,
+      sealedNonce: sealedResult.sealedNonce,
+      senderEphemeralPublicKey: sealedResult.senderEphemeralPublicKey,
+      aadHash: sealedResult.aadHash,
+      file: fileOptions,
+      onChainNotification: options.onChainNotification,
+      expiresAt: new Date(expiresAtMs).toISOString()
+    };
+    const result = await this.createSignal(wallet, signalOptions);
+    const shareableLink = `${FRONTEND_BASE_URL}/view/${result.signalId}`;
+    return {
+      ...result,
+      keyBase64: "",
+      // No key needed for X25519 signals
+      shareableLink
+    };
+  }
+  async uploadFileEncrypted(wallet, fileData, originalName, mimeType, key) {
+    const encrypted = await encryptFile(fileData, key);
+    const encryptedBase64 = this.arrayBufferToBase64(encrypted.encrypted);
+    return this.uploadFile(wallet, {
+      file: encryptedBase64,
+      originalName,
+      mimeType
+    });
+  }
+  async burnSignal(wallet, signalId) {
+    validateSignalId(signalId);
+    validateWalletAddress(wallet.address);
+    logger.info("Burning signal", { signalId });
+    const authMessage = await this.createAuthMessage("burn", `signal ${signalId}`);
+    const signature = await this.signMessage(wallet, authMessage);
+    const requestBody = {
+      signalId,
+      wallet: {
+        address: wallet.address,
+        signature,
+        message: authMessage
+      }
+    };
+    const result = await this.makeRequest(
+      this.getApiUrl("/signals/burn"),
+      {
+        method: "POST",
+        body: JSON.stringify(requestBody)
+      }
+    );
+    logger.info("Signal burned successfully", { signalId });
+    return result;
+  }
+};
+
+// src/morse-sdk.ts
+var MorseSDK = class {
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("apiKey is required. Please provide an API key in the SDK configuration.");
+    }
+    this.config = config;
+    this.apiVersion = config.apiVersion || "v1";
+    switch (this.apiVersion) {
+      case "v1":
+        this.contract = new MorseSDKV1(config);
+        break;
+      default:
+        logger.warn(`Unknown API version: ${this.apiVersion}, defaulting to v1`);
+        this.contract = new MorseSDKV1(config);
+        this.apiVersion = "v1";
+    }
+    logger.debug("MorseSDK initialized", {
+      apiVersion: this.apiVersion,
+      contractVersion: this.contract.version
+    });
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  getApiVersion() {
+    return this.apiVersion;
+  }
+  getContract() {
+    return this.contract;
+  }
+  async createSignal(wallet, options) {
+    return this.contract.createSignal(wallet, options);
+  }
+  async openSignal(wallet, signalId) {
+    return this.contract.openSignal(wallet, signalId);
+  }
+  async listMySignals(wallet) {
+    return this.contract.listMySignals(wallet);
+  }
+  async uploadFile(wallet, options) {
+    return this.contract.uploadFile(wallet, options);
+  }
+  async downloadFile(wallet, signalId) {
+    return this.contract.downloadFile(wallet, signalId);
+  }
+  async burnSignal(wallet, signalId) {
+    return this.contract.burnSignal(wallet, signalId);
+  }
+  async createSignalEncrypted(wallet, options) {
+    const v1Contract = this.contract;
+    if (v1Contract.createSignalEncrypted) {
+      return v1Contract.createSignalEncrypted(wallet, options);
+    }
+    throw new Error("createSignalEncrypted is not available in this API version");
+  }
+  async openSignalDecrypted(wallet, signalId, keyBase64) {
+    const v1Contract = this.contract;
+    if (v1Contract.openSignalDecrypted) {
+      return v1Contract.openSignalDecrypted(wallet, signalId, keyBase64);
+    }
+    throw new Error("openSignalDecrypted is not available in this API version");
+  }
+  async uploadFileEncrypted(wallet, fileData, originalName, mimeType, key) {
+    const v1Contract = this.contract;
+    if (v1Contract.uploadFileEncrypted) {
+      return v1Contract.uploadFileEncrypted(wallet, fileData, originalName, mimeType, key);
+    }
+    throw new Error("uploadFileEncrypted is not available in this API version");
+  }
+  async downloadFileDecrypted(wallet, signalId, keyBase64) {
+    const v1Contract = this.contract;
+    if (v1Contract.downloadFileDecrypted) {
+      return v1Contract.downloadFileDecrypted(wallet, signalId, keyBase64);
+    }
+    throw new Error("downloadFileDecrypted is not available in this API version");
+  }
+};
+
+// src/helpers.ts
+function createWalletFromPrivateKey(config) {
+  let ethersModule;
+  try {
+    ethersModule = __require("ethers");
+  } catch {
+    try {
+      throw new Error("ethers must be installed");
+    } catch (error) {
+      throw new Error(
+        "ethers is required for private key wallets. Install it: npm install ethers"
+      );
+    }
+  }
+  const { Wallet } = ethersModule;
+  const tempWallet = new Wallet(config.privateKey);
+  const address = tempWallet.address;
+  const privateKey = config.privateKey;
+  return {
+    address,
+    signMessage: async (message) => {
+      const wallet = new Wallet(privateKey);
+      const signature = await wallet.signMessage(message);
+      return signature;
+    }
+  };
+}
+function createWalletFromPreSigned(config) {
+  return {
+    address: config.address,
+    signMessage: async (message) => {
+      if (message === config.message) {
+        return config.signature;
+      }
+      throw new Error(
+        "Pre-signed wallet can only sign the original message. Expected: " + config.message + ", Got: " + message
+      );
+    }
+  };
+}
+async function createBrowserWallet(ethereum, address) {
+  let currentAddress = address || "";
+  if (!currentAddress) {
+    const accounts = await ethereum.request({ method: "eth_accounts" });
+    if (accounts.length === 0) {
+      throw new Error("No wallet connected. Please connect your wallet first.");
+    }
+    currentAddress = accounts[0];
+  }
+  return {
+    address: currentAddress,
+    signMessage: async (message) => {
+      try {
+        const signature = await ethereum.request({
+          method: "personal_sign",
+          params: [message, currentAddress]
+        });
+        return signature;
+      } catch (error) {
+        if (error.code === 4001) {
+          throw new Error("User rejected the signing request");
+        }
+        throw error;
+      }
+    }
+  };
+}
+
+// src/index.ts
+init_crypto_x25519();
+
+// src/expiration.ts
+var Expiration = {
+  /** 5 seconds */
+  FIVE_SECONDS: "5s",
+  /** 30 seconds */
+  THIRTY_SECONDS: "30s",
+  /** 1 minute */
+  ONE_MINUTE: "1m",
+  /** 5 minutes */
+  FIVE_MINUTES: "5m",
+  /** 30 minutes */
+  THIRTY_MINUTES: "30m",
+  /** 1 hour */
+  ONE_HOUR: "1h",
+  /** 6 hours */
+  SIX_HOURS: "6h",
+  /** 12 hours */
+  TWELVE_HOURS: "12h",
+  /** 24 hours (1 day) */
+  ONE_DAY: "24h",
+  /** 7 days (1 week) */
+  ONE_WEEK: "7d",
+  /** 30 days (1 month) */
+  ONE_MONTH: "30d"
+};
+
+export { Expiration, MorseSDK, MorseSDKError, MorseSDKV1, NetworkError, RateLimitError, SignalAlreadyUsedError, SignalExpiredError, SignalNotFoundError, ValidationError, WalletKeyService, WalletNotAllowedError, X25519_CIPHER_VERSION, createBrowserWallet, createKeyCertificate, createSharedSignal, createWalletFromPreSigned, createWalletFromPrivateKey, deriveKeyPairFromWalletSignature, extractSignalIdFromUrl, filterActiveSignals, formatExpiration, generateShareableLink, generateSignalId, getCipherVersion, getSignalUrl, getTimeUntilExpiration, isSignalExpired, isValidSignalId, isValidWalletAddress, logger, openSharedSignal, parseExpiresIn, sortSignalsByDate, validateSignalId, validateWalletAddress, verifyKeyCertificate };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map