@buildonspark/spark-sdk 0.3.7 → 0.3.9

package/dist/{chunk-J2P3KTQP.js → chunk-4YFT7DAE.js}

@@ -2,7 +2,7 @@ import {
   Network,
   TransferStatus,
   TransferType
-} from "./chunk-IC4IUEOS.js";
+} from "./chunk-YEBEN7XD.js";
 
 // src/types/sdk-types.ts
 import { bytesToHex } from "@noble/curves/utils";

package/dist/{chunk-XWLR6G5C.js → chunk-JLF6WJ7K.js}

@@ -5,7 +5,7 @@ import {
   Timestamp,
   networkFromJSON,
   networkToJSON
-} from "./chunk-IC4IUEOS.js";
+} from "./chunk-YEBEN7XD.js";
 
 // src/proto/spark_token.ts
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";

package/dist/{chunk-UYTT3C6H.js → chunk-MFCM6GUD.js}

@@ -3,10 +3,10 @@ import {
   NetworkError,
   SparkWallet,
   clientEnv
-} from "./chunk-KDEVNW7C.js";
+} from "./chunk-O4C4HGQL.js";
 import {
   Empty
-} from "./chunk-IC4IUEOS.js";
+} from "./chunk-YEBEN7XD.js";
 
 // src/services/connection/connection.node.ts
 import {
@@ -19,66 +19,6 @@ import { Metadata } from "nice-grpc-common";
 
 // src/proto/mock.ts
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
-function interruptTransferRequest_InterruptTransferActionFromJSON(object) {
-  switch (object) {
-    case 0:
-    case "NONE":
-      return 0 /* NONE */;
-    case 1:
-    case "INTERRUPT":
-      return 1 /* INTERRUPT */;
-    case 2:
-    case "RESUME":
-      return 2 /* RESUME */;
-    case -1:
-    case "UNRECOGNIZED":
-    default:
-      return -1 /* UNRECOGNIZED */;
-  }
-}
-function interruptTransferRequest_InterruptTransferActionToJSON(object) {
-  switch (object) {
-    case 0 /* NONE */:
-      return "NONE";
-    case 1 /* INTERRUPT */:
-      return "INTERRUPT";
-    case 2 /* RESUME */:
-      return "RESUME";
-    case -1 /* UNRECOGNIZED */:
-    default:
-      return "UNRECOGNIZED";
-  }
-}
-function interruptCoopExitRequest_InterruptCoopExitActionFromJSON(object) {
-  switch (object) {
-    case 0:
-    case "NONE":
-      return 0 /* NONE */;
-    case 1:
-    case "INTERRUPT":
-      return 1 /* INTERRUPT */;
-    case 2:
-    case "RESUME":
-      return 2 /* RESUME */;
-    case -1:
-    case "UNRECOGNIZED":
-    default:
-      return -1 /* UNRECOGNIZED */;
-  }
-}
-function interruptCoopExitRequest_InterruptCoopExitActionToJSON(object) {
-  switch (object) {
-    case 0 /* NONE */:
-      return "NONE";
-    case 1 /* INTERRUPT */:
-      return "INTERRUPT";
-    case 2 /* RESUME */:
-      return "RESUME";
-    case -1 /* UNRECOGNIZED */:
-    default:
-      return "UNRECOGNIZED";
-  }
-}
 function createBaseCleanUpPreimageShareRequest() {
   return { paymentHash: new Uint8Array(0) };
 }
@@ -130,59 +70,6 @@ var CleanUpPreimageShareRequest = {
     return message;
   }
 };
-function createBaseInterruptTransferRequest() {
-  return { action: 0 };
-}
-var InterruptTransferRequest = {
-  encode(message, writer = new BinaryWriter()) {
-    if (message.action !== 0) {
-      writer.uint32(8).int32(message.action);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    const end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseInterruptTransferRequest();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 8) {
-            break;
-          }
-          message.action = reader.int32();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      action: isSet(object.action) ? interruptTransferRequest_InterruptTransferActionFromJSON(object.action) : 0
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.action !== 0) {
-      obj.action = interruptTransferRequest_InterruptTransferActionToJSON(message.action);
-    }
-    return obj;
-  },
-  create(base) {
-    return InterruptTransferRequest.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseInterruptTransferRequest();
-    message.action = object.action ?? 0;
-    return message;
-  }
-};
 function createBaseUpdateNodesStatusRequest() {
   return { nodeIds: [], status: "" };
 }
@@ -302,74 +189,6 @@ var TriggerTaskRequest = {
     return message;
   }
 };
