@onekeyfe/hwk-trezor-core 1.2.10 → 1.2.11-alpha.1

package/dist/index.mjs

@@ -11759,6 +11759,22 @@ function shouldMarkThpModuleHandled(entry) {
 
 // src/index.ts
 init_buffer();
+function trackTransportFailure() {
+  let failure;
+  return {
+    run: async (io) => {
+      try {
+        return await io();
+      } catch (error2) {
+        failure ??= { error: error2 };
+        throw error2;
+      }
+    },
+    rethrow: () => {
+      if (failure) throw failure.error;
+    }
+  };
+}
 var unwrapTransportAbortSignal = (options) => {
   if (!options) return void 0;
   if ("addEventListener" in options && typeof options.addEventListener === "function") {
@@ -11816,20 +11832,26 @@ var TrezorCore = class {
     });
     if (this.protocol.name === "v2") {
       const previousNonce = thpState?.sendNonce;
+      const transportFailure = trackTransportFailure();
       const response = await callThpMessage({
         thpState,
         chunks,
         apiWrite: async (chunk, options2) => {
-          await this.transport.write(chunk, unwrapTransportAbortSignal(options2));
+          await transportFailure.run(
+            () => this.transport.write(chunk, unwrapTransportAbortSignal(options2))
+          );
           return { success: true, payload: void 0 };
         },
         apiRead: async (options2) => {
-          const payload = await this.transport.read(unwrapTransportAbortSignal(options2));
+          const payload = await transportFailure.run(
+            () => this.transport.read(unwrapTransportAbortSignal(options2))
+          );
           return { success: true, payload: toRuntimeBuffer(payload) };
         },
         signal: options.signal
       });
       if (!response.success) {
+        transportFailure.rethrow();
         throw new Error(response.error.message ?? response.error.code);
       }
       if (previousNonce === thpState?.sendNonce) {
@@ -11866,14 +11888,16 @@ var TrezorCore = class {
     await this.writeChunks(chunks, options.signal);
   }
   async receive(options = {}) {
+    const transportFailure = trackTransportFailure();
     const response = await receiveAndParse(async () => {
-      const payload = await this.transport.read(options.signal);
+      const payload = await transportFailure.run(() => this.transport.read(options.signal));
       return {
         success: true,
         payload: toRuntimeBuffer(payload)
       };
     }, this.protocol);
     if (!response.success) {
+      transportFailure.rethrow();
       throw new TrezorProtocolError(response.error.code, response.error.message);
     }
     if (isFailureResponse(response.payload)) {
@@ -11928,16 +11952,17 @@ var TrezorThpProtocol = class {
     }
     const previousNonce = this.thpState.sendNonce;
     const chunk = toRuntimeBuffer(this.encode(params));
+    const transportFailure = trackTransportFailure();
     const result = await callThpMessage({
       thpState: this.thpState,
       chunks: [chunk],
       skipAck: params.skipAck,
       apiWrite: async (data) => {
-        await transport.write?.(connectId, Uint8Array.from(data));
+        await transportFailure.run(async () => transport.write?.(connectId, Uint8Array.from(data)));
         return { success: true, payload: void 0 };
       },
       apiRead: async () => {
-        const data = await transport.read?.(connectId);
+        const data = await transportFailure.run(async () => transport.read?.(connectId));
         if (!data) {
           return {
             success: false,
@@ -11948,6 +11973,7 @@ var TrezorThpProtocol = class {
       }
     });
     if (!result.success) {
+      transportFailure.rethrow();
       throw new Error(result.error.message ?? result.error.code);
     }
     if (previousNonce === this.thpState.sendNonce) {