@bytezhang/ledger-adapter 0.0.9 → 0.0.11

package/dist/index.js

@@ -32,6 +32,7 @@ var index_exports = {};
 __export(index_exports, {
   AppManager: () => AppManager,
   LedgerAdapter: () => LedgerAdapter,
+  LedgerConnectorBase: () => LedgerConnectorBase,
   LedgerDeviceManager: () => LedgerDeviceManager,
   SignerBtc: () => SignerBtc,
   SignerEth: () => SignerEth,
@@ -1221,6 +1222,445 @@ var SignerSol = class {
   }
 };
 
+// src/connector/LedgerConnectorBase.ts
+function normalizePath(path) {
+  return path.startsWith("m/") ? path.slice(2) : path;
+}
+function stripHex2(hex) {
+  return hex.startsWith("0x") ? hex.slice(2) : hex;
+}
+function padHex642(hex) {
+  return `0x${stripHex2(hex).padStart(64, "0")}`;
+}
+var LedgerConnectorBase = class {
+  constructor(createTransport, options) {
+    this._deviceManager = null;
+    this._signerManager = null;
+    this._dmk = null;
+    this._eventHandlers = /* @__PURE__ */ new Map();
+    this._createTransport = createTransport;
+    this._connectionType = options?.connectionType ?? "usb";
+    this._providedDmk = options?.dmk;
+    if (this._providedDmk) {
+      this._initManagers(this._providedDmk);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Protected — hooks for subclasses
+  // ---------------------------------------------------------------------------
+  /**
+   * Resolve the connectId for a discovered device descriptor.
+   * Default: use the DMK path (ephemeral UUID).
+   * Override in subclasses to extract stable identifiers (e.g. BLE hex ID).
+   */
+  _resolveConnectId(descriptor) {
+    return descriptor.path;
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Device discovery
+  // ---------------------------------------------------------------------------
+  async searchDevices() {
+    const dm = await this._getDeviceManager();
+    let descriptors = await dm.enumerate();
+    if (descriptors.length === 0) {
+      try {
+        await dm.requestDevice();
+      } catch {
+      }
+      descriptors = await dm.enumerate();
+    }
+    const result = descriptors.map((d) => {
+      const connectId = this._resolveConnectId(d);
+      return {
+        connectId,
+        deviceId: d.path,
+        name: d.name || d.type || "Ledger",
+        model: d.type
+      };
+    });
+    return result;
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Connection
+  // ---------------------------------------------------------------------------
+  async connect(deviceId) {
+    const dm = await this._getDeviceManager();
+    await this.searchDevices();
+    let resolvedDeviceId = deviceId;
+    if (!resolvedDeviceId) {
+      const descriptors = await dm.enumerate();
+      if (descriptors.length === 0) {
+        throw new Error(
+          `No Ledger device found. Make sure the device is connected${this._connectionType === "ble" ? " nearby with Bluetooth enabled" : " via USB"} and unlocked.`
+        );
+      }
+      resolvedDeviceId = descriptors[0].path;
+    }
+    try {
+      const sessionId = await dm.connect(resolvedDeviceId);
+      const session = {
+        sessionId,
+        deviceInfo: {
+          vendor: "ledger",
+          model: "unknown",
+          firmwareVersion: "unknown",
+          deviceId: resolvedDeviceId,
+          connectId: resolvedDeviceId,
+          connectionType: this._connectionType,
+          capabilities: {
+            persistentDeviceIdentity: false
+          }
+        }
+      };
+      this._emit("device-connect", {
+        device: {
+          connectId: resolvedDeviceId,
+          deviceId: resolvedDeviceId,
+          name: "Ledger"
+        }
+      });
+      return session;
+    } catch (err) {
+      this._resetManagers();
+      const dm2 = await this._getDeviceManager();
+      await this.searchDevices();
+      const descriptors = await dm2.enumerate();
+      const retryId = deviceId ? descriptors.find((d) => d.path === deviceId)?.path : descriptors[0]?.path;
+      if (!retryId) {
+        throw new Error(
+          `No Ledger device found after retry. Make sure the device is connected${this._connectionType === "ble" ? " nearby with Bluetooth enabled" : " via USB"} and unlocked.`
+        );
+      }
+      const sessionId = await dm2.connect(retryId);
+      const session = {
+        sessionId,
+        deviceInfo: {
+          vendor: "ledger",
+          model: "unknown",
+          firmwareVersion: "unknown",
+          deviceId: retryId,
+          connectId: retryId,
+          connectionType: this._connectionType
+        }
+      };
+      this._emit("device-connect", {
+        device: {
+          connectId: retryId,
+          deviceId: retryId,
+          name: "Ledger"
+        }
+      });
+      return session;
+    }
+  }
+  async disconnect(sessionId) {
+    if (!this._deviceManager) return;
+    const deviceId = this._deviceManager.getDeviceId(sessionId);
+    this._signerManager?.invalidate(sessionId);
+    await this._deviceManager.disconnect(sessionId);
+    if (deviceId) {
+      this._emit("device-disconnect", { connectId: deviceId });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Method dispatch
+  // ---------------------------------------------------------------------------
+  async call(sessionId, method, params) {
+    switch (method) {
+      case "evmGetAddress":
+        return this._evmGetAddress(sessionId, params);
+      case "evmSignTransaction":
+        return this._evmSignTransaction(sessionId, params);
+      case "evmSignMessage":
+        return this._evmSignMessage(sessionId, params);
+      case "evmSignTypedData":
+        return this._evmSignTypedData(sessionId, params);
+      case "btcGetAddress":
+        return this._btcGetAddress(sessionId, params);
+      case "btcGetPublicKey":
+        return this._btcGetPublicKey(sessionId, params);
+      case "btcSignTransaction":
+        return this._btcSignTransaction(sessionId, params);
+      case "btcSignMessage":
+        return this._btcSignMessage(sessionId, params);
+      case "btcGetMasterFingerprint":
+        return this._btcGetMasterFingerprint(sessionId, params);
+      case "solGetAddress":
+        return this._solGetAddress(sessionId, params);
+      case "solSignTransaction":
+        return this._solSignTransaction(sessionId, params);
+      case "solSignMessage":
+        return this._solSignMessage(sessionId, params);
+      default:
+        throw new Error(`LedgerConnector: unknown method "${method}"`);
+    }
+  }
+  async cancel(_sessionId) {
+  }
+  uiResponse(_response) {
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Events
+  // ---------------------------------------------------------------------------
+  on(event, handler) {
+    if (!this._eventHandlers.has(event)) {
+      this._eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this._eventHandlers.get(event).add(handler);
+  }
+  off(event, handler) {
+    this._eventHandlers.get(event)?.delete(handler);
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Reset
+  // ---------------------------------------------------------------------------
+  reset() {
+    this._resetManagers();
+  }
+  // ---------------------------------------------------------------------------
+  // Private -- EVM methods
+  // ---------------------------------------------------------------------------
+  async _evmGetAddress(sessionId, params) {
+    const signer = await this._getEthSigner(sessionId);
+    const path = normalizePath(params.path);
+    try {
+      const result = await signer.getAddress(path, {
+        checkOnDevice: params.showOnDevice ?? false
+      });
+      return { address: result.address, publicKey: result.publicKey };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
+  }
+  async _evmSignTransaction(sessionId, params) {
+    const signer = await this._getEthSigner(sessionId);
+    const path = normalizePath(params.path);
+    try {
+      const result = await signer.signTransaction(
+        path,
+        params.serializedTx
+      );
+      return {
+        v: `0x${result.v.toString(16)}`,
+        r: padHex642(result.r),
+        s: padHex642(result.s)
+      };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
+  }
+  async _evmSignMessage(sessionId, params) {
+    const signer = await this._getEthSigner(sessionId);
+    const path = normalizePath(params.path);
+    try {
+      const result = await signer.signMessage(
+        path,
+        params.message
+      );
+      const rHex = stripHex2(result.r).padStart(64, "0");
+      const sHex = stripHex2(result.s).padStart(64, "0");
+      const vHex = result.v.toString(16).padStart(2, "0");
+      return { signature: `0x${rHex}${sHex}${vHex}` };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
+  }
+  async _evmSignTypedData(sessionId, params) {
+    const signer = await this._getEthSigner(sessionId);
+    const path = normalizePath(params.path);
+    try {
+      const result = await signer.signTypedData(
+        path,
+        params.data
+      );
+      const rHex = stripHex2(result.r).padStart(64, "0");
+      const sHex = stripHex2(result.s).padStart(64, "0");
+      const vHex = result.v.toString(16).padStart(2, "0");
+      return { signature: `0x${rHex}${sHex}${vHex}` };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private -- BTC methods
+  // ---------------------------------------------------------------------------
+  async _btcGetAddress(sessionId, params) {
+    const btcSigner = await this._createBtcSigner(sessionId);
+    const path = normalizePath(params.path);
+    try {
+      const { DefaultWallet, DefaultDescriptorTemplate } = await import("@ledgerhq/device-signer-kit-bitcoin");
+      const purpose = path.split("/")[0]?.replace("'", "");
+      let template = DefaultDescriptorTemplate.NATIVE_SEGWIT;
+      if (purpose === "44") template = DefaultDescriptorTemplate.LEGACY;
+      else if (purpose === "49")
+        template = DefaultDescriptorTemplate.NESTED_SEGWIT;
+      else if (purpose === "86") template = DefaultDescriptorTemplate.TAPROOT;
+      const wallet = new DefaultWallet(path, template);
+      const result = await btcSigner.getWalletAddress(wallet, 0, {
+        checkOnDevice: params.showOnDevice ?? false,
+        change: false
+      });
+      return { address: result.address, path: params.path };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
+  }
+  async _btcGetPublicKey(sessionId, params) {
+    const btcSigner = await this._createBtcSigner(sessionId);
+    const path = normalizePath(params.path);
+    try {
+      const xpub = await btcSigner.getExtendedPublicKey(path, {
+        checkOnDevice: params.showOnDevice ?? false
+      });
+      return { xpub, path: params.path };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
+  }
+  async _btcSignTransaction(_sessionId, _params) {
+    throw new Error("LedgerConnector: btcSignTransaction is not yet implemented");
+  }
+  async _btcSignMessage(_sessionId, _params) {
+    throw new Error("LedgerConnector: btcSignMessage is not yet implemented");
+  }
+  async _btcGetMasterFingerprint(sessionId, params) {
+    const btcSigner = await this._createBtcSigner(sessionId);
+    try {
+      const fingerprint = await btcSigner.getMasterFingerprint({
+        skipOpenApp: params?.skipOpenApp
+      });
+      const hex = Array.from(fingerprint).map((b) => b.toString(16).padStart(2, "0")).join("");
+      return { masterFingerprint: hex };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private -- SOL methods
+  // ---------------------------------------------------------------------------
+  async _solGetAddress(sessionId, params) {
+    const solSigner = await this._createSolSigner(sessionId);
+    const path = normalizePath(params.path);
+    try {
+      const publicKey = await solSigner.getAddress(path, {
+        checkOnDevice: params.showOnDevice ?? false
+      });
+      return { address: publicKey, path: params.path };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
+  }
+  async _solSignTransaction(_sessionId, _params) {
+    throw new Error("LedgerConnector: solSignTransaction is not yet implemented");
+  }
+  async _solSignMessage(_sessionId, _params) {
+    throw new Error("LedgerConnector: solSignMessage is not yet implemented");
+  }
+  // ---------------------------------------------------------------------------
+  // Private -- DMK / Manager lifecycle
+  // ---------------------------------------------------------------------------
+  /**
+   * Lazily create or return the DMK instance.
+   * If a DMK was provided via constructor, it is used directly.
+   * Otherwise, one is created via the transport factory.
+   */
+  async _getOrCreateDmk() {
+    if (this._dmk) return this._dmk;
+    if (this._providedDmk) {
+      this._dmk = this._providedDmk;
+      return this._dmk;
+    }
+    const { DeviceManagementKitBuilder } = await import("@ledgerhq/device-management-kit");
+    const transportFactory = await this._createTransport();
+    this._dmk = new DeviceManagementKitBuilder().addTransport(transportFactory).build();
+    return this._dmk;
+  }
+  _initManagers(dmk) {
+    this._dmk = dmk;
+    this._deviceManager = new LedgerDeviceManager(dmk);
+    this._signerManager = new SignerManager(dmk);
+  }
+  async _getDeviceManager() {
+    if (this._deviceManager) return this._deviceManager;
+    const dmk = await this._getOrCreateDmk();
+    this._initManagers(dmk);
+    return this._deviceManager;
+  }
+  async _getEthSigner(sessionId) {
+    if (!this._signerManager) {
+      const dmk = await this._getOrCreateDmk();
+      this._initManagers(dmk);
+    }
+    const signer = await this._signerManager.getOrCreate(sessionId);
+    signer.onInteraction = (interaction) => {
+      this._emit("ui-event", {
+        type: interaction,
+        payload: { sessionId }
+      });
+    };
+    return signer;
+  }
+  async _createBtcSigner(sessionId) {
+    const dmk = await this._getOrCreateDmk();
+    const { SignerBtcBuilder } = await import("@ledgerhq/device-signer-kit-bitcoin");
+    const sdkSigner = new SignerBtcBuilder({
+      dmk,
+      sessionId
+    }).build();
+    return new SignerBtc(sdkSigner);
+  }
+  async _createSolSigner(sessionId) {
+    const dmk = await this._getOrCreateDmk();
+    const { SignerSolanaBuilder } = await import("@ledgerhq/device-signer-kit-solana");
+    const sdkSigner = new SignerSolanaBuilder({
+      dmk,
+      sessionId
+    }).build();
+    return new SignerSol(sdkSigner);
+  }
+  _invalidateSession(sessionId) {
+    this._signerManager?.invalidate(sessionId);
+  }
+  _resetManagers() {
+    this._signerManager?.clearAll();
+    this._deviceManager?.dispose();
+    this._deviceManager = null;
+    this._signerManager = null;
+    this._dmk = null;
+  }
+  // ---------------------------------------------------------------------------
+  // Private -- Events
+  // ---------------------------------------------------------------------------
+  _emit(event, data) {
+    const handlers = this._eventHandlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(data);
+        } catch {
+        }
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private -- Error handling
+  // ---------------------------------------------------------------------------
+  _wrapError(err) {
+    const mapped = mapLedgerError(err);
+    const error = new Error(mapped.message);
+    error.code = mapped.code;
+    return error;
+  }
+};
+
 // src/transport/registry.ts
 var registry = /* @__PURE__ */ new Map();
 function normalizeType(type) {
@@ -1340,6 +1780,7 @@ var AppManager = class {
 0 && (module.exports = {
   AppManager,
   LedgerAdapter,
+  LedgerConnectorBase,
   LedgerDeviceManager,
   SignerBtc,
   SignerEth,