@buildonspark/spark-sdk 0.3.4 → 0.3.6

package/dist/chunk-FJ7LTA2O.js

@@ -0,0 +1,605 @@
+import {
+  ConnectionManager,
+  NetworkError,
+  SparkWallet,
+  clientEnv
+} from "./chunk-XPHYQ2L6.js";
+import {
+  Empty
+} from "./chunk-IC4IUEOS.js";
+
+// src/services/connection/connection.node.ts
+import {
+  createClient,
+  createChannel,
+  createClientFactory,
+  ChannelCredentials
+} from "nice-grpc";
+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) };
+}
+var CleanUpPreimageShareRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.paymentHash.length !== 0) {
+      writer.uint32(10).bytes(message.paymentHash);
+    }
+    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 = createBaseCleanUpPreimageShareRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.paymentHash = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { paymentHash: isSet(object.paymentHash) ? bytesFromBase64(object.paymentHash) : new Uint8Array(0) };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.paymentHash.length !== 0) {
+      obj.paymentHash = base64FromBytes(message.paymentHash);
+    }
+    return obj;
+  },
+  create(base) {
+    return CleanUpPreimageShareRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseCleanUpPreimageShareRequest();
+    message.paymentHash = object.paymentHash ?? new Uint8Array(0);
+    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: "" };
+}
+var UpdateNodesStatusRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    for (const v of message.nodeIds) {
+      writer.uint32(10).string(v);
+    }
+    if (message.status !== "") {
+      writer.uint32(18).string(message.status);
+    }
+    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 = createBaseUpdateNodesStatusRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.nodeIds.push(reader.string());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.status = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      nodeIds: globalThis.Array.isArray(object?.nodeIds) ? object.nodeIds.map((e) => globalThis.String(e)) : [],
+      status: isSet(object.status) ? globalThis.String(object.status) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.nodeIds?.length) {
+      obj.nodeIds = message.nodeIds;
+    }
+    if (message.status !== "") {
+      obj.status = message.status;
+    }
+    return obj;
+  },
+  create(base) {
+    return UpdateNodesStatusRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseUpdateNodesStatusRequest();
+    message.nodeIds = object.nodeIds?.map((e) => e) || [];
+    message.status = object.status ?? "";
+    return message;
+  }
+};
+function createBaseTriggerTaskRequest() {
+  return { taskName: "" };
+}
+var TriggerTaskRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.taskName !== "") {
+      writer.uint32(10).string(message.taskName);
+    }
+    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 = createBaseTriggerTaskRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.taskName = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { taskName: isSet(object.taskName) ? globalThis.String(object.taskName) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.taskName !== "") {
+      obj.taskName = message.taskName;
+    }
+    return obj;
+  },
+  create(base) {
+    return TriggerTaskRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTriggerTaskRequest();
+    message.taskName = object.taskName ?? "";
+    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",
+  methods: {
+    clean_up_preimage_share: {
+      name: "clean_up_preimage_share",
+      requestType: CleanUpPreimageShareRequest,
+      requestStream: false,
+      responseType: Empty,
+      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,
+      requestStream: false,
+      responseType: Empty,
+      responseStream: false,
+      options: {}
+    },
+    /** Triggers the execution of a scheduled task immediately by name. Used by hermetic tests */
+    trigger_task: {
+      name: "trigger_task",
+      requestType: TriggerTaskRequest,
+      requestStream: false,
+      responseType: Empty,
+      responseStream: false,
+      options: {}
+    }
+  }
+};
+function bytesFromBase64(b64) {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+function base64FromBytes(arr) {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+function isSet(value) {
+  return value !== null && value !== void 0;
+}
+
+// src/services/connection/connection.node.ts
+import { openTelemetryClientMiddleware } from "nice-grpc-opentelemetry";
+import { retryMiddleware } from "nice-grpc-client-middleware-retry";
+import fs from "fs";
+var ConnectionManagerNodeJS = class extends ConnectionManager {
+  constructor(config) {
+    super(config);
+  }
+  async createMockClient(address) {
+    const channel = await this.createChannelWithTLS(address);
+    const client = createClient(MockServiceDefinition, channel);
+    return { ...client, close: () => channel.close() };
+  }
+  async createChannelWithTLS(address, certPath) {
+    try {
+      if (certPath) {
+        try {
+          const cert = fs.readFileSync(certPath);
+          return createChannel(address, ChannelCredentials.createSsl(cert));
+        } catch (error) {
+          console.error("Error reading certificate:", error);
+          return createChannel(
+            address,
+            ChannelCredentials.createSsl(null, null, null, {
+              rejectUnauthorized: false
+            })
+          );
+        }
+      } else {
+        return createChannel(
+          address,
+          ChannelCredentials.createSsl(null, null, null, {
+            rejectUnauthorized: false
+          })
+        );
+      }
+    } catch (error) {
+      console.error("Channel creation error:", error);
+      throw new NetworkError(
+        "Failed to create channel",
+        {
+          url: address,
+          operation: "createChannel",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error)
+        },
+        error
+      );
+    }
+  }
+  createAuthnMiddleware() {
+    return async function* (call, options) {
+      const metadata = Metadata(options.metadata).set(
+        "X-Client-Env",
+        clientEnv
+      );
+      return yield* call.next(call.request, {
+        ...options,
+        metadata
+      });
+    }.bind(this);
+  }
+  createMiddleware(address, initialAuthToken) {
+    return async function* (call, options) {
+      const metadata = Metadata(options.metadata).set(
+        "X-Client-Env",
+        clientEnv
+      );
+      try {
+        return yield* call.next(call.request, {
+          ...options,
+          metadata: metadata.set(
+            "Authorization",
+            `Bearer ${this.clients.get(address)?.authToken || initialAuthToken}`
+          )
+        });
+      } catch (error) {
+        return yield* this.handleMiddlewareError(
+          error,
+          address,
+          call,
+          metadata,
+          options
+        );
+      }
+    }.bind(this);
+  }
+  async createGrpcClient(defintion, channel, withRetries, middleware) {
+    const retryOptions = {
+      retry: true,
+      retryMaxAttempts: 3
+    };
+    let options = {};
+    let clientFactory = createClientFactory();
+    if (withRetries) {
+      options = retryOptions;
+      clientFactory = clientFactory.use(openTelemetryClientMiddleware()).use(retryMiddleware);
+    }
+    if (middleware) {
+      clientFactory = clientFactory.use(middleware);
+    }
+    const client = clientFactory.create(defintion, channel, {
+      "*": options
+    });
+    return {
+      ...client,
+      close: channel.close.bind(channel)
+    };
+  }
+};
+
+// src/spark-wallet/spark-wallet.node.ts
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
+var SparkWalletNodeJS = class extends SparkWallet {
+  buildConnectionManager(config) {
+    return new ConnectionManagerNodeJS(config);
+  }
+  initializeTracerEnv({
+    spanProcessors,
+    traceUrls
+  }) {
+    initializeTracerEnvNodeJS({ spanProcessors, traceUrls });
+  }
+};
+function initializeTracerEnvNodeJS({
+  spanProcessors,
+  traceUrls
+}) {
+  const provider = new NodeTracerProvider({ spanProcessors });
+  provider.register({
+    contextManager: new AsyncLocalStorageContextManager(),
+    propagator: new W3CTraceContextPropagator()
+  });
+  registerInstrumentations({
+    instrumentations: [
+      new UndiciInstrumentation({
+        ignoreRequestHook: (request) => {
+          try {
+            return !traceUrls.some(
+              (prefix) => request.origin.startsWith(prefix)
+            );
+          } catch {
+            return true;
+          }
+        }
+      })
+    ]
+  });
+}
+
+export {
+  ConnectionManagerNodeJS,
+  SparkWalletNodeJS,
+  initializeTracerEnvNodeJS
+};

package/dist/chunk-LIZFXQWK.js

@@ -0,0 +1,7 @@
+import {
+  setCrypto
+} from "./chunk-XPHYQ2L6.js";
+
+// src/index.ts
+var cryptoImpl = typeof window !== "undefined" && window.crypto ? window.crypto : typeof globalThis !== "undefined" && globalThis.crypto ? globalThis.crypto : null;
+setCrypto(cryptoImpl);