@partylayer/adapter-send 1.0.0

package/dist/index.mjs

@@ -0,0 +1,619 @@
+import { WalletNotInstalledError, PartyLayerError, UserRejectedError, CapabilityNotSupportedError, TransportError, mapUnknownErrorToPartyLayerError, matchesProviderDetection, toWalletId, toPartyId, toSignature, toTransactionHash } from '@partylayer/core';
+
+// src/send-adapter.ts
+
+// src/constants.ts
+var SEND_KERNEL_ID = "ldmohiccoioolenadmogclhoklmanpgi";
+var SEND_BUILTIN_DETECTION = {
+  transport: "window.canton",
+  matchers: [
+    { field: "kernel.url", match: "domain", value: "cantonwallet.com" },
+    { field: "kernel.userUrl", match: "domain", value: "cantonwallet.com" },
+    { field: "kernel.id", match: "exact", values: [SEND_KERNEL_ID] }
+  ]
+};
+var SEND_SUPPORTED_NETWORKS = ["canton:mainnet"];
+var SEND_INSTALL_URL = "https://sigilry.org";
+var SEND_HOMEPAGE = "https://cantonwallet.com";
+var SEND_DOCS_URL = "https://sigilry.org";
+var SEND_SIGNING_METHOD = "webauthn-prf";
+var SendRpcErrorCode = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  USER_REJECTED: 4001,
+  UNAUTHORIZED: 4100,
+  UNSUPPORTED_METHOD: 4200,
+  DISCONNECTED: 4900,
+  CHAIN_DISCONNECTED: 4901,
+  INVALID_INPUT: -32e3,
+  RESOURCE_NOT_FOUND: -32001,
+  RESOURCE_UNAVAILABLE: -32002,
+  TRANSACTION_REJECTED: -32003,
+  METHOD_NOT_SUPPORTED: -32004,
+  LIMIT_EXCEEDED: -32005
+};
+var WALLET_ID = "send";
+var SendNotInstalledError = class extends WalletNotInstalledError {
+  constructor(reason) {
+    super(
+      WALLET_ID,
+      reason ?? `Send Canton Wallet is not detected. Visit ${SEND_INSTALL_URL} for installation instructions`
+    );
+    this.name = "SendNotInstalledError";
+    this.details = {
+      ...this.details ?? {},
+      installUrl: SEND_INSTALL_URL
+    };
+  }
+};
+var SendKernelMismatchError = class extends WalletNotInstalledError {
+  constructor(actualKernelId) {
+    super(
+      WALLET_ID,
+      `Another Canton wallet is active at window.canton (kernel.id="${actualKernelId}", expected "${SEND_KERNEL_ID}"). The Send adapter will yield to the matching adapter.`
+    );
+    this.name = "SendKernelMismatchError";
+    this.details = {
+      ...this.details ?? {},
+      actualKernelId,
+      expectedKernelId: SEND_KERNEL_ID
+    };
+  }
+};
+var SendAuthTimeoutError = class extends WalletNotInstalledError {
+  constructor(originalMessage) {
+    super(
+      WALLET_ID,
+      originalMessage ?? "Send authentication timed out. Please try again. If the problem persists, see https://cantonwallet.com"
+    );
+    this.name = "SendAuthTimeoutError";
+    this.details = {
+      ...this.details ?? {},
+      cause: "send-auth-timeout",
+      retry: true,
+      helpUrl: "https://cantonwallet.com",
+      ...originalMessage ? { originalMessage } : {}
+    };
+  }
+};
+function detectSendAuthTimeout(err) {
+  if (!err || typeof err !== "object") return false;
+  const raw = err.message;
+  if (typeof raw !== "string" || raw.length === 0) return false;
+  const msg = raw.toLowerCase();
+  return msg.includes("authentication timed out") || msg.includes("cannot reach authentication server") || msg.includes("auth.cantonwallet.com");
+}
+function isSendRpcError(err) {
+  if (!err || typeof err !== "object") return false;
+  const candidate = err;
+  return typeof candidate.code === "number" && typeof candidate.message === "string";
+}
+function mapSigilryError(err, context) {
+  if (err instanceof PartyLayerError) return err;
+  if (detectSendAuthTimeout(err)) {
+    const original = err instanceof Error ? err.message : void 0;
+    return new SendAuthTimeoutError(original);
+  }
+  if (isSendRpcError(err)) {
+    const code = err.code;
+    const message = err.message;
+    if (code === SendRpcErrorCode.USER_REJECTED) {
+      return new UserRejectedError(context.phase, {
+        walletId: context.walletId,
+        transport: context.transport,
+        rpcCode: code,
+        originalMessage: message
+      });
+    }
+    if (code === SendRpcErrorCode.UNSUPPORTED_METHOD || code === SendRpcErrorCode.METHOD_NOT_FOUND || code === SendRpcErrorCode.METHOD_NOT_SUPPORTED) {
+      return new CapabilityNotSupportedError(WALLET_ID, context.phase);
+    }
+    if (code === SendRpcErrorCode.DISCONNECTED || code === SendRpcErrorCode.CHAIN_DISCONNECTED || code === SendRpcErrorCode.UNAUTHORIZED) {
+      return new TransportError(message, err, {
+        walletId: context.walletId,
+        phase: context.phase,
+        transport: context.transport,
+        rpcCode: code
+      });
+    }
+    return new TransportError(message, err, {
+      walletId: context.walletId,
+      phase: context.phase,
+      transport: context.transport,
+      rpcCode: code
+    });
+  }
+  return mapUnknownErrorToPartyLayerError(err, context);
+}
+function templateIdHint(payload) {
+  if (!payload || typeof payload !== "object") return "";
+  const commands = payload.commands;
+  if (!Array.isArray(commands)) return "";
+  try {
+    for (const cmd of commands) {
+      const exercise = cmd?.ExerciseCommand ?? cmd?.exerciseCommand ?? cmd?.exercise;
+      const create = cmd?.CreateCommand ?? cmd?.createCommand ?? cmd?.create;
+      const raw = exercise?.templateId ?? create?.templateId;
+      const choice = exercise?.choice;
+      if (choice === "Amulet_Transfer" && typeof raw === "string" && raw.includes("Splice.Amulet:Amulet")) {
+        return " The command exercises 'Amulet_Transfer' directly on the Amulet template \u2014 that's the legacy (pre-CIP-56) path Canton no longer accepts. Use the Token Standard flow: exercise 'TransferFactory_Transfer' by interface on a TransferFactory contract (interfaceId '#splice-api-token-transfer-instruction-v1:Splice.Api.Token.TransferInstructionV1:TransferFactory'). See https://partylayer.xyz/docs/token-transfers for the canonical flow.";
+      }
+      if (typeof raw === "string" && raw.length > 0 && !raw.startsWith("#")) {
+        return ` The command uses templateId="${raw}" which is the short Canton form; Send requires the fully-qualified Daml form (e.g. '#splice-amulet:Splice.Amulet:Amulet').`;
+      }
+    }
+  } catch {
+  }
+  return "";
+}
+function safePreview(value, maxLen = 200) {
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  try {
+    const s = JSON.stringify(value);
+    if (typeof s !== "string") return String(value);
+    return s.length > maxLen ? s.slice(0, maxLen) + "..." : s;
+  } catch {
+    return String(value);
+  }
+}
+var SendProvider = class {
+  detection;
+  cachedStatus = null;
+  /**
+   * @param detection Optional. Used to match the running `window.canton`
+   *   provider against Send's identity. When omitted, falls back to
+   *   `SEND_BUILTIN_DETECTION` (canonical registry rule mirror).
+   */
+  constructor(detection) {
+    this.detection = detection ?? SEND_BUILTIN_DETECTION;
+  }
+  /**
+   * True when `window.canton` is present AND its self-reported status
+   * matches Send's detection rules. Performs an actual `status` round-trip
+   * on first call and caches the response for subsequent ones.
+   */
+  async isInstalled() {
+    if (typeof window === "undefined" || !window.canton) return false;
+    try {
+      const status = await this.fetchStatus();
+      return matchesProviderDetection(status, this.detection);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Synchronous best-effort presence check. Used for fast picker rendering
+   * before any async status introspection. May report `true` for a
+   * non-Send provider — callers must follow up with `isInstalled()` (or
+   * any guarded request) before assuming Send is wired in.
+   */
+  isPotentiallyAvailable() {
+    return typeof window !== "undefined" && !!window.canton;
+  }
+  /**
+   * Read the cached `kernel.id` from the running provider, fetching status
+   * on demand. Diagnostic helper kept public for back-compat — detection
+   * itself no longer hinges on this single field.
+   */
+  async getKernelId() {
+    const status = await this.fetchStatus();
+    const id = status?.kernel?.id;
+    if (typeof id !== "string" || id.length === 0) {
+      throw new SendNotInstalledError(
+        "window.canton.status() did not return a kernel.id \u2014 provider is malformed."
+      );
+    }
+    return id;
+  }
+  /**
+   * Read the latest cached status object. Resolves the underlying RPC on
+   * demand if no cached value is present.
+   */
+  async getStatus() {
+    return this.fetchStatus();
+  }
+  /**
+   * Reset the cached status (e.g. after the user uninstalls and reinstalls
+   * the extension, or you suspect kernel identity changed mid-session).
+   * Kept under both names to avoid breaking existing test imports.
+   */
+  resetKernelCache() {
+    this.cachedStatus = null;
+  }
+  resetStatusCache() {
+    this.cachedStatus = null;
+  }
+  async fetchStatus() {
+    if (this.cachedStatus) return this.cachedStatus;
+    if (typeof window === "undefined" || !window.canton) {
+      throw new SendNotInstalledError();
+    }
+    const provider = window.canton;
+    const status = await provider.request({ method: "status" });
+    this.cachedStatus = status;
+    return status;
+  }
+  /** Internal — bypasses the detection guard. */
+  async rawRequest(args) {
+    if (typeof window === "undefined" || !window.canton) {
+      throw new SendNotInstalledError();
+    }
+    const provider = window.canton;
+    return provider.request(args);
+  }
+  /** Public dispatch — guards every call with a registry-driven detection check. */
+  async guardedRequest(args) {
+    const status = await this.fetchStatus();
+    if (!matchesProviderDetection(status, this.detection)) {
+      const observedId = status?.kernel?.id ?? "<unknown>";
+      throw new SendKernelMismatchError(observedId);
+    }
+    return this.rawRequest(args);
+  }
+  // ── Sigilry RPC methods (every one is guarded) ─────────────────────────
+  status() {
+    return this.guardedRequest({ method: "status" });
+  }
+  connect() {
+    return this.guardedRequest({ method: "connect" });
+  }
+  disconnect() {
+    return this.guardedRequest({ method: "disconnect" });
+  }
+  isConnected() {
+    return this.guardedRequest({ method: "isConnected" });
+  }
+  getActiveNetwork() {
+    return this.guardedRequest({ method: "getActiveNetwork" });
+  }
+  listAccounts() {
+    return this.guardedRequest({ method: "listAccounts" });
+  }
+  getPrimaryAccount() {
+    return this.guardedRequest({ method: "getPrimaryAccount" });
+  }
+  signMessage(message) {
+    return this.guardedRequest({ method: "signMessage", params: { message } });
+  }
+  prepareExecute(params) {
+    return this.guardedRequest({ method: "prepareExecute", params });
+  }
+  prepareExecuteAndWait(params) {
+    return this.guardedRequest({ method: "prepareExecuteAndWait", params });
+  }
+  ledgerApi(req) {
+    return this.guardedRequest({ method: "ledgerApi", params: req });
+  }
+  // ── Events ─────────────────────────────────────────────────────────────
+  // No kernel guard here on purpose — by the time the dApp wires up an
+  // event listener it has already gone through `connect()` (which IS
+  // guarded), so we trust the binding.
+  on(event, listener) {
+    if (typeof window === "undefined" || !window.canton) {
+      throw new SendNotInstalledError();
+    }
+    window.canton.on(event, listener);
+  }
+  off(event, listener) {
+    if (typeof window === "undefined" || !window.canton) return;
+    if (typeof window.canton.off === "function") {
+      window.canton.off(event, listener);
+      return;
+    }
+    if (typeof window.canton.removeListener === "function") {
+      window.canton.removeListener(event, listener);
+    }
+  }
+};
+
+// src/send-adapter.ts
+var WALLET_ID2 = "send";
+var SEND_CAPABILITIES = [
+  "connect",
+  "disconnect",
+  "restore",
+  "signMessage",
+  "submitTransaction",
+  "ledgerApi",
+  "events",
+  "injected"
+];
+var SendAdapter = class {
+  walletId = toWalletId(WALLET_ID2);
+  name = "Send";
+  provider;
+  /**
+   * @param options.detection Optional. When supplied, the adapter uses
+   *   these matcher rules to decide whether the running `window.canton`
+   *   belongs to Send. Inject this from the registry entry's
+   *   `providerDetection` field for canonical behaviour. Omitting it
+   *   falls back to the built-in pattern that mirrors the canonical
+   *   registry rule (parity is verified by tests).
+   * @param options.provider Optional. Pre-built provider instance, used
+   *   primarily by tests; takes precedence over `options.detection`.
+   */
+  constructor(options) {
+    this.provider = options?.provider ?? new SendProvider(options?.detection);
+  }
+  getCapabilities() {
+    return SEND_CAPABILITIES;
+  }
+  async detectInstalled() {
+    if (typeof window === "undefined") {
+      return { installed: false, reason: "Browser environment required" };
+    }
+    if (!this.provider.isPotentiallyAvailable()) {
+      return {
+        installed: false,
+        reason: `Send Canton Wallet not detected. Visit ${SEND_INSTALL_URL} for installation instructions`
+      };
+    }
+    const installed = await this.provider.isInstalled();
+    if (installed) {
+      return { installed: true, reason: "Send Canton Wallet detected" };
+    }
+    return {
+      installed: false,
+      reason: "window.canton is present but its kernel.id does not match Send. Another Canton wallet is active."
+    };
+  }
+  async connect(ctx, _opts) {
+    try {
+      if (!this.provider.isPotentiallyAvailable()) {
+        throw new SendNotInstalledError();
+      }
+      ctx.logger.debug("Connecting to Send Canton Wallet", {
+        appName: ctx.appName,
+        network: ctx.network
+      });
+      const status = await this.provider.connect();
+      const account = await this.provider.getPrimaryAccount();
+      const partyId = toPartyId(account.partyId);
+      ctx.logger.info("Connected to Send Canton Wallet", {
+        partyId: account.partyId,
+        signingProviderId: account.signingProviderId,
+        kernelId: status.kernel?.id
+      });
+      return {
+        partyId,
+        session: {
+          walletId: this.walletId,
+          network: ctx.network,
+          createdAt: Date.now(),
+          metadata: buildSessionMetadata(status, account)
+        },
+        capabilities: this.getCapabilities()
+      };
+    } catch (err) {
+      throw mapSigilryError(err, {
+        walletId: this.walletId,
+        phase: "connect",
+        transport: "injected",
+        details: { origin: ctx.origin, network: ctx.network }
+      });
+    }
+  }
+  async disconnect(ctx, _session) {
+    try {
+      await this.provider.disconnect();
+    } catch (err) {
+      ctx.logger.warn("Error during Send wallet disconnect", err);
+    }
+  }
+  async restore(ctx, persisted) {
+    try {
+      if (typeof window === "undefined") return null;
+      if (!this.provider.isPotentiallyAvailable()) return null;
+      if (persisted.expiresAt && Date.now() >= persisted.expiresAt) return null;
+      const status = await this.provider.status();
+      if (!status.isConnected) return null;
+      const account = await this.provider.getPrimaryAccount();
+      if (account.partyId !== persisted.partyId) {
+        ctx.logger.debug(
+          "Send primary account changed since session was persisted; treating as expired",
+          {
+            persistedPartyId: persisted.partyId,
+            currentPartyId: account.partyId
+          }
+        );
+        return null;
+      }
+      ctx.logger.debug("Restored Send Canton Wallet session", {
+        partyId: account.partyId,
+        kernelId: status.kernel?.id
+      });
+      return {
+        ...persisted,
+        walletId: this.walletId,
+        metadata: {
+          ...persisted.metadata ?? {},
+          ...buildSessionMetadata(status, account)
+        }
+      };
+    } catch (err) {
+      ctx.logger.warn("Failed to restore Send wallet session", err);
+      return null;
+    }
+  }
+  async signMessage(ctx, session, params) {
+    try {
+      if (typeof params.message !== "string" || params.message.length === 0) {
+        throw new Error("signMessage requires a non-empty string `message`");
+      }
+      ctx.logger.debug("Signing message with Send Canton Wallet", {
+        sessionId: session.sessionId,
+        messageLength: params.message.length
+      });
+      const { signature } = await this.provider.signMessage(params.message);
+      return {
+        signature: toSignature(signature),
+        partyId: session.partyId,
+        message: params.message,
+        nonce: params.nonce,
+        domain: params.domain
+      };
+    } catch (err) {
+      throw mapSigilryError(err, {
+        walletId: this.walletId,
+        phase: "signMessage",
+        transport: "injected",
+        details: { sessionId: session.sessionId }
+      });
+    }
+  }
+  async signTransaction(_ctx, _session, _params) {
+    throw new CapabilityNotSupportedError(
+      this.walletId,
+      "signTransaction \u2014 Send fuses sign-and-submit through prepareExecuteAndWait. Use submitTransaction instead."
+    );
+  }
+  async submitTransaction(ctx, session, params) {
+    const payload = params.signedTx;
+    try {
+      if (!payload || typeof payload !== "object") {
+        throw new Error(
+          `submitTransaction requires a SendPrepareSubmissionRequest as \`signedTx\` (received ${safePreview(payload)})`
+        );
+      }
+      if (!payload.commands || typeof payload.commands !== "object") {
+        throw new Error(
+          `submitTransaction signedTx is missing the required 'commands' field (received ${safePreview(payload)})`
+        );
+      }
+      ctx.logger.debug("Submitting transaction via Send Canton Wallet", {
+        sessionId: session.sessionId,
+        commandId: payload.commandId
+      });
+      const { tx } = await this.provider.prepareExecuteAndWait(payload);
+      if (!tx || typeof tx !== "object" || !tx.payload?.updateId) {
+        throw new Error(
+          `Send returned an unexpected shape from prepareExecuteAndWait. Expected { tx: { commandId, status:'executed', payload: { updateId, completionOffset } } } but received ${safePreview(tx)}.`
+        );
+      }
+      return {
+        transactionHash: toTransactionHash(tx.payload.updateId),
+        submittedAt: Date.now(),
+        commandId: tx.commandId,
+        updateId: tx.payload.updateId
+      };
+    } catch (err) {
+      const baseHint = templateIdHint(payload);
+      if (baseHint && !isSendRpcError(err)) {
+        const baseMessage = err instanceof Error ? err.message : String(err);
+        throw new TransportError(
+          baseMessage + baseHint,
+          err instanceof Error ? err : void 0,
+          {
+            walletId: this.walletId,
+            phase: "submitTransaction",
+            transport: "injected",
+            sessionId: session.sessionId,
+            commandId: payload?.commandId
+          }
+        );
+      }
+      throw mapSigilryError(err, {
+        walletId: this.walletId,
+        phase: "submitTransaction",
+        transport: "injected",
+        details: { sessionId: session.sessionId, commandId: payload?.commandId }
+      });
+    }
+  }
+  async ledgerApi(ctx, session, params) {
+    try {
+      ctx.logger.debug("Proxying ledger API request via Send Canton Wallet", {
+        sessionId: session.sessionId,
+        requestMethod: params.requestMethod,
+        resource: params.resource
+      });
+      const result = await this.provider.ledgerApi({
+        requestMethod: params.requestMethod,
+        resource: params.resource,
+        body: params.body
+      });
+      if (result && typeof result.response === "string") {
+        return { response: result.response };
+      }
+      return { response: JSON.stringify(result ?? null) };
+    } catch (err) {
+      throw mapSigilryError(err, {
+        walletId: this.walletId,
+        phase: "ledgerApi",
+        transport: "injected",
+        details: {
+          sessionId: session.sessionId,
+          requestMethod: params.requestMethod,
+          resource: params.resource
+        }
+      });
+    }
+  }
+  /**
+   * Subscribe to PartyLayer adapter events. Currently bridges only
+   * `txStatus` from Send's native `txChanged` event. Other PartyLayer
+   * adapter events (`connect` / `disconnect` / `sessionExpired` / `error`)
+   * are emitted by the SDK itself, not the wallet, so we no-op them.
+   */
+  on(event, handler) {
+    if (event !== "txStatus") {
+      return () => {
+      };
+    }
+    const listener = (...args) => {
+      const tx = args[0];
+      if (!tx) return;
+      handler({
+        status: mapTxStatus(tx.status),
+        commandId: tx.commandId,
+        raw: tx
+      });
+    };
+    try {
+      this.provider.on("txChanged", listener);
+    } catch {
+      return () => {
+      };
+    }
+    return () => this.provider.off("txChanged", listener);
+  }
+};
+function mapTxStatus(status) {
+  switch (status) {
+    case "pending":
+      return "pending";
+    case "signed":
+      return "submitted";
+    case "executed":
+      return "committed";
+    case "failed":
+    default:
+      return "failed";
+  }
+}
+function buildSessionMetadata(status, account) {
+  const meta = {
+    kernelId: status.kernel?.id ?? "",
+    signingProviderId: account.signingProviderId,
+    signingMethod: SEND_SIGNING_METHOD,
+    publicKey: account.publicKey,
+    namespace: account.namespace,
+    networkId: account.networkId,
+    hint: account.hint
+  };
+  if (status.network?.ledgerApi?.baseUrl) {
+    meta.ledgerApiBaseUrl = status.network.ledgerApi.baseUrl;
+  }
+  if (status.session?.userId) {
+    meta.userId = status.session.userId;
+  }
+  return meta;
+}
+
+export { SEND_DOCS_URL, SEND_HOMEPAGE, SEND_INSTALL_URL, SEND_KERNEL_ID, SEND_SIGNING_METHOD, SEND_SUPPORTED_NETWORKS, SendAdapter, SendAuthTimeoutError, SendKernelMismatchError, SendNotInstalledError, SendProvider, SendRpcErrorCode, detectSendAuthTimeout, mapSigilryError, safePreview, templateIdHint };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map