@cantonconnect/core 0.2.0

package/dist/index.js

@@ -0,0 +1,786 @@
+'use strict';
+
+// src/types.ts
+function toWalletId(id) {
+  return id;
+}
+function toPartyId(id) {
+  return id;
+}
+function toSessionId(id) {
+  return id;
+}
+function toTransactionHash(hash) {
+  return hash;
+}
+function toSignature(sig) {
+  return sig;
+}
+
+// src/errors.ts
+var CantonConnectError = class _CantonConnectError extends Error {
+  code;
+  cause;
+  details;
+  isOperational;
+  constructor(message, code, options) {
+    super(message);
+    this.name = "CantonConnectError";
+    this.code = code;
+    this.cause = options?.cause;
+    this.details = options?.details;
+    this.isOperational = options?.isOperational ?? true;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _CantonConnectError);
+    }
+  }
+  /**
+   * Serialize error to JSON for telemetry/logging
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      isOperational: this.isOperational,
+      details: this.details,
+      cause: this.cause instanceof Error ? {
+        name: this.cause.name,
+        message: this.cause.message,
+        stack: this.cause.stack
+      } : this.cause
+    };
+  }
+};
+var WalletNotFoundError = class extends CantonConnectError {
+  constructor(walletId) {
+    super(`Wallet "${walletId}" not found`, "WALLET_NOT_FOUND", {
+      details: { walletId }
+    });
+    this.name = "WalletNotFoundError";
+  }
+};
+var WalletNotInstalledError = class extends CantonConnectError {
+  constructor(walletId, reason) {
+    super(
+      `Wallet "${walletId}" is not installed${reason ? `: ${reason}` : ""}`,
+      "WALLET_NOT_INSTALLED",
+      {
+        details: { walletId, reason }
+      }
+    );
+    this.name = "WalletNotInstalledError";
+  }
+};
+var UserRejectedError = class extends CantonConnectError {
+  constructor(operation, details) {
+    super(`User rejected ${operation}`, "USER_REJECTED", {
+      details: { operation, ...details }
+    });
+    this.name = "UserRejectedError";
+  }
+};
+var OriginNotAllowedError = class extends CantonConnectError {
+  constructor(origin, allowedOrigins) {
+    super(
+      `Origin "${origin}" is not allowed`,
+      "ORIGIN_NOT_ALLOWED",
+      {
+        details: { origin, allowedOrigins }
+      }
+    );
+    this.name = "OriginNotAllowedError";
+  }
+};
+var SessionExpiredError = class extends CantonConnectError {
+  constructor(sessionId) {
+    super(`Session "${sessionId}" has expired`, "SESSION_EXPIRED", {
+      details: { sessionId }
+    });
+    this.name = "SessionExpiredError";
+  }
+};
+var CapabilityNotSupportedError = class extends CantonConnectError {
+  constructor(walletId, capability) {
+    super(
+      `Wallet "${walletId}" does not support capability "${capability}"`,
+      "CAPABILITY_NOT_SUPPORTED",
+      {
+        details: { walletId, capability }
+      }
+    );
+    this.name = "CapabilityNotSupportedError";
+  }
+};
+var TransportError = class extends CantonConnectError {
+  constructor(message, cause, details) {
+    super(message, "TRANSPORT_ERROR", {
+      cause,
+      details
+    });
+    this.name = "TransportError";
+  }
+};
+var RegistryFetchFailedError = class extends CantonConnectError {
+  constructor(url, cause) {
+    super(`Failed to fetch registry from "${url}"`, "REGISTRY_FETCH_FAILED", {
+      cause,
+      details: { url }
+    });
+    this.name = "RegistryFetchFailedError";
+  }
+};
+var RegistryVerificationFailedError = class extends CantonConnectError {
+  constructor(reason, details) {
+    super(`Registry verification failed: ${reason}`, "REGISTRY_VERIFICATION_FAILED", {
+      details: { reason, ...details }
+    });
+    this.name = "RegistryVerificationFailedError";
+  }
+};
+var RegistrySchemaInvalidError = class extends CantonConnectError {
+  constructor(reason, details) {
+    super(`Registry schema invalid: ${reason}`, "REGISTRY_SCHEMA_INVALID", {
+      details: { reason, ...details }
+    });
+    this.name = "RegistrySchemaInvalidError";
+  }
+};
+var InternalError = class extends CantonConnectError {
+  constructor(message, cause, details) {
+    super(message, "INTERNAL_ERROR", {
+      cause,
+      details,
+      isOperational: false
+    });
+    this.name = "InternalError";
+  }
+};
+var TimeoutError = class extends CantonConnectError {
+  constructor(operation, timeoutMs) {
+    super(
+      `Operation "${operation}" timed out after ${timeoutMs}ms`,
+      "TIMEOUT",
+      {
+        details: { operation, timeoutMs }
+      }
+    );
+    this.name = "TimeoutError";
+  }
+};
+function mapUnknownErrorToCantonConnectError(err, context) {
+  if (err instanceof CantonConnectError) {
+    return err;
+  }
+  if (err instanceof Error) {
+    const message = err.message.toLowerCase();
+    if (message.includes("rejected") || message.includes("denied") || message.includes("cancelled") || message.includes("canceled") || err.name === "UserRejectedError") {
+      return new UserRejectedError(context.phase, {
+        walletId: context.walletId,
+        transport: context.transport,
+        originalMessage: err.message
+      });
+    }
+    if (message.includes("timeout") || message.includes("timed out") || err.name === "TimeoutError") {
+      let timeoutMs = context.timeoutMs ?? 0;
+      if (timeoutMs === 0) {
+        const msMatch = err.message.match(/(\d+)\s*ms/i);
+        const secMatch = err.message.match(/(\d+)\s*(?:sec|second)/i);
+        if (msMatch) {
+          timeoutMs = parseInt(msMatch[1], 10);
+        } else if (secMatch) {
+          timeoutMs = parseInt(secMatch[1], 10) * 1e3;
+        }
+      }
+      return new TimeoutError(context.phase, timeoutMs);
+    }
+    if (message.includes("network") || message.includes("fetch") || message.includes("connection") || err.name === "NetworkError" || err.name === "TypeError") {
+      return new TransportError(err.message, err, {
+        walletId: context.walletId,
+        phase: context.phase,
+        transport: context.transport
+      });
+    }
+    return new TransportError(err.message, err, {
+      walletId: context.walletId,
+      phase: context.phase,
+      transport: context.transport,
+      originalError: err.name
+    });
+  }
+  if (typeof err === "string") {
+    return new TransportError(err, void 0, {
+      walletId: context.walletId,
+      phase: context.phase,
+      transport: context.transport
+    });
+  }
+  return new InternalError(
+    `Unknown error in ${context.phase}`,
+    err,
+    {
+      walletId: context.walletId,
+      transport: context.transport,
+      errorType: typeof err
+    }
+  );
+}
+
+// src/adapters.ts
+function capabilityGuard(adapter, requiredCapabilities) {
+  const supported = adapter.getCapabilities();
+  const missing = requiredCapabilities.filter((cap) => !supported.includes(cap));
+  if (missing.length > 0) {
+    throw new CapabilityNotSupportedError(
+      adapter.walletId,
+      missing.join(", ")
+    );
+  }
+}
+async function installGuard(adapter) {
+  const detect = await adapter.detectInstalled();
+  if (!detect.installed) {
+    throw new WalletNotInstalledError(adapter.walletId, detect.reason);
+  }
+}
+
+// src/session.ts
+function generateSessionId() {
+  return toSessionId(`session_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`);
+}
+function validateSession(session) {
+  if (typeof session !== "object" || session === null) {
+    return false;
+  }
+  const s = session;
+  return typeof s.sessionId === "string" && typeof s.walletId === "string" && typeof s.partyId === "string" && typeof s.network === "string" && typeof s.createdAt === "number" && typeof s.origin === "string" && Array.isArray(s.capabilitiesSnapshot);
+}
+function isSessionExpired(session) {
+  if (!session.expiresAt) {
+    return false;
+  }
+  return Date.now() >= session.expiresAt;
+}
+function createSession(walletId, partyId, network, origin, capabilities = [], expiresInMs) {
+  const now = Date.now();
+  return {
+    sessionId: generateSessionId(),
+    walletId,
+    partyId,
+    network,
+    createdAt: now,
+    expiresAt: expiresInMs ? now + expiresInMs : void 0,
+    origin,
+    capabilitiesSnapshot: capabilities
+  };
+}
+
+// src/transport/deeplink.ts
+var DeepLinkTransport = class {
+  /**
+   * Generate a random state nonce
+   */
+  generateState() {
+    const array = new Uint8Array(32);
+    crypto.getRandomValues(array);
+    return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  /**
+   * Build deep link URL with query parameters
+   */
+  buildDeepLinkUrl(baseUrl, request) {
+    const url = new URL(baseUrl);
+    Object.entries(request).forEach(([key, value]) => {
+      if (value !== void 0) {
+        if (Array.isArray(value)) {
+          url.searchParams.set(key, JSON.stringify(value));
+        } else if (typeof value === "object") {
+          url.searchParams.set(key, JSON.stringify(value));
+        } else {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    });
+    return url.toString();
+  }
+  /**
+   * Validate callback origin
+   */
+  validateOrigin(origin, options) {
+    if (options.allowedOrigins && options.allowedOrigins.length > 0) {
+      if (!options.allowedOrigins.includes(origin)) {
+        throw new Error(`Origin ${origin} not allowed`);
+      }
+    }
+  }
+  /**
+   * Wait for callback via postMessage or redirect
+   */
+  async waitForCallback(state, options, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(new Error("Transport timeout"));
+      }, timeoutMs);
+      const messageHandler = (event) => {
+        try {
+          this.validateOrigin(event.origin, options);
+        } catch (err) {
+          return;
+        }
+        const data = event.data;
+        if (data && data.state === state) {
+          cleanup();
+          resolve(data);
+        }
+      };
+      const redirectHandler = () => {
+        if (typeof window !== "undefined") {
+          const hash = window.location.hash.substring(1);
+          const params = new URLSearchParams(hash);
+          const callbackState = params.get("state");
+          if (callbackState === state) {
+            const data = {};
+            params.forEach((value, key) => {
+              data[key] = value;
+            });
+            cleanup();
+            resolve(data);
+          }
+        }
+      };
+      const cleanup = () => {
+        clearTimeout(timeout);
+        if (typeof window !== "undefined") {
+          window.removeEventListener("message", messageHandler);
+          window.removeEventListener("hashchange", redirectHandler);
+        }
+      };
+      if (typeof window !== "undefined") {
+        window.addEventListener("message", messageHandler);
+        window.addEventListener("hashchange", redirectHandler);
+        redirectHandler();
+      }
+    });
+  }
+  /**
+   * Open a connection request
+   */
+  async openConnectRequest(url, request, options) {
+    if (!request.state) {
+      request.state = this.generateState();
+    }
+    const deepLinkUrl = this.buildDeepLinkUrl(url, request);
+    if (typeof window !== "undefined") {
+      window.location.href = deepLinkUrl;
+      const fallbackWindow = window.open(deepLinkUrl, "_blank");
+      if (!fallbackWindow) {
+        throw new Error("Failed to open deep link");
+      }
+    }
+    const timeout = options.timeoutMs || 6e4;
+    const response = await this.waitForCallback(
+      request.state,
+      options,
+      timeout
+    );
+    if (response.state !== request.state) {
+      throw new Error("State mismatch in callback");
+    }
+    return response;
+  }
+  /**
+   * Open a sign request
+   */
+  async openSignRequest(url, request, options) {
+    if (!request.state) {
+      request.state = this.generateState();
+    }
+    const deepLinkUrl = this.buildDeepLinkUrl(url, request);
+    if (typeof window !== "undefined") {
+      window.location.href = deepLinkUrl;
+    }
+    const timeout = options.timeoutMs || 6e4;
+    const response = await this.waitForCallback(
+      request.state,
+      options,
+      timeout
+    );
+    if (response.state !== request.state) {
+      throw new Error("State mismatch in callback");
+    }
+    return response;
+  }
+};
+
+// src/transport/popup.ts
+var PopupTransport = class {
+  /**
+   * Generate a random state nonce
+   */
+  generateState() {
+    const array = new Uint8Array(32);
+    crypto.getRandomValues(array);
+    return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  /**
+   * Build URL with query parameters
+   */
+  buildUrl(baseUrl, request) {
+    const url = new URL(baseUrl);
+    Object.entries(request).forEach(([key, value]) => {
+      if (value !== void 0) {
+        if (Array.isArray(value)) {
+          url.searchParams.set(key, JSON.stringify(value));
+        } else if (typeof value === "object") {
+          url.searchParams.set(key, JSON.stringify(value));
+        } else {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    });
+    return url.toString();
+  }
+  /**
+   * Validate message origin
+   */
+  validateOrigin(origin, options) {
+    if (options.allowedOrigins && options.allowedOrigins.length > 0) {
+      if (!options.allowedOrigins.includes(origin)) {
+        throw new Error(`Origin ${origin} not allowed`);
+      }
+    }
+  }
+  /**
+   * Open popup window
+   */
+  openPopup(url, _options) {
+    if (typeof window === "undefined") {
+      return null;
+    }
+    const width = 500;
+    const height = 600;
+    const left = window.screenX + (window.outerWidth - width) / 2;
+    const top = window.screenY + (window.outerHeight - height) / 2;
+    return window.open(
+      url,
+      "CantonConnect",
+      `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes`
+    );
+  }
+  /**
+   * Wait for postMessage callback
+   */
+  async waitForCallback(popup, state, options, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        popup.close();
+        reject(new Error("Transport timeout"));
+      }, timeoutMs);
+      const checkClosed = setInterval(() => {
+        if (popup.closed) {
+          cleanup();
+          reject(new Error("Popup closed by user"));
+        }
+      }, 500);
+      const messageHandler = (event) => {
+        try {
+          this.validateOrigin(event.origin, options);
+        } catch (err) {
+          return;
+        }
+        const data = event.data;
+        if (data && data.state === state) {
+          cleanup();
+          popup.close();
+          resolve(data);
+        }
+      };
+      const cleanup = () => {
+        clearTimeout(timeout);
+        clearInterval(checkClosed);
+        if (typeof window !== "undefined") {
+          window.removeEventListener("message", messageHandler);
+        }
+      };
+      if (typeof window !== "undefined") {
+        window.addEventListener("message", messageHandler);
+      }
+    });
+  }
+  /**
+   * Open a connection request
+   */
+  async openConnectRequest(url, request, options) {
+    if (!request.state) {
+      request.state = this.generateState();
+    }
+    const fullUrl = this.buildUrl(url, request);
+    const popup = this.openPopup(fullUrl, options);
+    if (!popup) {
+      throw new Error("Failed to open popup window");
+    }
+    const timeout = options.timeoutMs || 6e4;
+    const response = await this.waitForCallback(
+      popup,
+      request.state,
+      options,
+      timeout
+    );
+    if (response.state !== request.state) {
+      throw new Error("State mismatch in callback");
+    }
+    return response;
+  }
+  /**
+   * Open a sign request
+   */
+  async openSignRequest(url, request, options) {
+    if (!request.state) {
+      request.state = this.generateState();
+    }
+    const fullUrl = this.buildUrl(url, request);
+    const popup = this.openPopup(fullUrl, options);
+    if (!popup) {
+      throw new Error("Failed to open popup window");
+    }
+    const timeout = options.timeoutMs || 6e4;
+    const response = await this.waitForCallback(
+      popup,
+      request.state,
+      options,
+      timeout
+    );
+    if (response.state !== request.state) {
+      throw new Error("State mismatch in callback");
+    }
+    return response;
+  }
+};
+
+// src/transport/postmessage.ts
+var PostMessageTransport = class {
+  /**
+   * Generate a random state nonce
+   */
+  generateState() {
+    const array = new Uint8Array(32);
+    crypto.getRandomValues(array);
+    return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  /**
+   * Validate message origin
+   */
+  validateOrigin(origin, options) {
+    if (options.allowedOrigins && options.allowedOrigins.length > 0) {
+      if (!options.allowedOrigins.includes(origin)) {
+        throw new Error(`Origin ${origin} not allowed`);
+      }
+    }
+  }
+  /**
+   * Send message and wait for response
+   */
+  async sendAndWait(target, targetOrigin, message, options, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(new Error("Transport timeout"));
+      }, timeoutMs);
+      const messageHandler = (event) => {
+        try {
+          this.validateOrigin(event.origin, options);
+        } catch (err) {
+          return;
+        }
+        const data = event.data;
+        if (data && data.state === message.state) {
+          cleanup();
+          resolve(data);
+        }
+      };
+      const cleanup = () => {
+        clearTimeout(timeout);
+        if (typeof window !== "undefined") {
+          window.removeEventListener("message", messageHandler);
+        }
+      };
+      if (typeof window !== "undefined") {
+        window.addEventListener("message", messageHandler);
+        target.postMessage(message, targetOrigin);
+      }
+    });
+  }
+  /**
+   * Open a connection request
+   */
+  async openConnectRequest(url, request, options) {
+    if (typeof window === "undefined") {
+      throw new Error("PostMessage transport requires browser environment");
+    }
+    if (!request.state) {
+      request.state = this.generateState();
+    }
+    const targetUrl = new URL(url);
+    const targetOrigin = targetUrl.origin;
+    const target = window.opener || window.parent;
+    if (!target || target === window) {
+      throw new Error("No target window available for postMessage");
+    }
+    const timeout = options.timeoutMs || 6e4;
+    const response = await this.sendAndWait(
+      target,
+      targetOrigin,
+      request,
+      options,
+      timeout
+    );
+    if (response.state !== request.state) {
+      throw new Error("State mismatch in callback");
+    }
+    return response;
+  }
+  /**
+   * Open a sign request
+   */
+  async openSignRequest(url, request, options) {
+    if (typeof window === "undefined") {
+      throw new Error("PostMessage transport requires browser environment");
+    }
+    if (!request.state) {
+      request.state = this.generateState();
+    }
+    const targetUrl = new URL(url);
+    const targetOrigin = targetUrl.origin;
+    const target = window.opener || window.parent;
+    if (!target || target === window) {
+      throw new Error("No target window available for postMessage");
+    }
+    const timeout = options.timeoutMs || 6e4;
+    const response = await this.sendAndWait(
+      target,
+      targetOrigin,
+      request,
+      options,
+      timeout
+    );
+    if (response.state !== request.state) {
+      throw new Error("State mismatch in callback");
+    }
+    return response;
+  }
+};
+
+// src/transport/mock.ts
+var MockTransport = class {
+  mockResponses = /* @__PURE__ */ new Map();
+  mockJobs = /* @__PURE__ */ new Map();
+  /**
+   * Set mock response for a state
+   */
+  setMockResponse(state, response) {
+    this.mockResponses.set(state, response);
+  }
+  /**
+   * Set mock job status
+   */
+  setMockJob(jobId, status) {
+    this.mockJobs.set(jobId, status);
+  }
+  /**
+   * Clear all mocks
+   */
+  clearMocks() {
+    this.mockResponses.clear();
+    this.mockJobs.clear();
+  }
+  /**
+   * Open a connection request (mock)
+   */
+  async openConnectRequest(_url, request, _options) {
+    const mockResponse = this.mockResponses.get(request.state);
+    if (mockResponse && "partyId" in mockResponse) {
+      return mockResponse;
+    }
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve({
+          state: request.state,
+          partyId: toPartyId("mock-party-" + Date.now()),
+          sessionToken: "mock-token",
+          expiresAt: Date.now() + 36e5,
+          // 1 hour
+          capabilities: request.requestedCapabilities || ["connect", "signMessage"]
+        });
+      }, 100);
+    });
+  }
+  /**
+   * Open a sign request (mock)
+   */
+  async openSignRequest(_url, request, _options) {
+    const mockResponse = this.mockResponses.get(request.state);
+    if (mockResponse && ("signature" in mockResponse || "jobId" in mockResponse)) {
+      return mockResponse;
+    }
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve({
+          state: request.state,
+          signature: "mock-signature-" + Date.now(),
+          transactionHash: request.transaction ? "mock-tx-hash" : void 0
+        });
+      }, 100);
+    });
+  }
+  /**
+   * Poll job status (mock)
+   */
+  async pollJobStatus(jobId, _statusUrl, _options) {
+    const mockJob = this.mockJobs.get(jobId);
+    if (mockJob) {
+      return mockJob;
+    }
+    return {
+      jobId,
+      status: "approved",
+      result: {
+        signature: "mock-signature",
+        transactionHash: "mock-tx-hash"
+      }
+    };
+  }
+};
+
+exports.CantonConnectError = CantonConnectError;
+exports.CapabilityNotSupportedError = CapabilityNotSupportedError;
+exports.DeepLinkTransport = DeepLinkTransport;
+exports.InternalError = InternalError;
+exports.MockTransport = MockTransport;
+exports.OriginNotAllowedError = OriginNotAllowedError;
+exports.PopupTransport = PopupTransport;
+exports.PostMessageTransport = PostMessageTransport;
+exports.RegistryFetchFailedError = RegistryFetchFailedError;
+exports.RegistrySchemaInvalidError = RegistrySchemaInvalidError;
+exports.RegistryVerificationFailedError = RegistryVerificationFailedError;
+exports.SessionExpiredError = SessionExpiredError;
+exports.TimeoutError = TimeoutError;
+exports.TransportError = TransportError;
+exports.UserRejectedError = UserRejectedError;
+exports.WalletNotFoundError = WalletNotFoundError;
+exports.WalletNotInstalledError = WalletNotInstalledError;
+exports.capabilityGuard = capabilityGuard;
+exports.createSession = createSession;
+exports.generateSessionId = generateSessionId;
+exports.installGuard = installGuard;
+exports.isSessionExpired = isSessionExpired;
+exports.mapUnknownErrorToCantonConnectError = mapUnknownErrorToCantonConnectError;
+exports.toPartyId = toPartyId;
+exports.toSessionId = toSessionId;
+exports.toSignature = toSignature;
+exports.toTransactionHash = toTransactionHash;
+exports.toWalletId = toWalletId;
+exports.validateSession = validateSession;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map