@bytezhang/ledger-adapter 0.0.18 → 0.0.21

package/dist/index.mjs

@@ -29,7 +29,7 @@ function isDeviceLockedError(err) {
   if (e.errorCode != null && LOCKED_ERROR_CODES.has(String(e.errorCode))) return true;
   if (e.statusCode != null && LOCKED_ERROR_CODES.has(String(e.statusCode))) return true;
   if (e._tag === "DeviceLockedError") return true;
-  if (typeof e.message === "string" && /locked/i.test(e.message)) return true;
+  if (typeof e.message === "string" && /locked|device exchange error/i.test(e.message)) return true;
   if (e.originalError != null && isDeviceLockedError(e.originalError)) return true;
   if (e.error != null && e._tag && isDeviceLockedError(e.error)) return true;
   return false;
@@ -65,7 +65,7 @@ function isDeviceDisconnectedError(err) {
   if (!err || typeof err !== "object") return false;
   const e = err;
   if (e._tag === "DeviceNotRecognizedError" || e._tag === "DeviceSessionNotFound") return true;
-  if (typeof e.message === "string" && /disconnected|not found|no device|unplugged|session.*not.*found/i.test(e.message)) return true;
+  if (typeof e.message === "string" && /disconnected|not found|no device|unplugged|session.*not.*found|timed out.*locked/i.test(e.message)) return true;
   return false;
 }
 function isTimeoutError(err) {
@@ -252,7 +252,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     );
   }
   getSupportedChains() {
-    return ["evm", "btc", "sol"];
+    return ["evm", "btc", "sol", "tron"];
   }
   on(event, listener) {
     this.emitter.on(event, listener);
@@ -502,16 +502,40 @@ var _LedgerAdapter = class _LedgerAdapter {
         "Ledger requires PSBT format for BTC transaction signing. Provide params.psbt."
       );
     }
-    return failure(
-      HardwareErrorCode2.MethodNotSupported,
-      "BTC transaction signing via PSBT is not yet implemented for Ledger."
-    );
+    try {
+      const accountPath = params.inputs?.[0]?.path ? params.inputs[0].path.split("/").slice(0, 3).join("/") : void 0;
+      const result = await this.connectorCall(connectId, "btcSignTransaction", {
+        psbt: params.psbt,
+        coin: params.coin,
+        path: accountPath
+      });
+      return success({
+        signatures: [],
+        serializedTx: result.signedPsbt,
+        signedPsbt: result.signedPsbt
+      });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
   }
-  async btcSignMessage(_connectId, _deviceId, _params) {
-    return failure(
-      HardwareErrorCode2.MethodNotSupported,
-      "BTC message signing is not yet supported on Ledger."
-    );
+  async btcSignMessage(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "btc")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
+    try {
+      const result = await this.connectorCall(connectId, "btcSignMessage", {
+        path: params.path,
+        message: params.message,
+        coin: params.coin
+      });
+      return success({
+        signature: result.signature,
+        address: result.address || ""
+      });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
   }
   // ---------------------------------------------------------------------------
   // Device fingerprint
@@ -574,18 +598,91 @@ var _LedgerAdapter = class _LedgerAdapter {
       return this.errorToFailure(err);
     }
   }