-function createBaseInterruptCoopExitRequest() {
-  return { action: 0, targetOperator: "" };
-}
-var InterruptCoopExitRequest = {
-  encode(message, writer = new BinaryWriter()) {
-    if (message.action !== 0) {
-      writer.uint32(8).int32(message.action);
-    }
-    if (message.targetOperator !== "") {
-      writer.uint32(18).string(message.targetOperator);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    const end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseInterruptCoopExitRequest();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 8) {
-            break;
-          }
-          message.action = reader.int32();
-          continue;
-        }
-        case 2: {
-          if (tag !== 18) {
-            break;
-          }
-          message.targetOperator = reader.string();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      action: isSet(object.action) ? interruptCoopExitRequest_InterruptCoopExitActionFromJSON(object.action) : 0,
-      targetOperator: isSet(object.targetOperator) ? globalThis.String(object.targetOperator) : ""
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.action !== 0) {
-      obj.action = interruptCoopExitRequest_InterruptCoopExitActionToJSON(message.action);
-    }
-    if (message.targetOperator !== "") {
-      obj.targetOperator = message.targetOperator;
-    }
-    return obj;
-  },
-  create(base) {
-    return InterruptCoopExitRequest.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseInterruptCoopExitRequest();
-    message.action = object.action ?? 0;
-    message.targetOperator = object.targetOperator ?? "";
-    return message;
-  }
-};
 var MockServiceDefinition = {
   name: "MockService",
   fullName: "mock.MockService",
@@ -382,22 +201,6 @@ var MockServiceDefinition = {
       responseStream: false,
       options: {}
     },
-    interrupt_transfer: {
-      name: "interrupt_transfer",
-      requestType: InterruptTransferRequest,
-      requestStream: false,
-      responseType: Empty,
-      responseStream: false,
-      options: {}
-    },
-    interrupt_coop_exit: {
-      name: "interrupt_coop_exit",
-      requestType: InterruptCoopExitRequest,
-      requestStream: false,
-      responseType: Empty,
-      responseStream: false,
-      options: {}
-    },
     update_nodes_status: {
       name: "update_nodes_status",
       requestType: UpdateNodesStatusRequest,
@@ -449,19 +252,27 @@ import { openTelemetryClientMiddleware } from "nice-grpc-opentelemetry";
 import { retryMiddleware } from "nice-grpc-client-middleware-retry";
 import fs from "fs";
 var ConnectionManagerNodeJS = class extends ConnectionManager {
+  certPath = null;
   constructor(config) {
     super(config);
   }
   async createMockClient(address) {
-    const channel = await this.createChannelWithTLS(address);
+    const key = this.makeChannelKey(address, false);
+    const channel = await ConnectionManager.acquireChannel(
+      key,
+      () => this.createChannelWithTLS(address, false)
+    );
     const client = createClient(MockServiceDefinition, channel);
-    return { ...client, close: () => channel.close() };
+    return {
+      ...client,
+      close: () => ConnectionManager.releaseChannel(key)
+    };
   }
-  async createChannelWithTLS(address, certPath) {
+  async createChannelWithTLS(address, isStreamClientType = false) {
     try {
-      if (certPath) {
+      if (this.certPath) {
         try {
-          const cert = fs.readFileSync(certPath);
+          const cert = fs.readFileSync(this.certPath);
           return createChannel(address, ChannelCredentials.createSsl(cert));
         } catch (error) {
           console.error("Error reading certificate:", error);
@@ -473,12 +284,13 @@ var ConnectionManagerNodeJS = class extends ConnectionManager {
           );
         }
       } else {
-        return createChannel(
+        const ch = createChannel(
           address,
           ChannelCredentials.createSsl(null, null, null, {
             rejectUnauthorized: false
           })
         );
+        return ch;
       }
     } catch (error) {
       console.error("Channel creation error:", error);
@@ -506,19 +318,17 @@ var ConnectionManagerNodeJS = class extends ConnectionManager {
       });
     }.bind(this);
   }
-  createMiddleware(address, initialAuthToken) {
+  createMiddleware(address) {
     return async function* (call, options) {
       const metadata = Metadata(options.metadata).set(
         "X-Client-Env",
         clientEnv
       );
       try {
+        const token = await this.authenticate(address);
         return yield* call.next(call.request, {
           ...options,
-          metadata: metadata.set(
-            "Authorization",
-            `Bearer ${this.clients.get(address)?.authToken || initialAuthToken}`
-          )
+          metadata: metadata.set("Authorization", `Bearer ${token}`)
         });
       } catch (error) {
         return yield* this.handleMiddlewareError(
@@ -531,7 +341,7 @@ var ConnectionManagerNodeJS = class extends ConnectionManager {
       }
     }.bind(this);
   }
-  async createGrpcClient(defintion, channel, withRetries, middleware) {
+  async createGrpcClient(definition, channel, withRetries, middleware, channelKey) {
     const retryOptions = {
       retry: true,
       retryMaxAttempts: 3
@@ -545,13 +355,30 @@ var ConnectionManagerNodeJS = class extends ConnectionManager {
     if (middleware) {
       clientFactory = clientFactory.use(middleware);
     }
-    const client = clientFactory.create(defintion, channel, {
+    const client = clientFactory.create(definition, channel, {
       "*": options
     });
     return {
       ...client,
-      close: channel.close.bind(channel)
+      close: channelKey ? () => ConnectionManager.releaseChannel(channelKey) : channel.close.bind(channel)
+    };
+  }
+  async subscribeToEvents(address, signal) {
+    const stream = super.subscribeToEvents(address, signal);
+    const channel = await this.getChannelForClient("stream", address);
+    if (!channel) {
+      throw new Error("Failed to get channel for client");
+    }
+    const maybeUnref = () => {
+      const internalChannel = channel.internalChannel;
+      if (internalChannel?.currentPicker?.subchannel?.child?.transport?.session?.socket) {
+        internalChannel.currentPicker.subchannel.child.transport.session.socket.unref();
+      } else {
+        setTimeout(maybeUnref, 100);
+      }
     };
+    maybeUnref();
+    return stream;
   }
 };