@buildonspark/spark-sdk 0.0.9 → 0.0.11

package/dist/chunk-SWFFNBSR.js

@@ -1,1244 +0,0 @@
-import {
-  DefaultSparkSigner
-} from "./chunk-SWCOMKD6.js";
-import {
-  getP2TRAddressFromPublicKey,
-  getSigHashFromTx,
-  getTxId,
-  proofOfPossessionMessageHashForDepositAddress
-} from "./chunk-NDKNVHGP.js";
-import {
-  NetworkToProto,
-  createWasmSigningCommitment,
-  getNetwork,
-  subtractPublicKeys
-} from "./chunk-COXVABEU.js";
-import {
-  BinaryReader,
-  BinaryWriter,
-  Empty,
-  SparkServiceDefinition
-} from "./chunk-5SAJ52IV.js";
-
-// src/tests/test-util.ts
-import { hexToBytes } from "@noble/curves/abstract/utils";
-import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1";
-import { Address as Address2, OutScript as OutScript2, Transaction as Transaction2 } from "@scure/btc-signer";
-
-// src/services/config.ts
-var WalletConfigService = class _WalletConfigService {
-  config;
-  signer;
-  constructor(network, signer) {
-    switch (network) {
-      case 0 /* MAINNET */:
-        this.config = MAINNET_WALLET_CONFIG;
-        break;
-      case 3 /* REGTEST */:
-        this.config = REGTEST_WALLET_CONFIG;
-        break;
-      default:
-        this.config = LOCAL_WALLET_CONFIG;
-        break;
-    }
-    this.signer = signer || new DefaultSparkSigner();
-  }
-  static withConfig(config, signer) {
-    const service = new _WalletConfigService(config.network, signer);
-    service.config = config;
-    return service;
-  }
-  getCoordinatorAddress() {
-    const coordinator = this.config.signingOperators[this.config.coodinatorIdentifier];
-    if (!coordinator) {
-      throw new Error(
-        `Coordinator ${this.config.coodinatorIdentifier} not found`
-      );
-    }
-    return coordinator.address;
-  }
-  getConfig() {
-    return this.config;
-  }
-  getNetwork() {
-    return this.config.network;
-  }
-  getNetworkProto() {
-    return NetworkToProto[this.config.network];
-  }
-};
-
-// src/services/connection.ts
-import { sha256 } from "@scure/btc-signer/utils";
-import * as fs from "fs";
-import {
-  ChannelCredentials,
-  createChannel,
-  createClient,
-  createClientFactory,
-  Metadata
-} from "nice-grpc";
-import { retryMiddleware } from "nice-grpc-client-middleware-retry";
-
-// src/proto/mock.ts
-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);
-    let 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;
-  }
-};
-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: {}
-    }
-  }
-};
-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/proto/spark_authn.ts
-function createBaseChallenge() {
-  return { version: 0, timestamp: 0, nonce: new Uint8Array(0), publicKey: new Uint8Array(0) };
-}
-var Challenge = {
-  encode(message, writer = new BinaryWriter()) {
-    if (message.version !== 0) {
-      writer.uint32(8).int32(message.version);
-    }
-    if (message.timestamp !== 0) {
-      writer.uint32(16).int64(message.timestamp);
-    }
-    if (message.nonce.length !== 0) {
-      writer.uint32(26).bytes(message.nonce);
-    }
-    if (message.publicKey.length !== 0) {
-      writer.uint32(34).bytes(message.publicKey);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseChallenge();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 8) {
-            break;
-          }
-          message.version = reader.int32();
-          continue;
-        }
-        case 2: {
-          if (tag !== 16) {
-            break;
-          }
-          message.timestamp = longToNumber(reader.int64());
-          continue;
-        }
-        case 3: {
-          if (tag !== 26) {
-            break;
-          }
-          message.nonce = reader.bytes();
-          continue;
-        }
-        case 4: {
-          if (tag !== 34) {
-            break;
-          }
-          message.publicKey = reader.bytes();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      version: isSet2(object.version) ? globalThis.Number(object.version) : 0,
-      timestamp: isSet2(object.timestamp) ? globalThis.Number(object.timestamp) : 0,
-      nonce: isSet2(object.nonce) ? bytesFromBase642(object.nonce) : new Uint8Array(0),
-      publicKey: isSet2(object.publicKey) ? bytesFromBase642(object.publicKey) : new Uint8Array(0)
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.version !== 0) {
-      obj.version = Math.round(message.version);
-    }
-    if (message.timestamp !== 0) {
-      obj.timestamp = Math.round(message.timestamp);
-    }
-    if (message.nonce.length !== 0) {
-      obj.nonce = base64FromBytes2(message.nonce);
-    }
-    if (message.publicKey.length !== 0) {
-      obj.publicKey = base64FromBytes2(message.publicKey);
-    }
-    return obj;
-  },
-  create(base) {
-    return Challenge.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseChallenge();
-    message.version = object.version ?? 0;
-    message.timestamp = object.timestamp ?? 0;
-    message.nonce = object.nonce ?? new Uint8Array(0);
-    message.publicKey = object.publicKey ?? new Uint8Array(0);
-    return message;
-  }
-};
-function createBaseProtectedChallenge() {
-  return { version: 0, challenge: void 0, serverHmac: new Uint8Array(0) };
-}
-var ProtectedChallenge = {
-  encode(message, writer = new BinaryWriter()) {
-    if (message.version !== 0) {
-      writer.uint32(8).int32(message.version);
-    }
-    if (message.challenge !== void 0) {
-      Challenge.encode(message.challenge, writer.uint32(18).fork()).join();
-    }
-    if (message.serverHmac.length !== 0) {
-      writer.uint32(26).bytes(message.serverHmac);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseProtectedChallenge();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 8) {
-            break;
-          }
-          message.version = reader.int32();
-          continue;
-        }
-        case 2: {
-          if (tag !== 18) {
-            break;
-          }
-          message.challenge = Challenge.decode(reader, reader.uint32());
-          continue;
-        }
-        case 3: {
-          if (tag !== 26) {
-            break;
-          }
-          message.serverHmac = reader.bytes();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      version: isSet2(object.version) ? globalThis.Number(object.version) : 0,
-      challenge: isSet2(object.challenge) ? Challenge.fromJSON(object.challenge) : void 0,
-      serverHmac: isSet2(object.serverHmac) ? bytesFromBase642(object.serverHmac) : new Uint8Array(0)
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.version !== 0) {
-      obj.version = Math.round(message.version);
-    }
-    if (message.challenge !== void 0) {
-      obj.challenge = Challenge.toJSON(message.challenge);
-    }
-    if (message.serverHmac.length !== 0) {
-      obj.serverHmac = base64FromBytes2(message.serverHmac);
-    }
-    return obj;
-  },
-  create(base) {
-    return ProtectedChallenge.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseProtectedChallenge();
-    message.version = object.version ?? 0;
-    message.challenge = object.challenge !== void 0 && object.challenge !== null ? Challenge.fromPartial(object.challenge) : void 0;
-    message.serverHmac = object.serverHmac ?? new Uint8Array(0);
-    return message;
-  }
-};
-function createBaseGetChallengeRequest() {
-  return { publicKey: new Uint8Array(0) };
-}
-var GetChallengeRequest = {
-  encode(message, writer = new BinaryWriter()) {
-    if (message.publicKey.length !== 0) {
-      writer.uint32(10).bytes(message.publicKey);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseGetChallengeRequest();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-          message.publicKey = reader.bytes();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return { publicKey: isSet2(object.publicKey) ? bytesFromBase642(object.publicKey) : new Uint8Array(0) };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.publicKey.length !== 0) {
-      obj.publicKey = base64FromBytes2(message.publicKey);
-    }
-    return obj;
-  },
-  create(base) {
-    return GetChallengeRequest.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseGetChallengeRequest();
-    message.publicKey = object.publicKey ?? new Uint8Array(0);
-    return message;
-  }
-};
-function createBaseGetChallengeResponse() {
-  return { protectedChallenge: void 0 };
-}
-var GetChallengeResponse = {
-  encode(message, writer = new BinaryWriter()) {
-    if (message.protectedChallenge !== void 0) {
-      ProtectedChallenge.encode(message.protectedChallenge, writer.uint32(10).fork()).join();
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseGetChallengeResponse();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-          message.protectedChallenge = ProtectedChallenge.decode(reader, reader.uint32());
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      protectedChallenge: isSet2(object.protectedChallenge) ? ProtectedChallenge.fromJSON(object.protectedChallenge) : void 0
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.protectedChallenge !== void 0) {
-      obj.protectedChallenge = ProtectedChallenge.toJSON(message.protectedChallenge);
-    }
-    return obj;
-  },
-  create(base) {
-    return GetChallengeResponse.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseGetChallengeResponse();
-    message.protectedChallenge = object.protectedChallenge !== void 0 && object.protectedChallenge !== null ? ProtectedChallenge.fromPartial(object.protectedChallenge) : void 0;
-    return message;
-  }
-};
-function createBaseVerifyChallengeRequest() {
-  return { protectedChallenge: void 0, signature: new Uint8Array(0), publicKey: new Uint8Array(0) };
-}
-var VerifyChallengeRequest = {
-  encode(message, writer = new BinaryWriter()) {
-    if (message.protectedChallenge !== void 0) {
-      ProtectedChallenge.encode(message.protectedChallenge, writer.uint32(10).fork()).join();
-    }
-    if (message.signature.length !== 0) {
-      writer.uint32(18).bytes(message.signature);
-    }
-    if (message.publicKey.length !== 0) {
-      writer.uint32(26).bytes(message.publicKey);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseVerifyChallengeRequest();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-          message.protectedChallenge = ProtectedChallenge.decode(reader, reader.uint32());
-          continue;
-        }
-        case 2: {
-          if (tag !== 18) {
-            break;
-          }
-          message.signature = reader.bytes();
-          continue;
-        }
-        case 3: {
-          if (tag !== 26) {
-            break;
-          }
-          message.publicKey = reader.bytes();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      protectedChallenge: isSet2(object.protectedChallenge) ? ProtectedChallenge.fromJSON(object.protectedChallenge) : void 0,
-      signature: isSet2(object.signature) ? bytesFromBase642(object.signature) : new Uint8Array(0),
-      publicKey: isSet2(object.publicKey) ? bytesFromBase642(object.publicKey) : new Uint8Array(0)
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.protectedChallenge !== void 0) {
-      obj.protectedChallenge = ProtectedChallenge.toJSON(message.protectedChallenge);
-    }
-    if (message.signature.length !== 0) {
-      obj.signature = base64FromBytes2(message.signature);
-    }
-    if (message.publicKey.length !== 0) {
-      obj.publicKey = base64FromBytes2(message.publicKey);
-    }
-    return obj;
-  },
-  create(base) {
-    return VerifyChallengeRequest.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseVerifyChallengeRequest();
-    message.protectedChallenge = object.protectedChallenge !== void 0 && object.protectedChallenge !== null ? ProtectedChallenge.fromPartial(object.protectedChallenge) : void 0;
-    message.signature = object.signature ?? new Uint8Array(0);
-    message.publicKey = object.publicKey ?? new Uint8Array(0);
-    return message;
-  }
-};
-function createBaseVerifyChallengeResponse() {
-  return { sessionToken: "", expirationTimestamp: 0 };
-}
-var VerifyChallengeResponse = {
-  encode(message, writer = new BinaryWriter()) {
-    if (message.sessionToken !== "") {
-      writer.uint32(10).string(message.sessionToken);
-    }
-    if (message.expirationTimestamp !== 0) {
-      writer.uint32(16).int64(message.expirationTimestamp);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseVerifyChallengeResponse();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-          message.sessionToken = reader.string();
-          continue;
-        }
-        case 2: {
-          if (tag !== 16) {
-            break;
-          }
-          message.expirationTimestamp = longToNumber(reader.int64());
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      sessionToken: isSet2(object.sessionToken) ? globalThis.String(object.sessionToken) : "",
-      expirationTimestamp: isSet2(object.expirationTimestamp) ? globalThis.Number(object.expirationTimestamp) : 0
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.sessionToken !== "") {
-      obj.sessionToken = message.sessionToken;
-    }
-    if (message.expirationTimestamp !== 0) {
-      obj.expirationTimestamp = Math.round(message.expirationTimestamp);
-    }
-    return obj;
-  },
-  create(base) {
-    return VerifyChallengeResponse.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseVerifyChallengeResponse();
-    message.sessionToken = object.sessionToken ?? "";
-    message.expirationTimestamp = object.expirationTimestamp ?? 0;
-    return message;
-  }
-};
-var SparkAuthnServiceDefinition = {
-  name: "SparkAuthnService",
-  fullName: "spark_authn.SparkAuthnService",
-  methods: {
-    /** Request a new authentication challenge for a public key */
-    get_challenge: {
-      name: "get_challenge",
-      requestType: GetChallengeRequest,
-      requestStream: false,
-      responseType: GetChallengeResponse,
-      responseStream: false,
-      options: {}
-    },
-    /** Verify a signed challenge and return a session token */
-    verify_challenge: {
-      name: "verify_challenge",
-      requestType: VerifyChallengeRequest,
-      requestStream: false,
-      responseType: VerifyChallengeResponse,
-      responseStream: false,
-      options: {}
-    }
-  }
-};
-function bytesFromBase642(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 base64FromBytes2(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 longToNumber(int64) {
-  const num = globalThis.Number(int64.toString());
-  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
-    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
-  }
-  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
-    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
-  }
-  return num;
-}
-function isSet2(value) {
-  return value !== null && value !== void 0;
-}
-
-// src/services/connection.ts
-var ConnectionManager = class _ConnectionManager {
-  config;
-  clients = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.config = config;
-  }
-  // When initializing wallet, go ahead and instantiate all clients
-  async createClients() {
-    await Promise.all(
-      Object.values(this.config.getConfig().signingOperators).map(
-        (operator) => {
-          this.createSparkClient(operator.address);
-        }
-      )
-    );
-  }
-  static createMockClient(address) {
-    const channel = this.createChannelWithTLS(address);
-    const client = createClient(MockServiceDefinition, channel);
-    return { ...client, close: () => channel.close() };
-  }
-  // TODO: Web transport handles TLS differently, verify that we don't need to do anything
-  static createChannelWithTLS(address, certPath) {
-    try {
-      if (certPath && typeof window === "undefined") {
-        const cert = fs.readFileSync(certPath);
-        return createChannel(address, ChannelCredentials.createSsl(cert));
-      } else {
-        return createChannel(
-          address,
-          typeof window === "undefined" ? ChannelCredentials.createSsl(null, null, null, {
-            rejectUnauthorized: false
-          }) : void 0
-        );
-      }
-    } catch (error) {
-      console.error("Channel creation error:", error);
-      throw new Error("Failed to create channel");
-    }
-  }
-  async createSparkClient(address, certPath) {
-    if (this.clients.has(address)) {
-      return this.clients.get(address).client;
-    }
-    const authToken = await this.authenticate(address);
-    const channel = _ConnectionManager.createChannelWithTLS(address, certPath);
-    const authMiddleware = this.createAuthMiddleWare(address, authToken);
-    const client = this.createGrpcClient(
-      SparkServiceDefinition,
-      channel,
-      authMiddleware
-    );
-    this.clients.set(address, { client, authToken });
-    return client;
-  }
-  async authenticate(address) {
-    try {
-      const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-      const sparkAuthnClient = this.createSparkAuthnGrpcConnection(address);
-      const challengeResp = await sparkAuthnClient.get_challenge({
-        publicKey: identityPublicKey
-      });
-      if (!challengeResp.protectedChallenge?.challenge) {
-        throw new Error("Invalid challenge response");
-      }
-      const challengeBytes = Challenge.encode(
-        challengeResp.protectedChallenge.challenge
-      ).finish();
-      const hash = sha256(challengeBytes);
-      const derSignatureBytes = await this.config.signer.signMessageWithIdentityKey(hash);
-      const verifyResp = await sparkAuthnClient.verify_challenge({
-        protectedChallenge: challengeResp.protectedChallenge,
-        signature: derSignatureBytes,
-        publicKey: identityPublicKey
-      });
-      sparkAuthnClient.close?.();
-      return verifyResp.sessionToken;
-    } catch (error) {
-      console.error("Authentication error:", error);
-      throw new Error(`Authentication failed: ${error.message}`);
-    }
-  }
-  createSparkAuthnGrpcConnection(address, certPath) {
-    const channel = _ConnectionManager.createChannelWithTLS(address, certPath);
-    return this.createGrpcClient(
-      SparkAuthnServiceDefinition,
-      channel
-    );
-  }
-  createAuthMiddleWare(address, authToken) {
-    if (typeof window === "undefined") {
-      return this.createNodeMiddleware(address, authToken);
-    } else {
-      return this.createBrowserMiddleware(address, authToken);
-    }
-  }
-  createNodeMiddleware(address, initialAuthToken) {
-    return async function* (call, options) {
-      try {
-        yield* call.next(call.request, {
-          ...options,
-          metadata: Metadata(options.metadata).set(
-            "Authorization",
-            `Bearer ${this.clients.get(address)?.authToken || initialAuthToken}`
-          )
-        });
-      } catch (error) {
-        if (error.message?.includes("token has expired")) {
-          const newAuthToken = await this.authenticate(address);
-          this.clients.get(address).authToken = newAuthToken;
-          yield* call.next(call.request, {
-            ...options,
-            metadata: Metadata(options.metadata).set(
-              "Authorization",
-              `Bearer ${newAuthToken}`
-            )
-          });
-        }
-        throw error;
-      }
-    }.bind(this);
-  }
-  createBrowserMiddleware(address, initialAuthToken) {
-    return async function* (call, options) {
-      try {
-        yield* call.next(call.request, {
-          ...options,
-          metadata: Metadata(options.metadata).set(
-            "Authorization",
-            `Bearer ${this.clients.get(address)?.authToken || initialAuthToken}`
-          ).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("Content-Type", "application/grpc-web+proto")
-        });
-      } catch (error) {
-        if (error.message?.includes("token has expired")) {
-          const newAuthToken = await this.authenticate(address);
-          this.clients.get(address).authToken = newAuthToken;
-          yield* call.next(call.request, {
-            ...options,
-            metadata: Metadata(options.metadata).set("Authorization", `Bearer ${newAuthToken}`).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("Content-Type", "application/grpc-web+proto")
-          });
-        }
-        throw error;
-      }
-    }.bind(this);
-  }
-  createGrpcClient(defintion, channel, middleware) {
-    const clientFactory = createClientFactory().use(retryMiddleware);
-    if (middleware) {
-      clientFactory.use(middleware);
-    }
-    const client = clientFactory.create(defintion, channel, {
-      "*": {
-        retry: true,
-        retryMaxAttempts: 3
-      }
-    });
-    return {
-      ...client,
-      close: channel.close?.bind(channel)
-    };
-  }
-};
-
-// src/services/deposit.ts
-import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
-import * as btc from "@scure/btc-signer";
-import { p2tr, Transaction } from "@scure/btc-signer";
-import { equalBytes, sha256 as sha2562 } from "@scure/btc-signer/utils";
-var INITIAL_TIME_LOCK = 6e4;
-var DepositService = class {
-  config;
-  connectionManager;
-  constructor(config, connectionManager) {
-    this.config = config;
-    this.connectionManager = connectionManager;
-  }
-  async validateDepositAddress({
-    address,
-    userPubkey
-  }) {
-    if (!address.depositAddressProof || !address.depositAddressProof.proofOfPossessionSignature || !address.depositAddressProof.addressSignatures) {
-      throw new Error(
-        "proof of possession signature or address signatures is null"
-      );
-    }
-    const operatorPubkey = subtractPublicKeys(address.verifyingKey, userPubkey);
-    const msg = proofOfPossessionMessageHashForDepositAddress(
-      await this.config.signer.getIdentityPublicKey(),
-      operatorPubkey,
-      address.address
-    );
-    const taprootKey = p2tr(
-      operatorPubkey.slice(1, 33),
-      void 0,
-      getNetwork(this.config.getNetwork())
-    ).tweakedPubkey;
-    const isVerified = schnorr.verify(
-      address.depositAddressProof.proofOfPossessionSignature,
-      msg,
-      taprootKey
-    );
-    if (!isVerified) {
-      throw new Error("proof of possession signature verification failed");
-    }
-    const addrHash = sha2562(address.address);
-    for (const operator of Object.values(
-      this.config.getConfig().signingOperators
-    )) {
-      if (operator.identifier === this.config.getConfig().coodinatorIdentifier) {
-        continue;
-      }
-      const operatorPubkey2 = operator.identityPublicKey;
-      const operatorSig = address.depositAddressProof.addressSignatures[operator.identifier];
-      if (!operatorSig) {
-        throw new Error("operator signature not found");
-      }
-      const sig = secp256k1.Signature.fromDER(operatorSig);
-      const isVerified2 = secp256k1.verify(sig, addrHash, operatorPubkey2);
-      if (!isVerified2) {
-        throw new Error("signature verification failed");
-      }
-    }
-  }
-  async generateDepositAddress({
-    signingPubkey
-  }) {
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    let depositResp;
-    try {
-      depositResp = await sparkClient.generate_deposit_address({
-        signingPublicKey: signingPubkey,
-        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        network: this.config.getNetworkProto()
-      });
-    } catch (error) {
-      throw new Error(`Error generating deposit address: ${error}`);
-    }
-    if (!depositResp.depositAddress) {
-      throw new Error("No deposit address response from coordinator");
-    }
-    await this.validateDepositAddress({
-      address: depositResp.depositAddress,
-      userPubkey: signingPubkey
-    });
-    return depositResp;
-  }
-  async createTreeRoot({
-    signingPubKey,
-    verifyingKey,
-    depositTx,
-    vout
-  }) {
-    const rootTx = new Transaction();
-    const output = depositTx.getOutput(vout);
-    if (!output) {
-      throw new Error("No output found in deposit tx");
-    }
-    const script = output.script;
-    const amount = output.amount;
-    if (!script || !amount) {
-      throw new Error("No script or amount found in deposit tx");
-    }
-    rootTx.addInput({
-      txid: getTxId(depositTx),
-      index: vout
-    });
-    rootTx.addOutput({
-      script,
-      amount
-    });
-    const rootNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const rootTxSighash = getSigHashFromTx(rootTx, 0, output);
-    const refundTx = new Transaction();
-    const sequence = 1 << 30 | INITIAL_TIME_LOCK;
-    refundTx.addInput({
-      txid: getTxId(rootTx),
-      index: 0,
-      sequence
-    });
-    const refundP2trAddress = getP2TRAddressFromPublicKey(
-      signingPubKey,
-      this.config.getNetwork()
-    );
-    const refundAddress = btc.Address(getNetwork(this.config.getNetwork())).decode(refundP2trAddress);
-    const refundPkScript = btc.OutScript.encode(refundAddress);
-    refundTx.addOutput({
-      script: refundPkScript,
-      amount
-    });
-    const refundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
-    const refundTxSighash = getSigHashFromTx(refundTx, 0, output);
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    let treeResp;
-    try {
-      treeResp = await sparkClient.start_tree_creation({
-        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        onChainUtxo: {
-          vout,
-          rawTx: depositTx.toBytes(),
-          network: this.config.getNetworkProto()
-        },
-        rootTxSigningJob: {
-          rawTx: rootTx.toBytes(),
-          signingPublicKey: signingPubKey,
-          signingNonceCommitment: rootNonceCommitment
-        },
-        refundTxSigningJob: {
-          rawTx: refundTx.toBytes(),
-          signingPublicKey: signingPubKey,
-          signingNonceCommitment: refundNonceCommitment
-        }
-      });
-    } catch (error) {
-      throw new Error(`Error starting tree creation: ${error}`);
-    }
-    if (!treeResp.rootNodeSignatureShares?.verifyingKey) {
-      throw new Error("No verifying key found in tree response");
-    }
-    if (!treeResp.rootNodeSignatureShares.nodeTxSigningResult?.signingNonceCommitments) {
-      throw new Error("No signing nonce commitments found in tree response");
-    }
-    if (!treeResp.rootNodeSignatureShares.refundTxSigningResult?.signingNonceCommitments) {
-      throw new Error("No signing nonce commitments found in tree response");
-    }
-    if (!equalBytes(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
-      throw new Error("Verifying key does not match");
-    }
-    const rootSignature = await this.config.signer.signFrost({
-      message: rootTxSighash,
-      publicKey: signingPubKey,
-      privateAsPubKey: signingPubKey,
-      verifyingKey,
-      selfCommitment: rootNonceCommitment,
-      statechainCommitments: treeResp.rootNodeSignatureShares.nodeTxSigningResult.signingNonceCommitments,
-      adaptorPubKey: new Uint8Array()
-    });
-    const refundSignature = await this.config.signer.signFrost({
-      message: refundTxSighash,
-      publicKey: signingPubKey,
-      privateAsPubKey: signingPubKey,
-      verifyingKey,
-      selfCommitment: refundNonceCommitment,
-      statechainCommitments: treeResp.rootNodeSignatureShares.refundTxSigningResult.signingNonceCommitments,
-      adaptorPubKey: new Uint8Array()
-    });
-    const rootAggregate = await this.config.signer.aggregateFrost({
-      message: rootTxSighash,
-      statechainSignatures: treeResp.rootNodeSignatureShares.nodeTxSigningResult.signatureShares,
-      statechainPublicKeys: treeResp.rootNodeSignatureShares.nodeTxSigningResult.publicKeys,
-      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
-      statechainCommitments: treeResp.rootNodeSignatureShares.nodeTxSigningResult.signingNonceCommitments,
-      selfCommitment: createWasmSigningCommitment(rootNonceCommitment),
-      publicKey: signingPubKey,
-      selfSignature: rootSignature,
-      adaptorPubKey: new Uint8Array()
-    });
-    const refundAggregate = await this.config.signer.aggregateFrost({
-      message: refundTxSighash,
-      statechainSignatures: treeResp.rootNodeSignatureShares.refundTxSigningResult.signatureShares,
-      statechainPublicKeys: treeResp.rootNodeSignatureShares.refundTxSigningResult.publicKeys,
-      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
-      statechainCommitments: treeResp.rootNodeSignatureShares.refundTxSigningResult.signingNonceCommitments,
-      selfCommitment: createWasmSigningCommitment(refundNonceCommitment),
-      publicKey: signingPubKey,
-      selfSignature: refundSignature,
-      adaptorPubKey: new Uint8Array()
-    });
-    let finalizeResp;
-    try {
-      finalizeResp = await sparkClient.finalize_node_signatures({
-        intent: 0 /* CREATION */,
-        nodeSignatures: [
-          {
-            nodeId: treeResp.rootNodeSignatureShares.nodeId,
-            nodeTxSignature: rootAggregate,
-            refundTxSignature: refundAggregate
-          }
-        ]
-      });
-    } catch (error) {
-      throw new Error(`Error finalizing node signatures in deposit: ${error}`);
-    }
-    return finalizeResp;
-  }
-};
-
-// src/tests/test-util.ts
-var LOCAL_WALLET_CONFIG = {
-  network: 3 /* REGTEST */,
-  coodinatorIdentifier: "0000000000000000000000000000000000000000000000000000000000000001",
-  frostSignerAddress: "unix:///tmp/frost_0.sock",
-  threshold: 3,
-  signingOperators: getLocalSigningOperators(),
-  useTokenTransactionSchnorrSignatures: true
-};
-var LOCAL_WALLET_CONFIG_SCHNORR = {
-  network: 3 /* REGTEST */,
-  coodinatorIdentifier: "0000000000000000000000000000000000000000000000000000000000000001",
-  frostSignerAddress: "unix:///tmp/frost_0.sock",
-  threshold: 3,
-  signingOperators: getLocalSigningOperators(),
-  useTokenTransactionSchnorrSignatures: true
-};
-var LOCAL_WALLET_CONFIG_ECDSA = {
-  network: 3 /* REGTEST */,
-  coodinatorIdentifier: "0000000000000000000000000000000000000000000000000000000000000001",
-  frostSignerAddress: "unix:///tmp/frost_0.sock",
-  threshold: 3,
-  signingOperators: getLocalSigningOperators(),
-  useTokenTransactionSchnorrSignatures: false
-};
-var REGTEST_WALLET_CONFIG = {
-  network: 3 /* REGTEST */,
-  coodinatorIdentifier: "0000000000000000000000000000000000000000000000000000000000000001",
-  frostSignerAddress: "unix:///tmp/frost_0.sock",
-  threshold: 3,
-  signingOperators: getRegtestSigningOperators(),
-  useTokenTransactionSchnorrSignatures: true
-};
-var MAINNET_WALLET_CONFIG = {
-  network: 0 /* MAINNET */,
-  coodinatorIdentifier: "0000000000000000000000000000000000000000000000000000000000000001",
-  frostSignerAddress: "unix:///tmp/frost_0.sock",
-  threshold: 3,
-  signingOperators: getRegtestSigningOperators(),
-  useTokenTransactionSchnorrSignatures: true
-};
-function getRegtestSigningOperators() {
-  const pubkeys = [
-    "03acd9a5a88db102730ff83dee69d69088cc4c9d93bbee893e90fd5051b7da9651",
-    "02d2d103cacb1d6355efeab27637c74484e2a7459e49110c3fe885210369782e23",
-    "0350f07ffc21bfd59d31e0a7a600e2995273938444447cb9bc4c75b8a895dbb853"
-  ];
-  const pubkeyBytesArray = pubkeys.map((pubkey) => hexToBytes(pubkey));
-  return {
-    "0000000000000000000000000000000000000000000000000000000000000001": {
-      id: 0,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000001",
-      address: "https://0.spark.dev.dev.sparkinfra.net",
-      identityPublicKey: pubkeyBytesArray[0]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000002": {
-      id: 1,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000002",
-      address: "https://1.spark.dev.dev.sparkinfra.net",
-      identityPublicKey: pubkeyBytesArray[1]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000003": {
-      id: 2,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000003",
-      address: "https://2.spark.dev.dev.sparkinfra.net",
-      identityPublicKey: pubkeyBytesArray[2]
-    }
-  };
-}
-function getLocalSigningOperators() {
-  const pubkeys = [
-    "0322ca18fc489ae25418a0e768273c2c61cabb823edfb14feb891e9bec62016510",
-    "0341727a6c41b168f07eb50865ab8c397a53c7eef628ac1020956b705e43b6cb27",
-    "0305ab8d485cc752394de4981f8a5ae004f2becfea6f432c9a59d5022d8764f0a6",
-    "0352aef4d49439dedd798ac4aef1e7ebef95f569545b647a25338398c1247ffdea",
-    "02c05c88cc8fc181b1ba30006df6a4b0597de6490e24514fbdd0266d2b9cd3d0ba"
-  ];
-  const pubkeyBytesArray = pubkeys.map((pubkey) => hexToBytes(pubkey));
-  return {
-    "0000000000000000000000000000000000000000000000000000000000000001": {
-      id: 0,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000001",
-      address: "https://localhost:8535",
-      identityPublicKey: pubkeyBytesArray[0]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000002": {
-      id: 1,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000002",
-      address: "https://localhost:8536",
-      identityPublicKey: pubkeyBytesArray[1]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000003": {
-      id: 2,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000003",
-      address: "https://localhost:8537",
-      identityPublicKey: pubkeyBytesArray[2]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000004": {
-      id: 3,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000004",
-      address: "https://localhost:8538",
-      identityPublicKey: pubkeyBytesArray[3]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000005": {
-      id: 4,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000005",
-      address: "https://localhost:8539",
-      identityPublicKey: pubkeyBytesArray[4]
-    }
-  };
-}
-function getTestWalletConfig() {
-  const identityPrivateKey = secp256k12.utils.randomPrivateKey();
-  return getTestWalletConfigWithIdentityKey(identityPrivateKey);
-}
-function getTestWalletConfigWithIdentityKey(identityPrivateKey) {
-  return {
-    ...LOCAL_WALLET_CONFIG,
-    identityPrivateKey
-  };
-}
-async function createNewTree(wallet, pubKey, faucet, amountSats = 100000n) {
-  const faucetCoin = await faucet.fund();
-  const configService = new WalletConfigService(
-    4 /* LOCAL */,
-    wallet.getSigner()
-  );
-  const connectionManager = new ConnectionManager(configService);
-  const depositService = new DepositService(configService, connectionManager);
-  const depositResp = await depositService.generateDepositAddress({
-    signingPubkey: pubKey
-  });
-  if (!depositResp.depositAddress) {
-    throw new Error("deposit address not found");
-  }
-  const depositTx = new Transaction2();
-  depositTx.addInput(faucetCoin.outpoint);
-  const addr = Address2(getNetwork(4 /* LOCAL */)).decode(
-    depositResp.depositAddress.address
-  );
-  const script = OutScript2.encode(addr);
-  depositTx.addOutput({ script, amount: amountSats });
-  const treeResp = await depositService.createTreeRoot({
-    signingPubKey: pubKey,
-    verifyingKey: depositResp.depositAddress.verifyingKey,
-    depositTx,
-    vout: 0
-  });
-  const signedDepositTx = await faucet.signFaucetCoin(
-    depositTx,
-    faucetCoin.txout,
-    faucetCoin.key
-  );
-  await faucet.broadcastTx(signedDepositTx.hex);
-  const randomKey = secp256k12.utils.randomPrivateKey();
-  const randomPubKey = secp256k12.getPublicKey(randomKey);
-  const randomAddress = getP2TRAddressFromPublicKey(
-    randomPubKey,
-    4 /* LOCAL */
-  );
-  await faucet.generateToAddress(1, randomAddress);
-  await new Promise((resolve) => setTimeout(resolve, 100));
-  return treeResp.nodes[0];
-}
-
-export {
-  ConnectionManager,
-  DepositService,
-  LOCAL_WALLET_CONFIG,
-  LOCAL_WALLET_CONFIG_SCHNORR,
-  LOCAL_WALLET_CONFIG_ECDSA,
-  REGTEST_WALLET_CONFIG,
-  MAINNET_WALLET_CONFIG,
-  getRegtestSigningOperators,
-  getLocalSigningOperators,
-  getTestWalletConfig,
-  getTestWalletConfigWithIdentityKey,
-  createNewTree,
-  WalletConfigService
-};