-  async solSignTransaction(_connectId, _deviceId, _params) {
-    return failure(
-      HardwareErrorCode2.MethodNotSupported,
-      "Solana transaction signing via Ledger is not yet implemented."
-    );
+  async solSignTransaction(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "sol")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
+    try {
+      const result = await this.connectorCall(connectId, "solSignTransaction", {
+        path: params.path,
+        serializedTx: params.serializedTx
+      });
+      return success({ signature: result.signature });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
   }
-  async solSignMessage(_connectId, _deviceId, _params) {
-    return failure(
-      HardwareErrorCode2.MethodNotSupported,
-      "Solana message signing via Ledger is not yet implemented."
+  async solSignMessage(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    if (!await this._verifyDeviceFingerprint(connectId, _deviceId, "sol")) {
+      return failure(HardwareErrorCode2.DeviceMismatch, "Wrong device connected");
+    }
+    try {
+      const result = await this.connectorCall(connectId, "solSignMessage", {
+        path: params.path,
+        message: params.message
+      });
+      return success({ signature: result.signature });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // TRON methods
+  // ---------------------------------------------------------------------------
+  async tronGetAddress(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    try {
+      const result = await this.connectorCall(connectId, "tronGetAddress", {
+        path: params.path,
+        showOnDevice: params.showOnDevice
+      });
+      return success({
+        address: result.address,
+        path: params.path
+      });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  async tronGetAddresses(connectId, deviceId, params, onProgress) {
+    return this.batchCall(
+      params,
+      (p) => this.tronGetAddress(connectId, deviceId, p),
+      onProgress
     );
   }
+  async tronSignTransaction(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    try {
+      if (!params.rawTxHex) {
+        return failure(
+          HardwareErrorCode2.InvalidParams,
+          "TRON signing requires a protobuf-encoded raw transaction hex (rawTxHex)."
+        );
+      }
+      const result = await this.connectorCall(connectId, "tronSignTransaction", {
+        path: params.path,
+        rawTxHex: params.rawTxHex
+      });
+      return success({ signature: result.signature });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  async tronSignMessage(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    try {
+      const result = await this.connectorCall(connectId, "tronSignMessage", {
+        path: params.path,
+        messageHex: params.message
+      });
+      return success({ signature: result.signature });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
   /**
    * Wait for user to connect and unlock device.
    * Emits 'ui-request' event via the adapter's own emitter.
@@ -1035,12 +1132,30 @@ var LedgerDeviceManager = class {
 };
 
 // src/signer/deviceActionToPromise.ts
-function deviceActionToPromise(action, onInteraction) {
+var DEFAULT_TIMEOUT_MS = 3e4;
+function deviceActionToPromise(action, onInteraction, timeoutMs = DEFAULT_TIMEOUT_MS) {
   return new Promise((resolve, reject) => {
     let settled = false;
     let sub;
+    let timer = null;
+    const resetTimer = () => {
+      if (timer) clearTimeout(timer);
+      if (timeoutMs > 0) {
+        timer = setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            sub?.unsubscribe();
+            reject(new Error("Device action timed out \u2014 device may be locked or disconnected"));
+          }
+        }, timeoutMs);
+      }
+    };
+    resetTimer();
+    console.log("[DMK-Observable] subscribing to action.observable...");
     sub = action.observable.subscribe({
       next: (state) => {
+        console.log("[DMK-Observable] next received");
+        resetTimer();
         console.log("[DMK-Observable] state:", JSON.stringify({
           status: state.status,
           interaction: state.intermediateValue?.requiredUserInteraction,
@@ -1051,11 +1166,13 @@ function deviceActionToPromise(action, onInteraction) {
         if (settled) return;
         if (state.status === "completed") {
           settled = true;
+          if (timer) clearTimeout(timer);
           onInteraction?.("interaction-complete");
           sub?.unsubscribe();
           resolve(state.output);
         } else if (state.status === "error") {
           settled = true;
+          if (timer) clearTimeout(timer);
           onInteraction?.("interaction-complete");
           sub?.unsubscribe();
           reject(state.error);
@@ -1071,6 +1188,7 @@ function deviceActionToPromise(action, onInteraction) {
       error: (err) => {
         if (!settled) {
           settled = true;
+          if (timer) clearTimeout(timer);
           sub?.unsubscribe();
           reject(err);
         }
@@ -1078,6 +1196,7 @@ function deviceActionToPromise(action, onInteraction) {
       complete: () => {
         if (!settled) {
           settled = true;
+          if (timer) clearTimeout(timer);
           reject(new Error("Device action completed without result"));
         }
       }
@@ -1094,6 +1213,7 @@ function hexToBytes(hex) {
   }
   return bytes;
 }
+var INTERACTIVE_TIMEOUT_MS = 5 * 6e4;
 var SignerEth = class {
   constructor(_sdk) {
     this._sdk = _sdk;
@@ -1101,22 +1221,25 @@ var SignerEth = class {
   async getAddress(derivationPath, options) {
     const checkOnDevice = options?.checkOnDevice ?? false;
     console.log("[DMK] getAddress \u2192 DMK:", { derivationPath, checkOnDevice });
+    console.log("[DMK] signer instance id:", this._instanceId ?? "none");
     const action = this._sdk.getAddress(derivationPath, {
       checkOnDevice
     });
-    return deviceActionToPromise(action, this.onInteraction);
+    console.log("[DMK] getAddress action created:", !!action, "hasObservable:", !!action?.observable);
+    const timeout = checkOnDevice ? INTERACTIVE_TIMEOUT_MS : void 0;
+    return deviceActionToPromise(action, this.onInteraction, timeout);
   }
   async signTransaction(derivationPath, serializedTxHex) {
     const action = this._sdk.signTransaction(derivationPath, hexToBytes(serializedTxHex));
-    return deviceActionToPromise(action, this.onInteraction);
+    return deviceActionToPromise(action, this.onInteraction, INTERACTIVE_TIMEOUT_MS);
   }
   async signMessage(derivationPath, message) {
     const action = this._sdk.signMessage(derivationPath, message);
-    return deviceActionToPromise(action, this.onInteraction);
+    return deviceActionToPromise(action, this.onInteraction, INTERACTIVE_TIMEOUT_MS);
   }
   async signTypedData(derivationPath, data) {
     const action = this._sdk.signTypedData(derivationPath, data);
-    return deviceActionToPromise(action, this.onInteraction);
+    return deviceActionToPromise(action, this.onInteraction, INTERACTIVE_TIMEOUT_MS);
   }
 };
 
@@ -1128,11 +1251,13 @@ var SignerManager = class _SignerManager {
     this._builderFn = builderFn ?? _SignerManager._defaultBuilder();
   }
   async getOrCreate(sessionId) {
-    let signer = this._cache.get(sessionId);
-    if (signer) return signer;
+    const hadCached = this._cache.has(sessionId);
+    this._cache.delete(sessionId);
+    console.log("[DMK] SignerManager.getOrCreate:", { sessionId, hadCached, creating: true });
     const builder = await this._builderFn({ dmk: this._dmk, sessionId });
     const sdkSigner = builder.build();
-    signer = new SignerEth(sdkSigner);
+    console.log("[DMK] SignerManager: new signer built");
+    const signer = new SignerEth(sdkSigner);
     this._cache.set(sessionId, signer);
     return signer;
   }
@@ -1155,6 +1280,7 @@ var SignerManager = class _SignerManager {
 };
 
 // src/signer/SignerBtc.ts
+var INTERACTIVE_TIMEOUT_MS2 = 5 * 6e4;
 var SignerBtc = class {
   constructor(_sdk) {
     this._sdk = _sdk;
@@ -1177,6 +1303,31 @@ var SignerBtc = class {
     const result = await deviceActionToPromise(action, this.onInteraction);
     return result.masterFingerprint;
   }
+  /**
+   * Sign a PSBT and return the array of partial signatures.
+   * The `wallet` param is a DefaultWallet or WalletPolicy instance.
+   * The `psbt` param can be a hex string, base64 string, or Uint8Array.
+   */
+  async signPsbt(wallet, psbt, options) {
+    const action = this._sdk.signPsbt(wallet, psbt, options);
+    return deviceActionToPromise(action, this.onInteraction, INTERACTIVE_TIMEOUT_MS2);
+  }
+  /**
+   * Sign a PSBT and return the fully extracted raw transaction as a hex string.
+   * Like signPsbt, but also finalises the PSBT and extracts the transaction.
+   */
+  async signTransaction(wallet, psbt, options) {
+    const action = this._sdk.signTransaction(wallet, psbt, options);
+    return deviceActionToPromise(action, this.onInteraction, INTERACTIVE_TIMEOUT_MS2);
+  }
+  /**
+   * Sign a message with the BTC app (BIP-137 / "Bitcoin Signed Message").
+   * Returns `{ r, s, v }` signature object.
+   */
+  async signMessage(derivationPath, message, options) {
+    const action = this._sdk.signMessage(derivationPath, message, options);
+    return deviceActionToPromise(action, this.onInteraction, INTERACTIVE_TIMEOUT_MS2);
+  }
 };
 
 // src/signer/SignerSol.ts
@@ -1209,6 +1360,200 @@ var SignerSol = class {
   }
 };
 
+// src/signer/SignerTron.ts
+var CLA = 224;
+var INS_ADDRESS = 2;
+var INS_SIGN = 4;
+var INS_SIGN_MESSAGE = 8;
+var CHUNK_SIZE = 250;
+function hexToBytes2(hex) {
+  const h = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(h.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(h.substring(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function splitPath(path) {
+  const p = path.startsWith("m/") ? path.slice(2) : path;
+  return p.split("/").map((component) => {
+    const hardened = component.endsWith("'");
+    const index = parseInt(hardened ? component.slice(0, -1) : component, 10);
+    return hardened ? index + 2147483648 : index;
+  });
+}
+function serializePath(path) {
+  const components = splitPath(path);
+  const buf = new Uint8Array(1 + components.length * 4);
+  buf[0] = components.length;
+  for (let i = 0; i < components.length; i++) {
+    const val = components[i];
+    const offset = 1 + i * 4;
+    buf[offset] = val >>> 24 & 255;
+    buf[offset + 1] = val >>> 16 & 255;
+    buf[offset + 2] = val >>> 8 & 255;
+    buf[offset + 3] = val & 255;
+  }
+  return buf;
+}
+function buildApdu(cla, ins, p1, p2, data) {
+  const dataLen = data?.length ?? 0;
+  const apdu = new Uint8Array(5 + dataLen);
+  apdu[0] = cla;
+  apdu[1] = ins;
+  apdu[2] = p1;
+  apdu[3] = p2;
+  apdu[4] = dataLen;
+  if (data && dataLen > 0) {
+    apdu.set(data, 5);
+  }
+  return apdu;
+}
+function checkStatusCode(statusCode, context) {
+  if (statusCode.length < 2) {
+    throw new Error(`${context}: invalid status code length`);
+  }
+  const sw = statusCode[0] << 8 | statusCode[1];
+  if (sw !== 36864) {
+    throw Object.assign(
+      new Error(`${context}: device returned error status 0x${sw.toString(16).padStart(4, "0")}`),
+      { statusCode: sw.toString(16), errorCode: sw.toString() }
+    );
+  }
+}
+var SignerTron = class {
+  constructor(_sendApdu) {
+    this._sendApdu = _sendApdu;
+  }
+  /**
+   * Get the TRON address at the given derivation path.
+   *
+   * APDU: CLA=0xE0, INS=0x02, P1=(showOnDevice?0x01:0x00), P2=0x00
+   * Data: pathCount(1) + paths(4 bytes each, big-endian, hardened bit)
+   * Response: pubKeyLen(1) + pubKey(pubKeyLen) + addrLen(1) + addr(addrLen, ASCII base58)
+   */
+  async getAddress(path, options) {
+    const showOnDevice = options?.checkOnDevice ?? false;
+    const pathData = serializePath(path);
+    const apdu = buildApdu(
+      CLA,
+      INS_ADDRESS,
+      showOnDevice ? 1 : 0,
+      0,
+      pathData
+    );
+    const response = await this._sendApdu(apdu);
+    checkStatusCode(response.statusCode, "tronGetAddress");
+    const data = response.data;
+    let offset = 0;
+    const pubKeyLen = data[offset];
+    offset += 1;
+    const publicKey = bytesToHex(data.slice(offset, offset + pubKeyLen));
+    offset += pubKeyLen;
+    const addrLen = data[offset];
+    offset += 1;
+    const addressBytes = data.slice(offset, offset + addrLen);
+    const address = new TextDecoder().decode(addressBytes);
+    return { publicKey, address };
+  }
+  /**
+   * Sign a TRON transaction (protobuf-encoded raw transaction).
+   *
+   * The transaction bytes are split into 250-byte chunks and sent sequentially.
+   * First chunk includes the serialized derivation path prefix.
+   *
+   * P1 flags:
+   *   0x10 = single chunk (entire tx fits in one APDU)
+   *   0x00 = first chunk of multi-chunk
+   *   0x80 = middle chunk (continuation)
+   *   0x90 = last chunk (final continuation)
+   *
+   * Returns: 65-byte signature as hex string (no 0x prefix).
+   */
+  async signTransaction(path, rawTxHex) {
+    const pathData = serializePath(path);
+    const txBytes = hexToBytes2(rawTxHex);
+    const firstChunkMaxTx = CHUNK_SIZE - pathData.length;
+    const txForFirst = txBytes.slice(0, firstChunkMaxTx);
+    const firstPayload = new Uint8Array(pathData.length + txForFirst.length);
+    firstPayload.set(pathData, 0);
+    firstPayload.set(txForFirst, pathData.length);
+    const remaining = txBytes.slice(firstChunkMaxTx);
+    const chunks = [];
+    let pos = 0;
+    while (pos < remaining.length) {
+      chunks.push(remaining.slice(pos, pos + CHUNK_SIZE));
+      pos += CHUNK_SIZE;
+    }
+    const totalChunks = 1 + chunks.length;
+    let response;
+    if (totalChunks === 1) {
+      const apdu = buildApdu(CLA, INS_SIGN, 16, 0, firstPayload);
+      response = await this._sendApdu(apdu);
+      checkStatusCode(response.statusCode, "tronSignTransaction");
+    } else {
+      const firstApdu = buildApdu(CLA, INS_SIGN, 0, 0, firstPayload);
+      response = await this._sendApdu(firstApdu);
+      checkStatusCode(response.statusCode, "tronSignTransaction (first)");
+      for (let i = 0; i < chunks.length; i++) {
+        const isLast = i === chunks.length - 1;
+        const p1 = isLast ? 144 : 128;
+        const apdu = buildApdu(CLA, INS_SIGN, p1, 0, chunks[i]);
+        response = await this._sendApdu(apdu);
+        checkStatusCode(response.statusCode, `tronSignTransaction (chunk ${i + 1})`);
+      }
+    }
+    return bytesToHex(response.data.slice(0, 65));
+  }
+  /**
+   * Sign a personal message with the TRON app.
+   *
+   * First chunk: pathCount(1) + paths(4 bytes BE) + messageLength(4 bytes BE) + message bytes
+   * Subsequent: continuation bytes
+   * P1: 0x00 = first, 0x80 = continuation
+   *
+   * Returns: 65-byte signature as hex string (no 0x prefix).
+   */
+  async signMessage(path, messageHex) {
+    const pathData = serializePath(path);
+    const messageBytes = hexToBytes2(messageHex);
+    const msgLenBuf = new Uint8Array(4);
+    const msgLen = messageBytes.length;
+    msgLenBuf[0] = msgLen >>> 24 & 255;
+    msgLenBuf[1] = msgLen >>> 16 & 255;
+    msgLenBuf[2] = msgLen >>> 8 & 255;
+    msgLenBuf[3] = msgLen & 255;
+    const header = new Uint8Array(pathData.length + 4);
+    header.set(pathData, 0);
+    header.set(msgLenBuf, pathData.length);
+    const firstChunkMaxMsg = CHUNK_SIZE - header.length;
+    const msgForFirst = messageBytes.slice(0, firstChunkMaxMsg);
+    const firstPayload = new Uint8Array(header.length + msgForFirst.length);
+    firstPayload.set(header, 0);
+    firstPayload.set(msgForFirst, header.length);
+    const remaining = messageBytes.slice(firstChunkMaxMsg);
+    const chunks = [];
+    let pos = 0;
+    while (pos < remaining.length) {
+      chunks.push(remaining.slice(pos, pos + CHUNK_SIZE));
+      pos += CHUNK_SIZE;
+    }
+    let response;
+    const firstApdu = buildApdu(CLA, INS_SIGN_MESSAGE, 0, 0, firstPayload);
+    response = await this._sendApdu(firstApdu);
+    checkStatusCode(response.statusCode, "tronSignMessage (first)");
+    for (let i = 0; i < chunks.length; i++) {
+      const apdu = buildApdu(CLA, INS_SIGN_MESSAGE, 128, 0, chunks[i]);
+      response = await this._sendApdu(apdu);
+      checkStatusCode(response.statusCode, `tronSignMessage (chunk ${i + 1})`);
+    }
+    return bytesToHex(response.data.slice(0, 65));
+  }
+};
+
 // src/connector/LedgerConnectorBase.ts
 function normalizePath(path) {
   return path.startsWith("m/") ? path.slice(2) : path;
@@ -1219,6 +1564,17 @@ function stripHex2(hex) {
 function padHex642(hex) {
   return `0x${stripHex2(hex).padStart(64, "0")}`;
 }
+function hexToBytes3(hex) {
+  const clean = stripHex2(hex);
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex2(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
 var LedgerConnectorBase = class {
   constructor(createTransport, options) {
     this._deviceManager = null;
@@ -1379,6 +1735,12 @@ var LedgerConnectorBase = class {
         return this._solSignTransaction(sessionId, params);
       case "solSignMessage":
         return this._solSignMessage(sessionId, params);
+      case "tronGetAddress":
+        return this._tronGetAddress(sessionId, params);
+      case "tronSignTransaction":
+        return this._tronSignTransaction(sessionId, params);
+      case "tronSignMessage":
+        return this._tronSignMessage(sessionId, params);
       default:
         throw new Error(`LedgerConnector: unknown method "${method}"`);
     }
@@ -1513,11 +1875,38 @@ var LedgerConnectorBase = class {
       throw this._wrapError(err);
     }
   }
-  async _btcSignTransaction(_sessionId, _params) {
-    throw new Error("LedgerConnector: btcSignTransaction is not yet implemented");
+  async _btcSignTransaction(sessionId, params) {
+    const btcSigner = await this._createBtcSigner(sessionId);
+    try {
+      const { DefaultWallet, DefaultDescriptorTemplate } = await import("@ledgerhq/device-signer-kit-bitcoin");
+      const path = normalizePath(params.path || "84'/0'/0'");
+      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 signedTxHex = await btcSigner.signTransaction(wallet, params.psbt);
+      return { signedPsbt: stripHex2(signedTxHex) };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
   }
-  async _btcSignMessage(_sessionId, _params) {
-    throw new Error("LedgerConnector: btcSignMessage is not yet implemented");
+  async _btcSignMessage(sessionId, params) {
+    const btcSigner = await this._createBtcSigner(sessionId);
+    const path = normalizePath(params.path);
+    try {
+      const result = await btcSigner.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: `${rHex}${sHex}${vHex}`, address: "" };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
   }
   async _btcGetMasterFingerprint(sessionId, params) {
     const btcSigner = await this._createBtcSigner(sessionId);
@@ -1548,11 +1937,67 @@ var LedgerConnectorBase = class {
       throw this._wrapError(err);
     }
   }
-  async _solSignTransaction(_sessionId, _params) {
-    throw new Error("LedgerConnector: solSignTransaction is not yet implemented");
+  async _solSignTransaction(sessionId, params) {
+    const solSigner = await this._createSolSigner(sessionId);
+    const path = normalizePath(params.path);
+    const txBytes = hexToBytes3(params.serializedTx);
+    try {
+      const result = await solSigner.signTransaction(path, txBytes);
+      return { signature: bytesToHex2(result) };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
   }
-  async _solSignMessage(_sessionId, _params) {
-    throw new Error("LedgerConnector: solSignMessage is not yet implemented");
+  async _solSignMessage(sessionId, params) {
+    const solSigner = await this._createSolSigner(sessionId);
+    const path = normalizePath(params.path);
+    const messageBytes = hexToBytes3(params.message);
+    try {
+      const result = await solSigner.signMessage(path, messageBytes);
+      return { signature: bytesToHex2(result) };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private -- TRON methods
+  // ---------------------------------------------------------------------------
+  async _tronGetAddress(sessionId, params) {
+    const tronSigner = await this._createTronSigner(sessionId);
+    const path = normalizePath(params.path);
+    try {
+      const result = await tronSigner.getAddress(path, {
+        checkOnDevice: params.showOnDevice ?? false
+      });
+      return { address: result.address, publicKey: result.publicKey, path: params.path };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
+  }
+  async _tronSignTransaction(sessionId, params) {
+    const tronSigner = await this._createTronSigner(sessionId);
+    const path = normalizePath(params.path);
+    try {
+      const signature = await tronSigner.signTransaction(path, params.rawTxHex);
+      return { signature };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
+  }
+  async _tronSignMessage(sessionId, params) {
+    const tronSigner = await this._createTronSigner(sessionId);
+    const path = normalizePath(params.path);
+    try {
+      const signature = await tronSigner.signMessage(path, params.messageHex);
+      return { signature };
+    } catch (err) {
+      this._invalidateSession(sessionId);
+      throw this._wrapError(err);
+    }
   }
   // ---------------------------------------------------------------------------
   // Private -- DMK / Manager lifecycle
@@ -1605,17 +2050,32 @@ var LedgerConnectorBase = class {
       dmk,
       sessionId
     }).build();
-    return new SignerBtc(sdkSigner);
+    const signer = new SignerBtc(sdkSigner);
+    signer.onInteraction = (interaction) => {
+      this._emit("ui-event", {
+        type: interaction,
+        payload: { sessionId }
+      });
+    };
+    return signer;
   }
   async _createSolSigner(sessionId) {
     const dmk = await this._getOrCreateDmk();
-    const { SignerSolanaBuilder } = await import("@ledgerhq/device-signer-kit-solana/lib/cjs/index.js");
+    const { SignerSolanaBuilder } = await import("@ledgerhq/device-signer-kit-solana");
     const sdkSigner = new SignerSolanaBuilder({
       dmk,
       sessionId
     }).build();
     return new SignerSol(sdkSigner);
   }
+  async _createTronSigner(sessionId) {
+    const dmk = await this._getOrCreateDmk();
+    const sendApdu = async (rawApdu) => {
+      const response = await dmk.sendApdu({ sessionId, apdu: rawApdu });
+      return response;
+    };
+    return new SignerTron(sendApdu);
+  }
   _invalidateSession(sessionId) {
     this._signerManager?.invalidate(sessionId);
   }
@@ -1752,6 +2212,7 @@ export {
   SignerEth,
   SignerManager,
   SignerSol,
+  SignerTron,
   clearRegistry,
   deviceActionToPromise,
   getTransportProvider,