@buildonspark/spark-sdk 0.1.39 → 0.1.41

package/dist/utils/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: tr
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
+  DEFAULT_FEE_SATS: () => DEFAULT_FEE_SATS,
   LRC_WALLET_NETWORK: () => LRC_WALLET_NETWORK,
   LRC_WALLET_NETWORK_TYPE: () => LRC_WALLET_NETWORK_TYPE,
   Network: () => Network2,
@@ -41,9 +42,13 @@ __export(utils_exports, {
   bigIntToPrivateKey: () => bigIntToPrivateKey,
   calculateAvailableTokenAmount: () => calculateAvailableTokenAmount,
   checkIfSelectedOutputsAreAvailable: () => checkIfSelectedOutputsAreAvailable,
+  checkIfValidSequence: () => checkIfValidSequence,
   collectResponses: () => collectResponses,
   computeTaprootKeyNoScript: () => computeTaprootKeyNoScript,
   computerLagrangeCoefficients: () => computerLagrangeCoefficients,
+  constructFeeBumpTx: () => constructFeeBumpTx,
+  constructUnilateralExitFeeBumpPackages: () => constructUnilateralExitFeeBumpPackages,
+  constructUnilateralExitTxs: () => constructUnilateralExitTxs,
   createRefundTx: () => createRefundTx,
   createSigningCommitment: () => createSigningCommitment,
   createSigningNonce: () => createSigningNonce,
@@ -62,6 +67,7 @@ __export(utils_exports, {
   getLatestDepositTxId: () => getLatestDepositTxId,
   getNetwork: () => getNetwork,
   getNetworkFromAddress: () => getNetworkFromAddress,
+  getNetworkFromString: () => getNetworkFromString,
   getNextTransactionSequence: () => getNextTransactionSequence,
   getP2TRAddressFromPkScript: () => getP2TRAddressFromPkScript,
   getP2TRAddressFromPublicKey: () => getP2TRAddressFromPublicKey,
@@ -71,13 +77,17 @@ __export(utils_exports, {
   getRandomSigningNonce: () => getRandomSigningNonce,
   getSigHashFromTx: () => getSigHashFromTx,
   getSigningCommitmentFromNonce: () => getSigningCommitmentFromNonce,
+  getSparkAddressFromTaproot: () => getSparkAddressFromTaproot,
   getTransactionSequence: () => getTransactionSequence,
   getTransferPackageSigningPayload: () => getTransferPackageSigningPayload,
   getTxFromRawTxBytes: () => getTxFromRawTxBytes,
   getTxFromRawTxHex: () => getTxFromRawTxHex,
   getTxId: () => getTxId,
   getTxIdNoReverse: () => getTxIdNoReverse,
+  isEphemeralAnchorOutput: () => isEphemeralAnchorOutput,
+  isTxBroadcast: () => isTxBroadcast,
   lastKeyWithTarget: () => lastKeyWithTarget,
+  maybeApplyFee: () => maybeApplyFee,
   modInverse: () => modInverse,
   proofOfPossessionMessageHashForDepositAddress: () => proofOfPossessionMessageHashForDepositAddress,
   recoverSecret: () => recoverSecret,
@@ -302,6 +312,564 @@ var import_wire2 = require("@bufbuild/protobuf/wire");
 // src/proto/google/protobuf/timestamp.ts
 var import_wire3 = require("@bufbuild/protobuf/wire");
 
+// src/proto/spark.ts
+function networkFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "UNSPECIFIED":
+      return 0 /* UNSPECIFIED */;
+    case 1:
+    case "MAINNET":
+      return 1 /* MAINNET */;
+    case 2:
+    case "REGTEST":
+      return 2 /* REGTEST */;
+    case 3:
+    case "TESTNET":
+      return 3 /* TESTNET */;
+    case 4:
+    case "SIGNET":
+      return 4 /* SIGNET */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function networkToJSON(object) {
+  switch (object) {
+    case 0 /* UNSPECIFIED */:
+      return "UNSPECIFIED";
+    case 1 /* MAINNET */:
+      return "MAINNET";
+    case 2 /* REGTEST */:
+      return "REGTEST";
+    case 3 /* TESTNET */:
+      return "TESTNET";
+    case 4 /* SIGNET */:
+      return "SIGNET";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+function createBaseSigningKeyshare() {
+  return { ownerIdentifiers: [], threshold: 0, publicKey: new Uint8Array(0) };
+}
+var SigningKeyshare = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    for (const v of message.ownerIdentifiers) {
+      writer.uint32(10).string(v);
+    }
+    if (message.threshold !== 0) {
+      writer.uint32(16).uint32(message.threshold);
+    }
+    if (message.publicKey.length !== 0) {
+      writer.uint32(26).bytes(message.publicKey);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSigningKeyshare();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.ownerIdentifiers.push(reader.string());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.threshold = reader.uint32();
+          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 {
+      ownerIdentifiers: globalThis.Array.isArray(object?.ownerIdentifiers) ? object.ownerIdentifiers.map((e) => globalThis.String(e)) : [],
+      threshold: isSet(object.threshold) ? globalThis.Number(object.threshold) : 0,
+      publicKey: isSet(object.publicKey) ? bytesFromBase64(object.publicKey) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.ownerIdentifiers?.length) {
+      obj.ownerIdentifiers = message.ownerIdentifiers;
+    }
+    if (message.threshold !== 0) {
+      obj.threshold = Math.round(message.threshold);
+    }
+    if (message.publicKey.length !== 0) {
+      obj.publicKey = base64FromBytes(message.publicKey);
+    }
+    return obj;
+  },
+  create(base) {
+    return SigningKeyshare.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSigningKeyshare();
+    message.ownerIdentifiers = object.ownerIdentifiers?.map((e) => e) || [];
+    message.threshold = object.threshold ?? 0;
+    message.publicKey = object.publicKey ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseTreeNode() {
+  return {
+    id: "",
+    treeId: "",
+    value: 0,
+    parentNodeId: void 0,
+    nodeTx: new Uint8Array(0),
+    refundTx: new Uint8Array(0),
+    vout: 0,
+    verifyingPublicKey: new Uint8Array(0),
+    ownerIdentityPublicKey: new Uint8Array(0),
+    signingKeyshare: void 0,
+    status: "",
+    network: 0
+  };
+}
+var TreeNode = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.treeId !== "") {
+      writer.uint32(18).string(message.treeId);
+    }
+    if (message.value !== 0) {
+      writer.uint32(24).uint64(message.value);
+    }
+    if (message.parentNodeId !== void 0) {
+      writer.uint32(34).string(message.parentNodeId);
+    }
+    if (message.nodeTx.length !== 0) {
+      writer.uint32(42).bytes(message.nodeTx);
+    }
+    if (message.refundTx.length !== 0) {
+      writer.uint32(50).bytes(message.refundTx);
+    }
+    if (message.vout !== 0) {
+      writer.uint32(56).uint32(message.vout);
+    }
+    if (message.verifyingPublicKey.length !== 0) {
+      writer.uint32(66).bytes(message.verifyingPublicKey);
+    }
+    if (message.ownerIdentityPublicKey.length !== 0) {
+      writer.uint32(74).bytes(message.ownerIdentityPublicKey);
+    }
+    if (message.signingKeyshare !== void 0) {
+      SigningKeyshare.encode(message.signingKeyshare, writer.uint32(82).fork()).join();
+    }
+    if (message.status !== "") {
+      writer.uint32(90).string(message.status);
+    }
+    if (message.network !== 0) {
+      writer.uint32(96).int32(message.network);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTreeNode();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.id = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.treeId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.value = longToNumber(reader.uint64());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.parentNodeId = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.nodeTx = reader.bytes();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.refundTx = reader.bytes();
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+          message.vout = reader.uint32();
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+          message.verifyingPublicKey = reader.bytes();
+          continue;
+        }
+        case 9: {
+          if (tag !== 74) {
+            break;
+          }
+          message.ownerIdentityPublicKey = reader.bytes();
+          continue;
+        }
+        case 10: {
+          if (tag !== 82) {
+            break;
+          }
+          message.signingKeyshare = SigningKeyshare.decode(reader, reader.uint32());
+          continue;
+        }
+        case 11: {
+          if (tag !== 90) {
+            break;
+          }
+          message.status = reader.string();
+          continue;
+        }
+        case 12: {
+          if (tag !== 96) {
+            break;
+          }
+          message.network = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      id: isSet(object.id) ? globalThis.String(object.id) : "",
+      treeId: isSet(object.treeId) ? globalThis.String(object.treeId) : "",
+      value: isSet(object.value) ? globalThis.Number(object.value) : 0,
+      parentNodeId: isSet(object.parentNodeId) ? globalThis.String(object.parentNodeId) : void 0,
+      nodeTx: isSet(object.nodeTx) ? bytesFromBase64(object.nodeTx) : new Uint8Array(0),
+      refundTx: isSet(object.refundTx) ? bytesFromBase64(object.refundTx) : new Uint8Array(0),
+      vout: isSet(object.vout) ? globalThis.Number(object.vout) : 0,
+      verifyingPublicKey: isSet(object.verifyingPublicKey) ? bytesFromBase64(object.verifyingPublicKey) : new Uint8Array(0),
+      ownerIdentityPublicKey: isSet(object.ownerIdentityPublicKey) ? bytesFromBase64(object.ownerIdentityPublicKey) : new Uint8Array(0),
+      signingKeyshare: isSet(object.signingKeyshare) ? SigningKeyshare.fromJSON(object.signingKeyshare) : void 0,
+      status: isSet(object.status) ? globalThis.String(object.status) : "",
+      network: isSet(object.network) ? networkFromJSON(object.network) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.treeId !== "") {
+      obj.treeId = message.treeId;
+    }
+    if (message.value !== 0) {
+      obj.value = Math.round(message.value);
+    }
+    if (message.parentNodeId !== void 0) {
+      obj.parentNodeId = message.parentNodeId;
+    }
+    if (message.nodeTx.length !== 0) {
+      obj.nodeTx = base64FromBytes(message.nodeTx);
+    }
+    if (message.refundTx.length !== 0) {
+      obj.refundTx = base64FromBytes(message.refundTx);
+    }
+    if (message.vout !== 0) {
+      obj.vout = Math.round(message.vout);
+    }
+    if (message.verifyingPublicKey.length !== 0) {
+      obj.verifyingPublicKey = base64FromBytes(message.verifyingPublicKey);
+    }
+    if (message.ownerIdentityPublicKey.length !== 0) {
+      obj.ownerIdentityPublicKey = base64FromBytes(message.ownerIdentityPublicKey);
+    }
+    if (message.signingKeyshare !== void 0) {
+      obj.signingKeyshare = SigningKeyshare.toJSON(message.signingKeyshare);
+    }
+    if (message.status !== "") {
+      obj.status = message.status;
+    }
+    if (message.network !== 0) {
+      obj.network = networkToJSON(message.network);
+    }
+    return obj;
+  },
+  create(base) {
+    return TreeNode.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTreeNode();
+    message.id = object.id ?? "";
+    message.treeId = object.treeId ?? "";
+    message.value = object.value ?? 0;
+    message.parentNodeId = object.parentNodeId ?? void 0;
+    message.nodeTx = object.nodeTx ?? new Uint8Array(0);
+    message.refundTx = object.refundTx ?? new Uint8Array(0);
+    message.vout = object.vout ?? 0;
+    message.verifyingPublicKey = object.verifyingPublicKey ?? new Uint8Array(0);
+    message.ownerIdentityPublicKey = object.ownerIdentityPublicKey ?? new Uint8Array(0);
+    message.signingKeyshare = object.signingKeyshare !== void 0 && object.signingKeyshare !== null ? SigningKeyshare.fromPartial(object.signingKeyshare) : void 0;
+    message.status = object.status ?? "";
+    message.network = object.network ?? 0;
+    return message;
+  }
+};
+function createBaseSparkAddress() {
+  return { identityPublicKey: new Uint8Array(0), paymentIntentFields: void 0 };
+}
+var SparkAddress = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.identityPublicKey.length !== 0) {
+      writer.uint32(10).bytes(message.identityPublicKey);
+    }
+    if (message.paymentIntentFields !== void 0) {
+      PaymentIntentFields.encode(message.paymentIntentFields, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSparkAddress();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.identityPublicKey = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.paymentIntentFields = PaymentIntentFields.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      identityPublicKey: isSet(object.identityPublicKey) ? bytesFromBase64(object.identityPublicKey) : new Uint8Array(0),
+      paymentIntentFields: isSet(object.paymentIntentFields) ? PaymentIntentFields.fromJSON(object.paymentIntentFields) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.identityPublicKey.length !== 0) {
+      obj.identityPublicKey = base64FromBytes(message.identityPublicKey);
+    }
+    if (message.paymentIntentFields !== void 0) {
+      obj.paymentIntentFields = PaymentIntentFields.toJSON(message.paymentIntentFields);
+    }
+    return obj;
+  },
+  create(base) {
+    return SparkAddress.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSparkAddress();
+    message.identityPublicKey = object.identityPublicKey ?? new Uint8Array(0);
+    message.paymentIntentFields = object.paymentIntentFields !== void 0 && object.paymentIntentFields !== null ? PaymentIntentFields.fromPartial(object.paymentIntentFields) : void 0;
+    return message;
+  }
+};
+function createBasePaymentIntentFields() {
+  return { id: new Uint8Array(0), assetIdentifier: void 0, assetAmount: new Uint8Array(0), memo: void 0 };
+}
+var PaymentIntentFields = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.id.length !== 0) {
+      writer.uint32(10).bytes(message.id);
+    }
+    if (message.assetIdentifier !== void 0) {
+      writer.uint32(18).bytes(message.assetIdentifier);
+    }
+    if (message.assetAmount.length !== 0) {
+      writer.uint32(26).bytes(message.assetAmount);
+    }
+    if (message.memo !== void 0) {
+      writer.uint32(34).string(message.memo);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBasePaymentIntentFields();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.id = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.assetIdentifier = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.assetAmount = reader.bytes();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.memo = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      id: isSet(object.id) ? bytesFromBase64(object.id) : new Uint8Array(0),
+      assetIdentifier: isSet(object.assetIdentifier) ? bytesFromBase64(object.assetIdentifier) : void 0,
+      assetAmount: isSet(object.assetAmount) ? bytesFromBase64(object.assetAmount) : new Uint8Array(0),
+      memo: isSet(object.memo) ? globalThis.String(object.memo) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.id.length !== 0) {
+      obj.id = base64FromBytes(message.id);
+    }
+    if (message.assetIdentifier !== void 0) {
+      obj.assetIdentifier = base64FromBytes(message.assetIdentifier);
+    }
+    if (message.assetAmount.length !== 0) {
+      obj.assetAmount = base64FromBytes(message.assetAmount);
+    }
+    if (message.memo !== void 0) {
+      obj.memo = message.memo;
+    }
+    return obj;
+  },
+  create(base) {
+    return PaymentIntentFields.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBasePaymentIntentFields();
+    message.id = object.id ?? new Uint8Array(0);
+    message.assetIdentifier = object.assetIdentifier ?? void 0;
+    message.assetAmount = object.assetAmount ?? new Uint8Array(0);
+    message.memo = object.memo ?? void 0;
+    return message;
+  }
+};
+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 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 isSet(value) {
+  return value !== null && value !== void 0;
+}
+
 // src/graphql/objects/BitcoinNetwork.ts
 var BitcoinNetwork = /* @__PURE__ */ ((BitcoinNetwork2) => {
   BitcoinNetwork2["FUTURE_VALUE"] = "FUTURE_VALUE";
@@ -372,6 +940,14 @@ function getNetworkFromAddress(address2) {
   }
   return null;
 }
+function getNetworkFromString(network) {
+  const net = (network ?? "REGTEST").toUpperCase();
+  if (net === "MAINNET") return 0 /* MAINNET */;
+  if (net === "TESTNET") return 1 /* TESTNET */;
+  if (net === "SIGNET") return 2 /* SIGNET */;
+  if (net === "LOCAL") return 4 /* LOCAL */;
+  return 3 /* REGTEST */;
+}
 
 // src/utils/bitcoin.ts
 function computeTaprootKeyNoScript(pubkey) {
@@ -743,6 +1319,7 @@ var BASE_CONFIG = {
   threshold: 2,
   signingOperators: getLocalSigningOperators(),
   tokenSignatures: "SCHNORR",
+  tokenTransactionVersion: "V0",
   electrsUrl: getElectrsUrl("LOCAL"),
   expectedWithdrawBondSats: 1e4,
   expectedWithdrawRelativeBlockLocktime: 1e3,
@@ -921,6 +1498,23 @@ async function getLatestDepositTxId(address2) {
   }
   return null;
 }
+async function isTxBroadcast(txid, baseUrl, network) {
+  const headers = {};
+  if (network === 3 /* REGTEST */) {
+    const auth = btoa(
+      `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`
+    );
+    headers["Authorization"] = `Basic ${auth}`;
+  }
+  const response = await fetch(`${baseUrl}/tx/${txid}`, {
+    headers
+  });
+  const tx = await response.json();
+  if (tx.error) {
+    return false;
+  }
+  return true;
+}
 
 // src/utils/proof.ts
 var import_sha22 = require("@noble/hashes/sha2");
@@ -1316,8 +1910,20 @@ function getTransferPackageSigningPayload(transferID, transferPackage) {
 // src/utils/transaction.ts
 var import_btc_signer = require("@scure/btc-signer");
 var TIME_LOCK_INTERVAL = 100;
+var ESTIMATED_TX_SIZE = 191;
+var DEFAULT_SATS_PER_VBYTE = 5;
+var DEFAULT_FEE_SATS = ESTIMATED_TX_SIZE * DEFAULT_SATS_PER_VBYTE;
+function maybeApplyFee(amount) {
+  if (amount > BigInt(DEFAULT_FEE_SATS)) {
+    return amount - BigInt(DEFAULT_FEE_SATS);
+  }
+  return amount;
+}
 function createRefundTx(sequence, nodeOutPoint, amountSats, receivingPubkey, network) {
-  const newRefundTx = new import_btc_signer.Transaction({ allowUnknownOutputs: true });
+  const newRefundTx = new import_btc_signer.Transaction({
+    version: 3,
+    allowUnknownOutputs: true
+  });
   newRefundTx.addInput({
     ...nodeOutPoint,
     sequence
@@ -1337,17 +1943,35 @@ function getTransactionSequence(currSequence) {
   const timelock = getCurrentTimelock(currSequence);
   return 1 << 30 | timelock;
 }
+function checkIfValidSequence(currSequence) {
+  const TIME_LOCK_ACTIVE = (currSequence || 0) & 2147483648;
+  if (TIME_LOCK_ACTIVE !== 0) {
+    throw new ValidationError("Timelock not active", {
+      field: "currSequence",
+      value: currSequence
+    });
+  }
+  const RELATIVE_TIME_LOCK_ACTIVE = (currSequence || 0) & 4194304;
+  if (RELATIVE_TIME_LOCK_ACTIVE !== 0) {
+    throw new ValidationError("Block based timelock not active", {
+      field: "currSequence",
+      value: currSequence
+    });
+  }
+}
 function getNextTransactionSequence(currSequence, forRefresh) {
+  checkIfValidSequence(currSequence);
   const currentTimelock = getCurrentTimelock(currSequence);
   const nextTimelock = currentTimelock - TIME_LOCK_INTERVAL;
+  checkIfValidSequence(nextTimelock);
   if (forRefresh && nextTimelock <= 100 && currentTimelock > 0) {
     return {
       nextSequence: 1 << 30 | nextTimelock,
       needRefresh: true
     };
   }
-  if (nextTimelock <= 0) {
-    throw new ValidationError("timelock interval is less than or equal to 0", {
+  if (nextTimelock < 100) {
+    throw new ValidationError("timelock interval is less than 100", {
       field: "nextTimelock",
       value: nextTimelock
     });
@@ -1364,8 +1988,541 @@ function getEphemeralAnchorOutput() {
     amount: 0n
   };
 }
+
+// src/utils/unilateral-exit.ts
+var import_utils8 = require("@noble/curves/abstract/utils");
+var import_legacy = require("@noble/hashes/legacy");
+var import_sha24 = require("@noble/hashes/sha2");
+var btc3 = __toESM(require("@scure/btc-signer"), 1);
+function isEphemeralAnchorOutput(script, amount) {
+  return Boolean(
+    amount === 0n && script && // Pattern 1: Bare OP_TRUE (single byte 0x51)
+    (script.length === 1 && script[0] === 81 || // Pattern 2: Push OP_TRUE (two bytes 0x01 0x51) - MALFORMED but we detect it
+    script.length === 2 && script[0] === 1 && script[1] === 81 || // Pattern 3: Bitcoin v29 ephemeral anchor script (7 bytes: 015152014e0173)
+    script.length === 7 && script[0] === 1 && script[1] === 81 && script[2] === 82 && script[3] === 1 && script[4] === 78 && script[5] === 1 && script[6] === 115 || // Pattern 4: Bitcoin ephemeral anchor OP_1 + push 2 bytes (4 bytes: 51024e73)
+    script.length === 4 && script[0] === 81 && script[1] === 2 && script[2] === 78 && script[3] === 115)
+  );
+}
+async function constructUnilateralExitTxs(nodeHexStrings, sparkClient, network) {
+  const result = [];
+  const nodes = nodeHexStrings.map((hex) => TreeNode.decode((0, import_utils8.hexToBytes)(hex)));
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    nodeMap.set(node.id, node);
+  }
+  for (const node of nodes) {
+    const transactions = [];
+    const chain = [];
+    let currentNode = node;
+    while (currentNode) {
+      chain.unshift(currentNode);
+      if (currentNode.parentNodeId) {
+        let parentNode = nodeMap.get(currentNode.parentNodeId);
+        if (!parentNode && sparkClient) {
+          try {
+            const response = await sparkClient.query_nodes({
+              source: {
+                $case: "nodeIds",
+                nodeIds: {
+                  nodeIds: [currentNode.parentNodeId]
+                }
+              },
+              includeParents: true,
+              network: network || 0
+              // Default to mainnet if not provided
+            });
+            parentNode = response.nodes[currentNode.parentNodeId];
+            if (parentNode) {
+              nodeMap.set(currentNode.parentNodeId, parentNode);
+            }
+          } catch (error) {
+            console.warn(
+              `Failed to query parent node ${currentNode.parentNodeId}: ${error}`
+            );
+            break;
+          }
+        }
+        if (parentNode) {
+          currentNode = parentNode;
+        } else {
+          if (!sparkClient) {
+            console.warn(
+              `Parent node ${currentNode.parentNodeId} not found. Provide a sparkClient to fetch missing parents.`
+            );
+          } else {
+            console.warn(
+              `Parent node ${currentNode.parentNodeId} not found in database. Chain may be incomplete.`
+            );
+          }
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    for (const chainNode of chain) {
+      const nodeTx = (0, import_utils8.bytesToHex)(chainNode.nodeTx);
+      transactions.push(nodeTx);
+      if (chainNode.id === node.id) {
+        const refundTx = (0, import_utils8.bytesToHex)(chainNode.refundTx);
+        transactions.push(refundTx);
+      }
+    }
+    result.push({
+      leafId: node.id,
+      transactions
+    });
+  }
+  return result;
+}
+async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, feeRate, electrsUrl, sparkClient, network) {
+  const result = [];
+  const availableUtxos = [...utxos].sort((a, b) => {
+    if (a.value > b.value) return -1;
+    if (a.value < b.value) return 1;
+    return 0;
+  });
+  const nodes = [];
+  for (let i = 0; i < nodeHexStrings.length; i++) {
+    const hex = nodeHexStrings[i];
+    try {
+      if (!hex || hex.length === 0) {
+        throw new Error(`Node hex string at index ${i} is empty`);
+      }
+      if (hex.startsWith("03000000") || hex.startsWith("02000000") || hex.startsWith("01000000")) {
+        throw new Error(
+          `Node hex string at index ${i} appears to be a raw transaction hex, not a TreeNode protobuf. Use 'leafidtohex' command to convert node IDs to proper hex strings.`
+        );
+      }
+      const nodeBytes = (0, import_utils8.hexToBytes)(hex);
+      const node = TreeNode.decode(nodeBytes);
+      if (!node.id) {
+        throw new Error(
+          `Decoded TreeNode at index ${i} is missing required 'id' field`
+        );
+      }
+      if (!node.nodeTx || node.nodeTx.length === 0) {
+        throw new Error(
+          `Decoded TreeNode at index ${i} is missing required 'nodeTx' field`
+        );
+      }
+      nodes.push(node);
+    } catch (decodeError) {
+      throw new Error(
+        `Failed to decode TreeNode hex string at index ${i}: ${decodeError}. Make sure you're providing TreeNode protobuf hex strings, not raw transaction hex. Use 'leafidtohex' command to get proper hex strings.`
+      );
+    }
+  }
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    nodeMap.set(node.id, node);
+  }
+  const broadcastTxs = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const txPackages = [];
+    let previousFeeBumpTx;
+    const chain = [];
+    let currentNode = node;
+    while (currentNode) {
+      chain.unshift(currentNode);
+      if (currentNode.parentNodeId) {
+        let parentNode = nodeMap.get(currentNode.parentNodeId);
+        if (!parentNode && sparkClient) {
+          try {
+            const response = await sparkClient.query_nodes({
+              source: {
+                $case: "nodeIds",
+                nodeIds: {
+                  nodeIds: [currentNode.parentNodeId]
+                }
+              },
+              includeParents: true,
+              network: network || 0
+              // Default to mainnet if not provided
+            });
+            parentNode = response.nodes[currentNode.parentNodeId];
+            if (parentNode) {
+              nodeMap.set(currentNode.parentNodeId, parentNode);
+            }
+          } catch (error) {
+            console.warn(
+              `Failed to query parent node ${currentNode.parentNodeId}: ${error}`
+            );
+            break;
+          }
+        }
+        if (parentNode) {
+          currentNode = parentNode;
+        } else {
+          if (!sparkClient) {
+            console.warn(
+              `Parent node ${currentNode.parentNodeId} not found. Provide a sparkClient to fetch missing parents.`
+            );
+          } else {
+            console.warn(
+              `Parent node ${currentNode.parentNodeId} not found in database. Chain may be incomplete.`
+            );
+          }
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    for (const chainNode of chain) {
+      let nodeTxHex = (0, import_utils8.bytesToHex)(chainNode.nodeTx);
+      try {
+        const txObj = getTxFromRawTxHex(nodeTxHex);
+        const txid = getTxId(txObj);
+        if (broadcastTxs.get(txid)) {
+          continue;
+        }
+        broadcastTxs.set(txid, true);
+        const isBroadcast = await isTxBroadcast(txid, electrsUrl, network);
+        if (isBroadcast) {
+          continue;
+        } else {
+        }
+        let anchorOutputScriptHex;
+        for (let i = txObj.outputsLength - 1; i >= 0; i--) {
+          const output = txObj.getOutput(i);
+          if (output?.amount === 0n && output.script) {
+            anchorOutputScriptHex = (0, import_utils8.bytesToHex)(output.script);
+            break;
+          }
+        }
+      } catch (parseError) {
+        console.error(
+          `\u274C Error parsing nodeTx for anchor check (node ${chainNode.id}): ${parseError}`
+        );
+        console.log(
+          `    This may indicate a corrupted transaction in the TreeNode.`
+        );
+        console.log(`    Transaction hex: ${nodeTxHex}`);
+        console.log(
+          `    Attempting to continue with original hex, but fee bump may fail.`
+        );
+      }
+      const {
+        feeBumpPsbt: nodeFeeBumpPsbt,
+        usedUtxos,
+        correctedParentTx
+      } = constructFeeBumpTx(nodeTxHex, availableUtxos, feeRate, void 0);
+      const feeBumpTx = btc3.Transaction.fromPSBT((0, import_utils8.hexToBytes)(nodeFeeBumpPsbt));
+      var feeBumpOut = feeBumpTx.outputsLength === 1 ? feeBumpTx.getOutput(0) : null;
+      var feeBumpOutPubKey = null;
+      for (const usedUtxo of usedUtxos) {
+        if (feeBumpOut && (0, import_utils8.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
+          feeBumpOutPubKey = usedUtxo.publicKey;
+        }
+        const index = availableUtxos.findIndex(
+          (u) => u.txid === usedUtxo.txid && u.vout === usedUtxo.vout
+        );
+        if (index !== -1) {
+          availableUtxos.splice(index, 1);
+        }
+      }
+      if (feeBumpOut)
+        availableUtxos.unshift({
+          txid: getTxId(feeBumpTx),
+          vout: 0,
+          value: feeBumpOut.amount,
+          script: (0, import_utils8.bytesToHex)(feeBumpOut.script),
+          publicKey: feeBumpOutPubKey
+        });
+      const finalNodeTx = correctedParentTx || nodeTxHex;
+      txPackages.push({ tx: finalNodeTx, feeBumpPsbt: nodeFeeBumpPsbt });
+      if (chainNode.id === node.id) {
+        let refundTxHex = (0, import_utils8.bytesToHex)(chainNode.refundTx);
+        try {
+          const txObj = getTxFromRawTxHex(refundTxHex);
+          let anchorOutputScriptHex;
+          for (let i = txObj.outputsLength - 1; i >= 0; i--) {
+            const output = txObj.getOutput(i);
+            if (output?.amount === 0n && output.script) {
+              anchorOutputScriptHex = (0, import_utils8.bytesToHex)(output.script);
+              break;
+            }
+          }
+        } catch (parseError) {
+          console.error(
+            `\u274C Error parsing refundTx for anchor check (node ${chainNode.id}): ${parseError}`
+          );
+          console.log(
+            `    This may indicate a corrupted refund transaction in the TreeNode.`
+          );
+          console.log(`    Refund transaction hex: ${refundTxHex}`);
+          console.log(
+            `    Attempting to continue with original refund hex, but this transaction may be invalid.`
+          );
+        }
+        const refundFeeBump = constructFeeBumpTx(
+          refundTxHex,
+          availableUtxos,
+          feeRate,
+          void 0
+        );
+        txPackages.push({
+          tx: refundTxHex,
+          feeBumpPsbt: refundFeeBump.feeBumpPsbt
+        });
+      }
+    }
+    result.push({
+      leafId: node.id,
+      txPackages
+    });
+  }
+  return result;
+}
+function hash160(data) {
+  const sha256Hash = (0, import_sha24.sha256)(data);
+  return (0, import_legacy.ripemd160)(sha256Hash);
+}
+function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
+  if (!txHex || txHex.length === 0) {
+    throw new Error("Transaction hex string is empty or undefined");
+  }
+  if (utxos.length === 0) {
+    throw new Error("No UTXOs available for fee bump");
+  }
+  let correctedTxHex = txHex;
+  let parentTx;
+  try {
+    parentTx = getTxFromRawTxHex(correctedTxHex);
+    if (!parentTx) {
+      throw new Error("getTxFromRawTxHex returned null/undefined");
+    }
+  } catch (parseError) {
+    throw new Error(
+      `Failed to parse parent transaction hex: ${parseError}. Transaction hex: ${correctedTxHex}`
+    );
+  }
+  try {
+    const outputsLength = parentTx.outputsLength;
+    const inputsLength = parentTx.inputsLength;
+    if (typeof outputsLength !== "number" || outputsLength < 0) {
+      throw new Error(
+        "Invalid transaction: outputsLength is not a valid number"
+      );
+    }
+    if (typeof inputsLength !== "number" || inputsLength < 0) {
+      throw new Error(
+        "Invalid transaction: inputsLength is not a valid number"
+      );
+    }
+  } catch (validationError) {
+    throw new Error(
+      `Transaction validation failed: ${validationError}. This may indicate a corrupted or malformed transaction.`
+    );
+  }
+  const parentTxIdFromLib = parentTx.id;
+  let ephemeralAnchorIndex = -1;
+  for (let i = 0; i < parentTx.outputsLength; i++) {
+    const output = parentTx.getOutput(i);
+    const isEphemeralAnchor = isEphemeralAnchorOutput(
+      output?.script,
+      output?.amount
+    );
+    if (isEphemeralAnchor) {
+      ephemeralAnchorIndex = i;
+      break;
+    }
+  }
+  if (ephemeralAnchorIndex === -1) {
+    throw new Error(
+      "No ephemeral anchor output found in parent transaction. Expected a 0-value output with OP_TRUE script (0x51), malformed OP_TRUE (0x0151), Bitcoin v29 ephemeral anchor script (015152014e0173), or Bitcoin OP_1 + push 2 bytes script (51024e73)."
+    );
+  }
+  const ephemeralAnchorOutput = parentTx.getOutput(ephemeralAnchorIndex);
+  if (!ephemeralAnchorOutput)
+    throw new Error("No ephemeral anchor output found");
+  if (!ephemeralAnchorOutput.script)
+    throw new Error("No script found in ephemeral anchor output");
+  if (utxos.length === 0) {
+    throw new Error("No UTXOs available for fee bump");
+  }
+  const builder = new btc3.Transaction({
+    version: 3,
+    allowUnknown: true,
+    allowLegacyWitnessUtxo: true
+  });
+  let totalValue = 0n;
+  const processedUtxos = [];
+  for (let i = 0; i < utxos.length; i++) {
+    const fundingUtxo = utxos[i];
+    if (!fundingUtxo) {
+      throw new Error(`UTXO at index ${i} is undefined`);
+    }
+    const pubKeyHash = hash160((0, import_utils8.hexToBytes)(fundingUtxo.publicKey));
+    const scriptToUse = new Uint8Array([0, 20, ...pubKeyHash]);
+    const providedScript = (0, import_utils8.hexToBytes)(fundingUtxo.script);
+    if ((0, import_utils8.bytesToHex)(scriptToUse) !== (0, import_utils8.bytesToHex)(providedScript)) {
+      throw new Error(
+        `\u274C  Derived script doesn't match provided script for UTXO ${i + 1}.`
+      );
+    }
+    builder.addInput({
+      txid: fundingUtxo.txid,
+      index: fundingUtxo.vout,
+      sequence: 4294967295,
+      witnessUtxo: {
+        script: scriptToUse,
+        // Always P2WPKH
+        amount: fundingUtxo.value
+      }
+    });
+    totalValue += fundingUtxo.value;
+    processedUtxos.push({
+      utxo: fundingUtxo,
+      p2wpkhScript: scriptToUse
+    });
+  }
+  builder.addInput({
+    txid: parentTxIdFromLib,
+    index: ephemeralAnchorIndex,
+    sequence: 4294967295,
+    witnessUtxo: {
+      script: ephemeralAnchorOutput.script,
+      // Use the original script directly (not P2WSH wrapped)
+      amount: 0n
+    }
+  });
+  const fee = 1500n;
+  const remainingValue = totalValue - fee;
+  if (remainingValue <= 0n) {
+    throw new Error(
+      `Insufficient funds for fee bump. Required fee: ${fee} sats, Available: ${totalValue} sats`
+    );
+  }
+  if (processedUtxos.length === 0) {
+    throw new Error("No processed UTXOs available for change output");
+  }
+  const firstProcessedUtxo = processedUtxos[0];
+  if (!firstProcessedUtxo) {
+    throw new Error("First processed UTXO is undefined");
+  }
+  builder.addOutput({
+    script: firstProcessedUtxo.p2wpkhScript,
+    amount: remainingValue
+  });
+  for (let i = 0; i < processedUtxos.length; i++) {
+    const processed = processedUtxos[i];
+    if (!processed) {
+      throw new Error(`Processed UTXO at index ${i} is undefined`);
+    }
+    try {
+      builder.updateInput(i, {
+        witnessScript: processed.p2wpkhScript
+      });
+      builder.signIdx;
+    } catch (error) {
+      throw new Error(`Failed to handle funding UTXO input ${i + 1}: ${error}`);
+    }
+  }
+  let psbtHex;
+  try {
+    psbtHex = (0, import_utils8.bytesToHex)(builder.toPSBT());
+  } catch (error) {
+    throw new Error(`Failed to extract transaction: ${error}`);
+  }
+  return {
+    feeBumpPsbt: psbtHex,
+    usedUtxos: utxos,
+    correctedParentTx: correctedTxHex !== txHex ? correctedTxHex : void 0
+  };
+}
+
+// src/address/address.ts
+var import_secp256k16 = require("@noble/curves/secp256k1");
+var import_utils9 = require("@noble/hashes/utils");
+var import_base2 = require("@scure/base");
+var import_uuidv7 = require("uuidv7");
+var import_utils10 = require("@noble/curves/abstract/utils");
+var AddressNetwork = {
+  MAINNET: "sp",
+  TESTNET: "spt",
+  REGTEST: "sprt",
+  SIGNET: "sps",
+  LOCAL: "spl"
+};
+function encodeSparkAddress(payload) {
+  try {
+    isValidPublicKey(payload.identityPublicKey);
+    let paymentIntentFields;
+    if (payload.paymentIntentFields) {
+      paymentIntentFields = payload.paymentIntentFields;
+    }
+    const sparkAddressProto = SparkAddress.create({
+      identityPublicKey: (0, import_utils9.hexToBytes)(payload.identityPublicKey),
+      paymentIntentFields
+    });
+    const serializedPayload = SparkAddress.encode(sparkAddressProto).finish();
+    const words = import_base2.bech32m.toWords(serializedPayload);
+    return import_base2.bech32m.encode(
+      AddressNetwork[payload.network],
+      words,
+      500
+    );
+  } catch (error) {
+    throw new ValidationError(
+      "Failed to encode Spark address",
+      {
+        field: "publicKey",
+        value: payload.identityPublicKey
+      },
+      error
+    );
+  }
+}
+function isValidPublicKey(publicKey) {
+  try {
+    const point = import_secp256k16.secp256k1.ProjectivePoint.fromHex(publicKey);
+    point.assertValidity();
+  } catch (error) {
+    throw new ValidationError(
+      "Invalid public key",
+      {
+        field: "publicKey",
+        value: publicKey
+      },
+      error
+    );
+  }
+}
+
+// src/utils/xchain-address.ts
+var btc4 = __toESM(require("@scure/btc-signer"), 1);
+var networkByType = {
+  MAINNET: btc4.NETWORK,
+  TESTNET: btc4.TEST_NETWORK,
+  REGTEST: {
+    ...btc4.TEST_NETWORK,
+    bech32: "bcrt"
+  }
+};
+function getSparkAddressFromTaproot(taprootAddress) {
+  for (const networkType of ["MAINNET", "TESTNET", "REGTEST"]) {
+    try {
+      const result = btc4.Address(networkByType[networkType]).decode(taprootAddress);
+      if (result.type === "tr") {
+        const outputPublicKey = result.pubkey;
+        return encodeSparkAddress({
+          identityPublicKey: import_buffer.Buffer.concat([
+            import_buffer.Buffer.from([2]),
+            outputPublicKey
+          ]).toString("hex"),
+          network: networkType
+        });
+      }
+    } catch (_) {
+    }
+  }
+  throw new ValidationError("Invalid taproot address");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_FEE_SATS,
   LRC_WALLET_NETWORK,
   LRC_WALLET_NETWORK_TYPE,
   Network,
@@ -1377,9 +2534,13 @@ function getEphemeralAnchorOutput() {
   bigIntToPrivateKey,
   calculateAvailableTokenAmount,
   checkIfSelectedOutputsAreAvailable,
+  checkIfValidSequence,
   collectResponses,
   computeTaprootKeyNoScript,
   computerLagrangeCoefficients,
+  constructFeeBumpTx,
+  constructUnilateralExitFeeBumpPackages,
+  constructUnilateralExitTxs,
   createRefundTx,
   createSigningCommitment,
   createSigningNonce,
@@ -1398,6 +2559,7 @@ function getEphemeralAnchorOutput() {
   getLatestDepositTxId,
   getNetwork,
   getNetworkFromAddress,
+  getNetworkFromString,
   getNextTransactionSequence,
   getP2TRAddressFromPkScript,
   getP2TRAddressFromPublicKey,
@@ -1407,13 +2569,17 @@ function getEphemeralAnchorOutput() {
   getRandomSigningNonce,
   getSigHashFromTx,
   getSigningCommitmentFromNonce,
+  getSparkAddressFromTaproot,
   getTransactionSequence,
   getTransferPackageSigningPayload,
   getTxFromRawTxBytes,
   getTxFromRawTxHex,
   getTxId,
   getTxIdNoReverse,
+  isEphemeralAnchorOutput,
+  isTxBroadcast,
   lastKeyWithTarget,
+  maybeApplyFee,
   modInverse,
   proofOfPossessionMessageHashForDepositAddress,
   recoverSecret,