@partylayer/provider 0.1.1

package/dist/index.js

@@ -0,0 +1,938 @@
+'use strict';
+
+var core = require('@partylayer/core');
+
+// src/provider.ts
+
+// src/event-bus.ts
+var CIP0103EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  owner = null;
+  /** Set the owning Provider instance (for chaining returns) */
+  setOwner(owner) {
+    this.owner = owner;
+  }
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+    return this.owner;
+  }
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set || set.size === 0) return false;
+    for (const fn of set) {
+      try {
+        fn(...args);
+      } catch {
+      }
+    }
+    return true;
+  }
+  removeListener(event, listenerToRemove) {
+    const set = this.listeners.get(event);
+    if (set) {
+      set.delete(listenerToRemove);
+      if (set.size === 0) this.listeners.delete(event);
+    }
+    return this.owner;
+  }
+  /** Remove all listeners, optionally scoped to a single event */
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+  }
+  /** Number of listeners for a given event */
+  listenerCount(event) {
+    return this.listeners.get(event)?.size ?? 0;
+  }
+};
+
+// src/errors.ts
+var ProviderRpcError = class _ProviderRpcError extends Error {
+  code;
+  data;
+  constructor(message, code, data) {
+    super(message);
+    this.name = "ProviderRpcError";
+    this.code = code;
+    this.data = data;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ProviderRpcError);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      data: this.data
+    };
+  }
+};
+var RPC_ERRORS = {
+  /** User rejected the request */
+  USER_REJECTED: 4001,
+  /** The requested method/account is not authorized */
+  UNAUTHORIZED: 4100,
+  /** Provider does not support the requested method */
+  UNSUPPORTED_METHOD: 4200,
+  /** Provider is disconnected from all chains */
+  DISCONNECTED: 4900,
+  /** Provider is not connected to the requested chain */
+  CHAIN_DISCONNECTED: 4901
+};
+var JSON_RPC_ERRORS = {
+  /** Invalid JSON (parse error) */
+  PARSE_ERROR: -32700,
+  /** Invalid request object */
+  INVALID_REQUEST: -32600,
+  /** Method not found */
+  METHOD_NOT_FOUND: -32601,
+  /** Invalid method parameters */
+  INVALID_PARAMS: -32602,
+  /** Internal JSON-RPC error */
+  INTERNAL_ERROR: -32603,
+  /** Invalid input / missing or invalid parameters */
+  INVALID_INPUT: -32e3,
+  /** Resource not found */
+  RESOURCE_NOT_FOUND: -32001,
+  /** Resource unavailable */
+  RESOURCE_UNAVAILABLE: -32002,
+  /** Transaction rejected */
+  TRANSACTION_REJECTED: -32003,
+  /** Method not supported */
+  METHOD_NOT_SUPPORTED: -32004,
+  /** Rate limit exceeded */
+  RATE_LIMIT_EXCEEDED: -32005
+};
+function userRejected(message = "User Rejected Request", data) {
+  return new ProviderRpcError(message, RPC_ERRORS.USER_REJECTED, data);
+}
+function unauthorized(message = "Unauthorized", data) {
+  return new ProviderRpcError(message, RPC_ERRORS.UNAUTHORIZED, data);
+}
+function unsupportedMethod(method) {
+  return new ProviderRpcError(
+    `Unsupported Method: "${method}"`,
+    RPC_ERRORS.UNSUPPORTED_METHOD,
+    { method }
+  );
+}
+function disconnected(message = "Disconnected") {
+  return new ProviderRpcError(message, RPC_ERRORS.DISCONNECTED);
+}
+function chainDisconnected(message = "Chain Disconnected") {
+  return new ProviderRpcError(message, RPC_ERRORS.CHAIN_DISCONNECTED);
+}
+function internalError(message, data) {
+  return new ProviderRpcError(message, JSON_RPC_ERRORS.INTERNAL_ERROR, data);
+}
+function invalidParams(message, data) {
+  return new ProviderRpcError(message, JSON_RPC_ERRORS.INVALID_PARAMS, data);
+}
+function methodNotFound(method) {
+  return new ProviderRpcError(
+    `Method not found: "${method}"`,
+    JSON_RPC_ERRORS.METHOD_NOT_FOUND,
+    { method }
+  );
+}
+function resourceNotFound(message, data) {
+  return new ProviderRpcError(message, JSON_RPC_ERRORS.RESOURCE_NOT_FOUND, data);
+}
+function resourceUnavailable(message, data) {
+  return new ProviderRpcError(message, JSON_RPC_ERRORS.RESOURCE_UNAVAILABLE, data);
+}
+function transactionRejected(message = "Transaction rejected", data) {
+  return new ProviderRpcError(message, JSON_RPC_ERRORS.TRANSACTION_REJECTED, data);
+}
+var ERROR_CODE_TO_RPC = {
+  USER_REJECTED: RPC_ERRORS.USER_REJECTED,
+  WALLET_NOT_FOUND: JSON_RPC_ERRORS.RESOURCE_NOT_FOUND,
+  WALLET_NOT_INSTALLED: JSON_RPC_ERRORS.RESOURCE_UNAVAILABLE,
+  ORIGIN_NOT_ALLOWED: RPC_ERRORS.UNAUTHORIZED,
+  SESSION_EXPIRED: RPC_ERRORS.DISCONNECTED,
+  CAPABILITY_NOT_SUPPORTED: RPC_ERRORS.UNSUPPORTED_METHOD,
+  TRANSPORT_ERROR: JSON_RPC_ERRORS.INTERNAL_ERROR,
+  REGISTRY_FETCH_FAILED: JSON_RPC_ERRORS.RESOURCE_UNAVAILABLE,
+  REGISTRY_VERIFICATION_FAILED: JSON_RPC_ERRORS.INTERNAL_ERROR,
+  REGISTRY_SCHEMA_INVALID: JSON_RPC_ERRORS.INTERNAL_ERROR,
+  INTERNAL_ERROR: JSON_RPC_ERRORS.INTERNAL_ERROR,
+  TIMEOUT: JSON_RPC_ERRORS.INVALID_INPUT
+};
+var RPC_TO_ERROR_CODE = {
+  [RPC_ERRORS.USER_REJECTED]: "USER_REJECTED",
+  [RPC_ERRORS.UNAUTHORIZED]: "ORIGIN_NOT_ALLOWED",
+  [RPC_ERRORS.UNSUPPORTED_METHOD]: "CAPABILITY_NOT_SUPPORTED",
+  [RPC_ERRORS.DISCONNECTED]: "SESSION_EXPIRED",
+  [RPC_ERRORS.CHAIN_DISCONNECTED]: "TRANSPORT_ERROR",
+  [JSON_RPC_ERRORS.INTERNAL_ERROR]: "INTERNAL_ERROR",
+  [JSON_RPC_ERRORS.METHOD_NOT_FOUND]: "CAPABILITY_NOT_SUPPORTED",
+  [JSON_RPC_ERRORS.RESOURCE_NOT_FOUND]: "WALLET_NOT_FOUND",
+  [JSON_RPC_ERRORS.RESOURCE_UNAVAILABLE]: "WALLET_NOT_INSTALLED",
+  [JSON_RPC_ERRORS.TRANSACTION_REJECTED]: "USER_REJECTED",
+  [JSON_RPC_ERRORS.INVALID_INPUT]: "TIMEOUT"
+};
+function toProviderRpcError(err) {
+  if (err instanceof ProviderRpcError) {
+    return err;
+  }
+  if (err instanceof core.PartyLayerError) {
+    const code = ERROR_CODE_TO_RPC[err.code] ?? JSON_RPC_ERRORS.INTERNAL_ERROR;
+    return new ProviderRpcError(err.message, code, {
+      originalCode: err.code,
+      details: err.details
+    });
+  }
+  if (isRpcShaped(err)) {
+    return new ProviderRpcError(err.message, err.code, err.data);
+  }
+  if (err instanceof Error) {
+    return new ProviderRpcError(err.message, JSON_RPC_ERRORS.INTERNAL_ERROR);
+  }
+  return new ProviderRpcError(String(err), JSON_RPC_ERRORS.INTERNAL_ERROR);
+}
+function toPartyLayerError(err) {
+  const code = RPC_TO_ERROR_CODE[err.code] ?? "INTERNAL_ERROR";
+  return new core.PartyLayerError(err.message, code, {
+    details: { rpcCode: err.code, data: err.data }
+  });
+}
+function isRpcShaped(err) {
+  if (typeof err !== "object" || err === null) return false;
+  const e = err;
+  return typeof e.message === "string" && typeof e.code === "number";
+}
+
+// src/method-router.ts
+var MethodRouter = class {
+  handlers = /* @__PURE__ */ new Map();
+  walletProvider = null;
+  constructor() {
+    this.registerDefaults();
+  }
+  /** Set / swap the underlying native wallet provider */
+  setWalletProvider(provider) {
+    this.walletProvider = provider;
+  }
+  /** Get the current wallet provider */
+  getWalletProvider() {
+    return this.walletProvider;
+  }
+  /** Register (or override) a handler for a method name */
+  register(method, handler) {
+    this.handlers.set(method, handler);
+  }
+  /** Route a request to the appropriate handler */
+  async route(payload) {
+    const { method, params } = payload;
+    const handler = this.handlers.get(method);
+    if (!handler) {
+      if (this.walletProvider) {
+        try {
+          return await this.walletProvider.request(payload);
+        } catch (err) {
+          throw toProviderRpcError(err);
+        }
+      }
+      throw unsupportedMethod(method);
+    }
+    if (!this.walletProvider && method !== "connect" && method !== "isConnected") {
+      throw disconnected("No wallet provider connected");
+    }
+    try {
+      return await handler(this.walletProvider, params);
+    } catch (err) {
+      throw toProviderRpcError(err);
+    }
+  }
+  /** Check whether a handler is registered for a given method */
+  hasHandler(method) {
+    return this.handlers.has(method);
+  }
+  // ─── Default passthrough handlers ───────────────────────────────────────
+  registerDefaults() {
+    const passthrough = (method) => {
+      return async (wp, params) => {
+        return wp.request({ method, params });
+      };
+    };
+    this.register("connect", passthrough("connect"));
+    this.register("disconnect", passthrough("disconnect"));
+    this.register("isConnected", passthrough("isConnected"));
+    this.register("status", passthrough("status"));
+    this.register("getActiveNetwork", passthrough("getActiveNetwork"));
+    this.register("listAccounts", passthrough("listAccounts"));
+    this.register("getPrimaryAccount", passthrough("getPrimaryAccount"));
+    this.register("signMessage", passthrough("signMessage"));
+    this.register("prepareExecute", passthrough("prepareExecute"));
+    this.register("ledgerApi", passthrough("ledgerApi"));
+  }
+};
+async function handleAsyncConnect(walletProvider, connectResult, options = {}) {
+  if (connectResult.isConnected && !connectResult.userUrl) {
+    return connectResult;
+  }
+  if (connectResult.userUrl) {
+    options.onUserUrl?.(connectResult.userUrl);
+  }
+  const timeoutMs = options.timeoutMs ?? 3e5;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        walletProvider.removeListener(core.CIP0103_EVENTS.CONNECTED, onConnected);
+        reject(
+          new ProviderRpcError(
+            "Async connect timed out",
+            JSON_RPC_ERRORS.INVALID_INPUT,
+            { timeoutMs }
+          )
+        );
+      }
+    }, timeoutMs);
+    const onConnected = (result) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        walletProvider.removeListener(core.CIP0103_EVENTS.CONNECTED, onConnected);
+        resolve(result);
+      }
+    };
+    walletProvider.on(core.CIP0103_EVENTS.CONNECTED, onConnected);
+  });
+}
+var TERMINAL_TX_STATUSES = ["executed", "failed"];
+async function handleAsyncPrepareExecute(walletProvider, commandId, userUrl, options = {}) {
+  if (userUrl) {
+    options.onUserUrl?.(userUrl);
+  }
+  const timeoutMs = options.timeoutMs ?? 3e5;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        walletProvider.removeListener(core.CIP0103_EVENTS.TX_CHANGED, onTxChanged);
+        reject(
+          new ProviderRpcError(
+            "Async prepareExecute timed out",
+            JSON_RPC_ERRORS.INVALID_INPUT,
+            { commandId, timeoutMs }
+          )
+        );
+      }
+    }, timeoutMs);
+    const onTxChanged = (event) => {
+      if (event.commandId !== commandId) return;
+      if (TERMINAL_TX_STATUSES.includes(event.status)) {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          walletProvider.removeListener(
+            core.CIP0103_EVENTS.TX_CHANGED,
+            onTxChanged
+          );
+          if (event.status === "failed") {
+            reject(
+              new ProviderRpcError(
+                "Transaction failed",
+                JSON_RPC_ERRORS.TRANSACTION_REJECTED,
+                { commandId }
+              )
+            );
+          } else {
+            resolve(event);
+          }
+        }
+      }
+    };
+    walletProvider.on(core.CIP0103_EVENTS.TX_CHANGED, onTxChanged);
+  });
+}
+
+// src/provider.ts
+var PartyLayerProvider = class {
+  eventBus;
+  router;
+  options;
+  nativeProvider;
+  connected = false;
+  /** Event forwarders from the native provider, keyed by event name */
+  nativeForwarders = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.options = options;
+    this.eventBus = new CIP0103EventBus();
+    this.eventBus.setOwner(this);
+    this.router = new MethodRouter();
+    this.nativeProvider = options.walletProvider?.provider ?? null;
+    if (this.nativeProvider) {
+      this.router.setWalletProvider(this.nativeProvider);
+      this.forwardNativeEvents();
+    }
+    this.registerOrchestratedMethods();
+  }
+  // ─── CIP-0103 Provider Interface ─────────────────────────────────────────
+  async request(args) {
+    return this.router.route(args);
+  }
+  on(event, listener) {
+    this.eventBus.on(event, listener);
+    return this;
+  }
+  emit(event, ...args) {
+    return this.eventBus.emit(event, ...args);
+  }
+  removeListener(event, listenerToRemove) {
+    this.eventBus.removeListener(event, listenerToRemove);
+    return this;
+  }
+  // ─── Public Management ────────────────────────────────────────────────────
+  /** Whether the provider is currently in a connected state */
+  get isConnected() {
+    return this.connected;
+  }
+  /** Switch the underlying wallet provider (e.g. user selects a different wallet) */
+  setWalletProvider(discovered) {
+    this.unforwardNativeEvents();
+    this.nativeProvider = discovered.provider;
+    this.router.setWalletProvider(this.nativeProvider);
+    this.forwardNativeEvents();
+  }
+  /** Get the currently attached native provider (if any) */
+  getNativeProvider() {
+    return this.nativeProvider;
+  }
+  /** Tear down: unsubscribe all events and release the native provider */
+  destroy() {
+    this.unforwardNativeEvents();
+    this.eventBus.removeAllListeners();
+    this.nativeProvider = null;
+    this.router.setWalletProvider(null);
+    this.connected = false;
+  }
+  // ─── Orchestrated Method Overrides ────────────────────────────────────────
+  registerOrchestratedMethods() {
+    this.router.register(
+      "connect",
+      async (wp, params) => {
+        const result = await wp.request({
+          method: "connect",
+          params
+        });
+        if (result.userUrl && !result.isConnected) {
+          const final = await handleAsyncConnect(wp, result, {
+            timeoutMs: this.options.asyncTimeoutMs,
+            onUserUrl: this.options.onUserUrl
+          });
+          this.connected = final.isConnected;
+          this.emitStatusChanged();
+          return final;
+        }
+        this.connected = result.isConnected;
+        this.emitStatusChanged();
+        return result;
+      }
+    );
+    this.router.register("disconnect", async (wp, params) => {
+      await wp.request({ method: "disconnect", params });
+      this.connected = false;
+      this.emitStatusChanged();
+    });
+    this.router.register(
+      "isConnected",
+      async (wp, params) => {
+        if (!wp) {
+          return {
+            isConnected: false,
+            reason: "No wallet provider connected"
+          };
+        }
+        return wp.request({
+          method: "isConnected",
+          params
+        });
+      }
+    );
+    this.router.register("prepareExecute", async (wp, params) => {
+      return wp.request({ method: "prepareExecute", params });
+    });
+  }
+  // ─── Native Event Forwarding ──────────────────────────────────────────────
+  forwardNativeEvents() {
+    if (!this.nativeProvider) return;
+    const eventsToForward = [
+      core.CIP0103_EVENTS.STATUS_CHANGED,
+      core.CIP0103_EVENTS.ACCOUNTS_CHANGED,
+      core.CIP0103_EVENTS.TX_CHANGED,
+      core.CIP0103_EVENTS.CONNECTED
+    ];
+    for (const event of eventsToForward) {
+      const forwarder = (...args) => {
+        this.eventBus.emit(event, ...args);
+      };
+      this.nativeForwarders.set(event, forwarder);
+      this.nativeProvider.on(event, forwarder);
+    }
+  }
+  unforwardNativeEvents() {
+    if (!this.nativeProvider) return;
+    for (const [event, forwarder] of this.nativeForwarders) {
+      this.nativeProvider.removeListener(event, forwarder);
+    }
+    this.nativeForwarders.clear();
+  }
+  // ─── Helpers ──────────────────────────────────────────────────────────────
+  /** Emit statusChanged by querying the current wallet provider status */
+  async emitStatusChanged() {
+    if (!this.nativeProvider) return;
+    try {
+      const status = await this.nativeProvider.request({
+        method: "status"
+      });
+      this.eventBus.emit(core.CIP0103_EVENTS.STATUS_CHANGED, status);
+    } catch {
+    }
+  }
+};
+
+// src/network.ts
+var CANTON_NETWORKS = {
+  mainnet: "canton:da-mainnet",
+  testnet: "canton:da-testnet",
+  devnet: "canton:da-devnet",
+  local: "canton:da-local"
+};
+var CAIP2_TO_SHORT = Object.fromEntries(
+  Object.entries(CANTON_NETWORKS).map(([short, full]) => [full, short])
+);
+function toCAIP2Network(networkId) {
+  let result;
+  if (networkId.includes(":")) {
+    result = networkId;
+  } else {
+    const caip2 = CANTON_NETWORKS[networkId];
+    result = caip2 ?? `canton:${networkId}`;
+  }
+  if (!isValidCAIP2(result)) {
+    throw new Error(
+      `Invalid CAIP-2 network identifier: "${result}". Expected format: "namespace:reference"`
+    );
+  }
+  return { networkId: result };
+}
+function fromCAIP2Network(caip2) {
+  const short = CAIP2_TO_SHORT[caip2];
+  if (short) return short;
+  const colonIndex = caip2.indexOf(":");
+  return colonIndex >= 0 ? caip2.slice(colonIndex + 1) : caip2;
+}
+function isValidCAIP2(networkId) {
+  return /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$/.test(networkId);
+}
+
+// src/bridge.ts
+var PROVIDER_VERSION = "0.1.1" ;
+function createProviderBridge(client) {
+  const eventBus = new CIP0103EventBus();
+  const pendingEmitted = /* @__PURE__ */ new Set();
+  const bridge = {
+    async request(args) {
+      return handleRequest(client, args, eventBus, pendingEmitted);
+    },
+    on(event, listener) {
+      eventBus.on(event, listener);
+      return bridge;
+    },
+    emit(event, ...args) {
+      return eventBus.emit(event, ...args);
+    },
+    removeListener(event, listener) {
+      eventBus.removeListener(event, listener);
+      return bridge;
+    }
+  };
+  eventBus.setOwner(bridge);
+  wireEvents(client, eventBus, pendingEmitted);
+  return bridge;
+}
+async function handleRequest(client, args, eventBus, pendingEmitted) {
+  const { method, params } = args;
+  try {
+    switch (method) {
+      case "connect": {
+        await client.connect();
+        return {
+          isConnected: true
+        };
+      }
+      case "disconnect": {
+        await client.disconnect();
+        return void 0;
+      }
+      case "isConnected": {
+        const session = await client.getActiveSession();
+        return {
+          isConnected: session !== null,
+          reason: session ? void 0 : "No active session"
+        };
+      }
+      case "status": {
+        const session = await client.getActiveSession();
+        return {
+          connection: {
+            isConnected: session !== null
+          },
+          provider: {
+            id: "partylayer",
+            version: PROVIDER_VERSION,
+            providerType: "browser"
+          },
+          network: session ? toCAIP2Network(session.network) : void 0,
+          session: session ? {
+            accessToken: "",
+            userId: String(session.partyId)
+          } : void 0
+        };
+      }
+      case "getActiveNetwork": {
+        const session = await client.getActiveSession();
+        return toCAIP2Network(
+          session?.network ?? "devnet"
+        );
+      }
+      case "listAccounts": {
+        const session = await client.getActiveSession();
+        if (!session) return [];
+        return [
+          sessionToAccount(session)
+        ];
+      }
+      case "getPrimaryAccount": {
+        const session = await client.getActiveSession();
+        if (!session) throw disconnected("No active session");
+        return sessionToAccount(session);
+      }
+      case "signMessage": {
+        const p = normalizeParams(params);
+        const result = await client.signMessage({
+          message: String(p.message ?? ""),
+          nonce: p.nonce ? String(p.nonce) : void 0,
+          domain: p.domain ? String(p.domain) : void 0
+        });
+        return String(result.signature);
+      }
+      case "prepareExecute": {
+        const p = normalizeParams(params);
+        const cmdId = `cmd_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+        pendingEmitted.add(cmdId);
+        eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, {
+          status: "pending",
+          commandId: cmdId
+        });
+        try {
+          const signResult = await client.signTransaction({ tx: p });
+          const session = await client.getActiveSession();
+          const partyId = String(signResult.partyId ?? session?.partyId ?? "unknown");
+          eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, {
+            status: "signed",
+            commandId: cmdId,
+            payload: {
+              signature: String(signResult.transactionHash),
+              signedBy: partyId,
+              party: partyId
+            }
+          });
+          try {
+            const receipt = await client.submitTransaction({
+              signedTx: signResult.signedTx ?? signResult.transactionHash
+            });
+            pendingEmitted.delete(cmdId);
+            eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, {
+              status: "executed",
+              commandId: cmdId,
+              payload: {
+                updateId: receipt.updateId ?? receipt.commandId ?? String(receipt.transactionHash),
+                completionOffset: 0
+              }
+            });
+          } catch (submitErr) {
+            pendingEmitted.delete(cmdId);
+            eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, {
+              status: "failed",
+              commandId: cmdId
+            });
+            throw submitErr;
+          }
+        } catch (signErr) {
+          if (pendingEmitted.has(cmdId)) {
+            pendingEmitted.delete(cmdId);
+            eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, {
+              status: "failed",
+              commandId: cmdId
+            });
+          }
+          throw signErr;
+        }
+        return void 0;
+      }
+      case "ledgerApi": {
+        if (!client.ledgerApi) {
+          throw unsupportedMethod("ledgerApi");
+        }
+        const p = normalizeParams(params);
+        const result = await client.ledgerApi({
+          requestMethod: String(p.requestMethod ?? "GET"),
+          resource: String(p.resource ?? ""),
+          body: p.body ? String(p.body) : void 0
+        });
+        return result;
+      }
+      default:
+        throw unsupportedMethod(method);
+    }
+  } catch (err) {
+    throw toProviderRpcError(err);
+  }
+}
+function wireEvents(client, eventBus, pendingEmitted) {
+  client.on("session:connected", (event) => {
+    const e = event;
+    if (!e || typeof e !== "object" || !("session" in e)) return;
+    const session = e.session;
+    eventBus.emit(core.CIP0103_EVENTS.STATUS_CHANGED, {
+      connection: { isConnected: true },
+      provider: {
+        id: "partylayer",
+        version: PROVIDER_VERSION,
+        providerType: "browser"
+      },
+      network: toCAIP2Network(session.network),
+      session: {
+        accessToken: "",
+        userId: String(session.partyId)
+      }
+    });
+    eventBus.emit(core.CIP0103_EVENTS.ACCOUNTS_CHANGED, [
+      {
+        primary: true,
+        partyId: String(session.partyId),
+        status: "allocated",
+        hint: "",
+        publicKey: "",
+        namespace: "",
+        networkId: toCAIP2Network(session.network).networkId,
+        signingProviderId: ""
+      }
+    ]);
+    eventBus.emit(core.CIP0103_EVENTS.CONNECTED, {
+      isConnected: true
+    });
+  });
+  client.on("session:disconnected", () => {
+    eventBus.emit(core.CIP0103_EVENTS.STATUS_CHANGED, {
+      connection: { isConnected: false },
+      provider: {
+        id: "partylayer",
+        version: PROVIDER_VERSION,
+        providerType: "browser"
+      }
+    });
+  });
+  client.on("tx:status", (event) => {
+    const e = event;
+    if (!e || typeof e !== "object" || !("status" in e)) return;
+    const statusMap = {
+      pending: "pending",
+      submitted: "pending",
+      signed: "signed",
+      committed: "executed",
+      rejected: "failed",
+      failed: "failed"
+    };
+    const mappedStatus = statusMap[e.status] ?? "pending";
+    const commandId = String(e.txId);
+    if (mappedStatus === "pending" && pendingEmitted.has(commandId)) {
+      return;
+    }
+    if (mappedStatus === "executed" || mappedStatus === "failed") {
+      pendingEmitted.delete(commandId);
+    }
+    let txEvent;
+    switch (mappedStatus) {
+      case "signed":
+        txEvent = {
+          status: "signed",
+          commandId,
+          payload: {
+            signature: "",
+            signedBy: "",
+            party: ""
+          }
+        };
+        break;
+      case "executed": {
+        const raw = e.raw;
+        txEvent = {
+          status: "executed",
+          commandId,
+          payload: {
+            updateId: raw?.updateId ?? raw?.commandId ?? commandId,
+            completionOffset: 0
+          }
+        };
+        break;
+      }
+      case "failed":
+        txEvent = { status: "failed", commandId };
+        break;
+      default:
+        txEvent = { status: "pending", commandId };
+        break;
+    }
+    eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, txEvent);
+  });
+}
+function normalizeParams(params) {
+  if (!params) return {};
+  if (Array.isArray(params)) return params[0] ?? {};
+  return params;
+}
+function sessionToAccount(session) {
+  return {
+    primary: true,
+    partyId: String(session.partyId),
+    status: "allocated",
+    hint: "",
+    publicKey: "",
+    namespace: "",
+    networkId: toCAIP2Network(session.network).networkId,
+    signingProviderId: ""
+  };
+}
+
+// src/discovery.ts
+var KNOWN_INJECTION_PATHS = [
+  "canton",
+  "cantonWallet",
+  "consoleWallet",
+  "splice"
+];
+function isCIP0103Provider(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const p = obj;
+  return typeof p.request === "function" && typeof p.on === "function" && typeof p.emit === "function" && typeof p.removeListener === "function";
+}
+function discoverInjectedProviders() {
+  if (typeof window === "undefined") return [];
+  const discovered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const win = window;
+  for (const path of KNOWN_INJECTION_PATHS) {
+    const candidate = win[path];
+    if (candidate === void 0 || candidate === null) continue;
+    if (isCIP0103Provider(candidate) && !seen.has(candidate)) {
+      seen.add(candidate);
+      discovered.push({
+        id: path,
+        provider: candidate,
+        source: "injected"
+      });
+      continue;
+    }
+    if (typeof candidate === "object") {
+      for (const [key, value] of Object.entries(
+        candidate
+      )) {
+        if (isCIP0103Provider(value) && !seen.has(value)) {
+          seen.add(value);
+          discovered.push({
+            id: `${path}.${key}`,
+            provider: value,
+            source: "injected"
+          });
+        }
+      }
+    }
+  }
+  return discovered;
+}
+function waitForProvider(id, timeoutMs = 3e3) {
+  return new Promise((resolve) => {
+    const match = findById(id);
+    if (match) {
+      resolve(match);
+      return;
+    }
+    const start = Date.now();
+    const interval = setInterval(() => {
+      const match2 = findById(id);
+      if (match2) {
+        clearInterval(interval);
+        resolve(match2);
+        return;
+      }
+      if (Date.now() - start >= timeoutMs) {
+        clearInterval(interval);
+        resolve(null);
+      }
+    }, 100);
+  });
+}
+function findById(id) {
+  return discoverInjectedProviders().find(
+    (p) => p.id === id || p.id.endsWith(`.${id}`)
+  );
+}
+
+Object.defineProperty(exports, "CIP0103_EVENTS", {
+  enumerable: true,
+  get: function () { return core.CIP0103_EVENTS; }
+});
+Object.defineProperty(exports, "CIP0103_MANDATORY_METHODS", {
+  enumerable: true,
+  get: function () { return core.CIP0103_MANDATORY_METHODS; }
+});
+Object.defineProperty(exports, "CIP0103_METHODS", {
+  enumerable: true,
+  get: function () { return core.CIP0103_METHODS; }
+});
+exports.CANTON_NETWORKS = CANTON_NETWORKS;
+exports.CIP0103EventBus = CIP0103EventBus;
+exports.JSON_RPC_ERRORS = JSON_RPC_ERRORS;
+exports.MethodRouter = MethodRouter;
+exports.PartyLayerProvider = PartyLayerProvider;
+exports.ProviderRpcError = ProviderRpcError;
+exports.RPC_ERRORS = RPC_ERRORS;
+exports.chainDisconnected = chainDisconnected;
+exports.createProviderBridge = createProviderBridge;
+exports.disconnected = disconnected;
+exports.discoverInjectedProviders = discoverInjectedProviders;
+exports.fromCAIP2Network = fromCAIP2Network;
+exports.handleAsyncConnect = handleAsyncConnect;
+exports.handleAsyncPrepareExecute = handleAsyncPrepareExecute;
+exports.internalError = internalError;
+exports.invalidParams = invalidParams;
+exports.isCIP0103Provider = isCIP0103Provider;
+exports.isValidCAIP2 = isValidCAIP2;
+exports.methodNotFound = methodNotFound;
+exports.resourceNotFound = resourceNotFound;
+exports.resourceUnavailable = resourceUnavailable;
+exports.toCAIP2Network = toCAIP2Network;
+exports.toPartyLayerError = toPartyLayerError;
+exports.toProviderRpcError = toProviderRpcError;
+exports.transactionRejected = transactionRejected;
+exports.unauthorized = unauthorized;
+exports.unsupportedMethod = unsupportedMethod;
+exports.userRejected = userRejected;
+exports.waitForProvider = waitForProvider;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map