@fiber-pay/sdk 0.1.0-rc.1

package/dist/chunk-QQDMPGVR.js

@@ -0,0 +1,723 @@
+// src/address.ts
+var BECH32_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+function bech32mPolymod(values) {
+  const GEN = [996825010, 642813549, 513874426, 1027748829, 705979059];
+  let chk = 1;
+  for (const v of values) {
+    const top = chk >> 25;
+    chk = (chk & 33554431) << 5 ^ v;
+    for (let i = 0; i < 5; i++) {
+      if (top >> i & 1) {
+        chk ^= GEN[i];
+      }
+    }
+  }
+  return chk;
+}
+function bech32mHrpExpand(hrp) {
+  const ret = [];
+  for (let i = 0; i < hrp.length; i++) {
+    ret.push(hrp.charCodeAt(i) >> 5);
+  }
+  ret.push(0);
+  for (let i = 0; i < hrp.length; i++) {
+    ret.push(hrp.charCodeAt(i) & 31);
+  }
+  return ret;
+}
+function bech32mCreateChecksum(hrp, data) {
+  const values = bech32mHrpExpand(hrp).concat(data).concat([0, 0, 0, 0, 0, 0]);
+  const polymod = bech32mPolymod(values) ^ 734539939;
+  const ret = [];
+  for (let i = 0; i < 6; i++) {
+    ret.push(polymod >> 5 * (5 - i) & 31);
+  }
+  return ret;
+}
+function convertBits(data, fromBits, toBits, pad) {
+  let acc = 0;
+  let bits = 0;
+  const ret = [];
+  const maxv = (1 << toBits) - 1;
+  for (const value of data) {
+    acc = acc << fromBits | value;
+    bits += fromBits;
+    while (bits >= toBits) {
+      bits -= toBits;
+      ret.push(acc >> bits & maxv);
+    }
+  }
+  if (pad && bits > 0) {
+    ret.push(acc << toBits - bits & maxv);
+  }
+  return ret;
+}
+function bech32mEncode(hrp, data) {
+  const checksum = bech32mCreateChecksum(hrp, data);
+  const combined = data.concat(checksum);
+  let result = `${hrp}1`;
+  for (const d of combined) {
+    result += BECH32_CHARSET[d];
+  }
+  return result;
+}
+function scriptToAddress(script, network) {
+  const hrp = network === "mainnet" ? "ckb" : "ckt";
+  const hashTypeByte = script.hash_type === "type" ? 1 : script.hash_type === "data" ? 0 : script.hash_type === "data1" ? 2 : 4;
+  const codeHash = script.code_hash.startsWith("0x") ? script.code_hash.slice(2) : script.code_hash;
+  const args = script.args.startsWith("0x") ? script.args.slice(2) : script.args;
+  const payload = new Uint8Array(1 + 32 + 1 + args.length / 2);
+  payload[0] = 0;
+  for (let i = 0; i < 32; i++) {
+    payload[1 + i] = parseInt(codeHash.slice(i * 2, i * 2 + 2), 16);
+  }
+  payload[33] = hashTypeByte;
+  for (let i = 0; i < args.length / 2; i++) {
+    payload[34 + i] = parseInt(args.slice(i * 2, i * 2 + 2), 16);
+  }
+  const data = convertBits(payload, 8, 5, true);
+  return bech32mEncode(hrp, data);
+}
+
+// src/types/rpc.ts
+var ChannelState = /* @__PURE__ */ ((ChannelState2) => {
+  ChannelState2["NegotiatingFunding"] = "NEGOTIATING_FUNDING";
+  ChannelState2["CollaboratingFundingTx"] = "COLLABORATING_FUNDING_TX";
+  ChannelState2["SigningCommitment"] = "SIGNING_COMMITMENT";
+  ChannelState2["AwaitingTxSignatures"] = "AWAITING_TX_SIGNATURES";
+  ChannelState2["AwaitingChannelReady"] = "AWAITING_CHANNEL_READY";
+  ChannelState2["ChannelReady"] = "CHANNEL_READY";
+  ChannelState2["ShuttingDown"] = "SHUTTING_DOWN";
+  ChannelState2["Closed"] = "CLOSED";
+  return ChannelState2;
+})(ChannelState || {});
+
+// src/types/policy.ts
+import { z } from "zod";
+var SpendingLimitSchema = z.object({
+  /** Maximum amount per single transaction (in shannons for CKB, or base units for UDT) */
+  maxPerTransaction: z.string().regex(/^0x[0-9a-fA-F]+$/),
+  /** Maximum total amount per time window */
+  maxPerWindow: z.string().regex(/^0x[0-9a-fA-F]+$/),
+  /** Time window in seconds */
+  windowSeconds: z.number().positive(),
+  /** Current spent amount in window (runtime state) */
+  currentSpent: z.string().regex(/^0x[0-9a-fA-F]+$/).optional(),
+  /** Window start timestamp (runtime state) */
+  windowStart: z.number().optional()
+});
+var RecipientPolicySchema = z.object({
+  /** Allowlist mode: only allow payments to these recipients */
+  allowlist: z.array(z.string()).optional(),
+  /** Blocklist mode: block payments to these recipients */
+  blocklist: z.array(z.string()).optional(),
+  /** Allow payments to unknown recipients (not in allowlist) */
+  allowUnknown: z.boolean().default(true)
+});
+var RateLimitSchema = z.object({
+  /** Maximum number of transactions per window */
+  maxTransactions: z.number().positive(),
+  /** Time window in seconds */
+  windowSeconds: z.number().positive(),
+  /** Cooldown between transactions in seconds */
+  cooldownSeconds: z.number().nonnegative().default(0),
+  /** Current transaction count in window (runtime state) */
+  currentCount: z.number().optional(),
+  /** Window start timestamp (runtime state) */
+  windowStart: z.number().optional(),
+  /** Last transaction timestamp (runtime state) */
+  lastTransaction: z.number().optional()
+});
+var ChannelPolicySchema = z.object({
+  /** Allow opening new channels */
+  allowOpen: z.boolean().default(true),
+  /** Allow closing channels */
+  allowClose: z.boolean().default(true),
+  /** Allow force close */
+  allowForceClose: z.boolean().default(false),
+  /** Maximum funding amount for new channels */
+  maxFundingAmount: z.string().regex(/^0x[0-9a-fA-F]+$/).optional(),
+  /** Minimum funding amount for new channels */
+  minFundingAmount: z.string().regex(/^0x[0-9a-fA-F]+$/).optional(),
+  /** Maximum number of channels */
+  maxChannels: z.number().positive().optional()
+});
+var SecurityPolicySchema = z.object({
+  /** Policy name for identification */
+  name: z.string(),
+  /** Policy version */
+  version: z.string().default("1.0.0"),
+  /** Whether this policy is active */
+  enabled: z.boolean().default(true),
+  /** Spending limits configuration */
+  spending: SpendingLimitSchema.optional(),
+  /** Recipient restrictions */
+  recipients: RecipientPolicySchema.optional(),
+  /** Rate limiting configuration */
+  rateLimit: RateLimitSchema.optional(),
+  /** Channel operation policy */
+  channels: ChannelPolicySchema.optional(),
+  /** Require confirmation for amounts above this threshold */
+  confirmationThreshold: z.string().regex(/^0x[0-9a-fA-F]+$/).optional(),
+  /** Log all transactions to audit log */
+  auditLogging: z.boolean().default(true),
+  /** Custom metadata */
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+
+// src/utils.ts
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function toHex(value) {
+  return `0x${value.toString(16)}`;
+}
+function fromHex(hex) {
+  return BigInt(hex);
+}
+function ckbToShannons(ckb) {
+  const amount = typeof ckb === "string" ? parseFloat(ckb) : ckb;
+  const shannons = BigInt(Math.floor(amount * 1e8));
+  return toHex(shannons);
+}
+function shannonsToCkb(shannons) {
+  return Number(fromHex(shannons)) / 1e8;
+}
+function randomBytes32() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return `0x${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+function base58btcEncode(bytes) {
+  if (bytes.length === 0) return "";
+  let number = 0n;
+  for (const byte of bytes) {
+    number = (number << 8n) + BigInt(byte);
+  }
+  let encoded = "";
+  while (number > 0n) {
+    const remainder = Number(number % 58n);
+    encoded = BASE58_ALPHABET[remainder] + encoded;
+    number /= 58n;
+  }
+  for (let i = 0; i < bytes.length && bytes[i] === 0; i++) {
+    encoded = `1${encoded}`;
+  }
+  return encoded || "1";
+}
+async function nodeIdToPeerId(nodeId) {
+  const normalized = nodeId.trim().replace(/^0x/i, "");
+  if (!/^[0-9a-fA-F]+$/.test(normalized)) {
+    throw new Error("Invalid node id: expected hex string");
+  }
+  if (normalized.length !== 66) {
+    throw new Error(
+      `Invalid node id: expected 33-byte compressed pubkey, got ${normalized.length / 2} bytes`
+    );
+  }
+  const raw = Uint8Array.from(
+    normalized.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) ?? []
+  );
+  if (raw.length !== 33) {
+    throw new Error(`Invalid node id: expected 33-byte compressed pubkey, got ${raw.length} bytes`);
+  }
+  const digestBuffer = await crypto.subtle.digest("SHA-256", raw);
+  const digest = new Uint8Array(digestBuffer);
+  const multihash = new Uint8Array(2 + digest.length);
+  multihash[0] = 18;
+  multihash[1] = 32;
+  multihash.set(digest, 2);
+  return base58btcEncode(multihash);
+}
+function buildMultiaddr(address, peerId) {
+  const normalizedAddress = address.trim();
+  const normalizedPeerId = peerId.trim();
+  if (!normalizedAddress.startsWith("/")) {
+    throw new Error('Invalid multiaddr: expected address starting with "/"');
+  }
+  if (!normalizedPeerId) {
+    throw new Error("Invalid peer id: empty value");
+  }
+  const withoutPeerSuffix = normalizedAddress.replace(/\/p2p\/[^/]+$/, "");
+  return `${withoutPeerSuffix}/p2p/${normalizedPeerId}`;
+}
+async function buildMultiaddrFromNodeId(address, nodeId) {
+  const peerId = await nodeIdToPeerId(nodeId);
+  return buildMultiaddr(address, peerId);
+}
+function buildMultiaddrFromRpcUrl(rpcUrl, peerId) {
+  let parsed;
+  try {
+    parsed = new URL(rpcUrl);
+  } catch {
+    throw new Error(`Invalid RPC URL: ${rpcUrl}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`Unsupported RPC protocol: ${parsed.protocol}`);
+  }
+  const port = parsed.port ? Number.parseInt(parsed.port, 10) : parsed.protocol === "https:" ? 443 : 80;
+  if (!Number.isFinite(port) || port <= 0 || port > 65535) {
+    throw new Error(`Invalid RPC port in URL: ${rpcUrl}`);
+  }
+  const p2pPort = port + 1;
+  if (p2pPort > 65535) {
+    throw new Error(`Cannot infer P2P port from RPC port ${port}`);
+  }
+  const host = parsed.hostname;
+  const isIpv4 = /^\d{1,3}(?:\.\d{1,3}){3}$/.test(host);
+  const isIpv6 = host.includes(":");
+  const base = isIpv4 ? `/ip4/${host}/tcp/${p2pPort}` : isIpv6 ? `/ip6/${host}/tcp/${p2pPort}` : `/dns/${host}/tcp/${p2pPort}`;
+  return buildMultiaddr(base, peerId);
+}
+
+// src/rpc/client.ts
+var FiberRpcError = class _FiberRpcError extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "FiberRpcError";
+  }
+  static fromJsonRpcError(error) {
+    return new _FiberRpcError(error.code, error.message, error.data);
+  }
+};
+var FiberRpcClient = class {
+  requestId = 0;
+  config;
+  channelStateAliases = {
+    NEGOTIATING_FUNDING: "NEGOTIATING_FUNDING" /* NegotiatingFunding */,
+    COLLABORATING_FUNDING_TX: "COLLABORATING_FUNDING_TX" /* CollaboratingFundingTx */,
+    SIGNING_COMMITMENT: "SIGNING_COMMITMENT" /* SigningCommitment */,
+    AWAITING_TX_SIGNATURES: "AWAITING_TX_SIGNATURES" /* AwaitingTxSignatures */,
+    AWAITING_CHANNEL_READY: "AWAITING_CHANNEL_READY" /* AwaitingChannelReady */,
+    CHANNEL_READY: "CHANNEL_READY" /* ChannelReady */,
+    SHUTTING_DOWN: "SHUTTING_DOWN" /* ShuttingDown */,
+    CLOSED: "CLOSED" /* Closed */
+  };
+  constructor(config) {
+    this.config = {
+      timeout: 3e4,
+      ...config
+    };
+  }
+  /**
+   * Make a raw JSON-RPC call
+   *
+   * Useful for advanced/experimental RPCs not wrapped by convenience methods.
+   *
+   * @example
+   * ```ts
+   * const result = await client.call<MyResult>('some_method', [{ foo: 'bar' }]);
+   * ```
+   */
+  async call(method, params = []) {
+    const request = {
+      jsonrpc: "2.0",
+      id: ++this.requestId,
+      method,
+      params
+    };
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.headers
+    };
+    if (this.config.biscuitToken) {
+      headers.Authorization = `Bearer ${this.config.biscuitToken}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(this.config.url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(request),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new FiberRpcError(-32e3, `HTTP error: ${response.status} ${response.statusText}`);
+      }
+      const json = await response.json();
+      if (json.error) {
+        throw FiberRpcError.fromJsonRpcError(json.error);
+      }
+      if (json.result === void 0) {
+        throw new FiberRpcError(-32e3, "Invalid JSON-RPC response: missing result and error");
+      }
+      return json.result;
+    } catch (error) {
+      if (error instanceof FiberRpcError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new FiberRpcError(-32e3, "Request timeout");
+        }
+        throw new FiberRpcError(-32e3, error.message);
+      }
+      throw new FiberRpcError(-32e3, "Unknown error");
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  // ===========================================================================
+  // Peer Module
+  // ===========================================================================
+  /**
+   * Connect to a peer
+   */
+  async connectPeer(params) {
+    return this.call("connect_peer", [params]);
+  }
+  /**
+   * Disconnect from a peer
+   */
+  async disconnectPeer(params) {
+    return this.call("disconnect_peer", [params]);
+  }
+  /**
+   * List all connected peers
+   */
+  async listPeers() {
+    return this.call("list_peers", []);
+  }
+  // ===========================================================================
+  // Channel Module
+  // ===========================================================================
+  /**
+   * Open a new channel with a peer
+   */
+  async openChannel(params) {
+    return this.call("open_channel", [params]);
+  }
+  /**
+   * Accept a channel opening request
+   */
+  async acceptChannel(params) {
+    return this.call("accept_channel", [params]);
+  }
+  /**
+   * List all channels
+   */
+  async listChannels(params) {
+    const result = await this.call("list_channels", params ? [params] : [{}]);
+    return {
+      ...result,
+      channels: result.channels.map((channel) => this.normalizeChannel(channel))
+    };
+  }
+  normalizeChannelStateName(stateName) {
+    const alias = this.channelStateAliases[stateName];
+    if (alias) return alias;
+    const normalizedInput = stateName.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+    for (const value of Object.values(ChannelState)) {
+      const normalizedValue = value.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+      if (normalizedValue === normalizedInput) {
+        return value;
+      }
+    }
+    return stateName;
+  }
+  normalizeChannel(channel) {
+    return {
+      ...channel,
+      state: {
+        ...channel.state,
+        state_name: this.normalizeChannelStateName(channel.state.state_name)
+      }
+    };
+  }
+  /**
+   * Shutdown (close) a channel
+   */
+  async shutdownChannel(params) {
+    return this.call("shutdown_channel", [params]);
+  }
+  /**
+   * Abandon a pending channel
+   */
+  async abandonChannel(params) {
+    return this.call("abandon_channel", [params]);
+  }
+  /**
+   * Update channel parameters
+   */
+  async updateChannel(params) {
+    return this.call("update_channel", [params]);
+  }
+  // ===========================================================================
+  // Payment Module
+  // ===========================================================================
+  /**
+   * Send a payment
+   */
+  async sendPayment(params) {
+    return this.call("send_payment", [params]);
+  }
+  /**
+   * Get payment status
+   */
+  async getPayment(params) {
+    return this.call("get_payment", [params]);
+  }
+  // ===========================================================================
+  // Invoice Module
+  // ===========================================================================
+  /**
+   * Create a new invoice
+   */
+  async newInvoice(params) {
+    return this.call("new_invoice", [params]);
+  }
+  /**
+   * Parse an invoice string
+   */
+  async parseInvoice(params) {
+    return this.call("parse_invoice", [params]);
+  }
+  /**
+   * Get invoice by payment hash
+   */
+  async getInvoice(params) {
+    return this.call("get_invoice", [params]);
+  }
+  /**
+   * Cancel an open invoice
+   */
+  async cancelInvoice(params) {
+    return this.call("cancel_invoice", [params]);
+  }
+  /**
+   * Settle a hold invoice with the preimage
+   * Used for conditional/escrow payments where the invoice was created
+   * with a payment_hash (no preimage provided upfront)
+   */
+  async settleInvoice(params) {
+    return this.call("settle_invoice", [params]);
+  }
+  // ===========================================================================
+  // Router Module
+  // ===========================================================================
+  /**
+   * Build a custom route for payment
+   * Useful for channel rebalancing (circular payments) and advanced routing
+   */
+  async buildRouter(params) {
+    return this.call("build_router", [params]);
+  }
+  /**
+   * Send a payment using a pre-built route from buildRouter()
+   * Use with allow_self_payment for channel rebalancing
+   */
+  async sendPaymentWithRouter(params) {
+    return this.call("send_payment_with_router", [params]);
+  }
+  // ===========================================================================
+  // Graph Module
+  // ===========================================================================
+  /**
+   * List nodes in the network graph
+   */
+  async graphNodes(params) {
+    return this.call("graph_nodes", params ? [params] : [{}]);
+  }
+  /**
+   * List channels in the network graph
+   */
+  async graphChannels(params) {
+    return this.call("graph_channels", params ? [params] : [{}]);
+  }
+  // ===========================================================================
+  // Info Module
+  // ===========================================================================
+  /**
+   * Get local node information
+   */
+  async nodeInfo() {
+    return this.call("node_info", []);
+  }
+  // ===========================================================================
+  // Utility Methods
+  // ===========================================================================
+  /**
+   * Check if the node is reachable
+   */
+  async ping() {
+    try {
+      await this.nodeInfo();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Wait for the node to be ready
+   */
+  async waitForReady(options = {}) {
+    const { timeout = 6e4, interval = 1e3 } = options;
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      if (await this.ping()) {
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new FiberRpcError(-32e3, "Node not ready within timeout");
+  }
+  // ===========================================================================
+  // Polling / Watching Helpers
+  // ===========================================================================
+  /**
+   * Wait for a payment to reach a terminal state (Success or Failed)
+   * Polls get_payment at the specified interval.
+   *
+   * @returns The final payment result
+   * @throws FiberRpcError on timeout
+   */
+  async waitForPayment(paymentHash, options = {}) {
+    const { timeout = 12e4, interval = 2e3 } = options;
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      const result = await this.getPayment({ payment_hash: paymentHash });
+      if (result.status === "Success" || result.status === "Failed") {
+        return result;
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new FiberRpcError(-32e3, `Payment ${paymentHash} did not complete within ${timeout}ms`);
+  }
+  /**
+   * Wait for a channel to reach ChannelReady state.
+   * Polls list_channels at the specified interval.
+   *
+   * @returns The channel info once ready
+   * @throws FiberRpcError on timeout or if channel disappears
+   */
+  async waitForChannelReady(channelId, options = {}) {
+    const { timeout = 3e5, interval = 5e3 } = options;
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      const result = await this.listChannels({});
+      const channel = result.channels.find((ch) => ch.channel_id === channelId);
+      if (!channel) {
+        const allChannels = result.channels;
+        const found = allChannels.find((ch) => ch.channel_id === channelId);
+        if (!found) {
+          await new Promise((resolve) => setTimeout(resolve, interval));
+          continue;
+        }
+      }
+      if (channel && channel.state.state_name === "CHANNEL_READY" /* ChannelReady */) {
+        return channel;
+      }
+      if (channel && channel.state.state_name === "CLOSED" /* Closed */) {
+        throw new FiberRpcError(-32e3, `Channel ${channelId} was closed before becoming ready`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new FiberRpcError(
+      -32e3,
+      `Channel ${channelId} did not become ready within ${timeout}ms`
+    );
+  }
+  /**
+   * Wait for an invoice to reach a specific status.
+   * Useful for hold invoice workflows: wait for 'Received' before settling.
+   *
+   * @returns The invoice info once the target status is reached
+   * @throws FiberRpcError on timeout
+   */
+  async waitForInvoiceStatus(paymentHash, targetStatus, options = {}) {
+    const { timeout = 12e4, interval = 2e3 } = options;
+    const statuses = Array.isArray(targetStatus) ? targetStatus : [targetStatus];
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      const result = await this.getInvoice({ payment_hash: paymentHash });
+      if (statuses.includes(result.status)) {
+        return result;
+      }
+      if (result.status === "Cancelled") {
+        throw new FiberRpcError(-32e3, `Invoice ${paymentHash} was cancelled`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new FiberRpcError(
+      -32e3,
+      `Invoice ${paymentHash} did not reach status [${statuses.join(", ")}] within ${timeout}ms`
+    );
+  }
+  /**
+   * Watch for incoming payments on specified invoices.
+   * Polls invoice statuses and calls the callback when a status changes.
+   * Use an AbortSignal to stop watching.
+   *
+   * @example
+   * ```typescript
+   * const controller = new AbortController();
+   * client.watchIncomingPayments({
+   *   paymentHashes: [hash1, hash2],
+   *   onPayment: (invoice) => console.log('Payment received!', invoice),
+   *   signal: controller.signal,
+   * });
+   * // Later: controller.abort(); to stop watching
+   * ```
+   */
+  async watchIncomingPayments(options) {
+    const { paymentHashes, onPayment, interval = 3e3, signal } = options;
+    const knownStatuses = /* @__PURE__ */ new Map();
+    for (const hash of paymentHashes) {
+      try {
+        const invoice = await this.getInvoice({ payment_hash: hash });
+        knownStatuses.set(hash, invoice.status);
+      } catch {
+        knownStatuses.set(hash, "Open");
+      }
+    }
+    while (!signal?.aborted) {
+      for (const hash of paymentHashes) {
+        if (signal?.aborted) return;
+        try {
+          const invoice = await this.getInvoice({ payment_hash: hash });
+          const previousStatus = knownStatuses.get(hash);
+          if (invoice.status !== previousStatus && (invoice.status === "Received" || invoice.status === "Paid")) {
+            knownStatuses.set(hash, invoice.status);
+            onPayment(invoice);
+          } else if (invoice.status !== previousStatus) {
+            knownStatuses.set(hash, invoice.status);
+          }
+        } catch {
+        }
+      }
+      await new Promise((resolve) => {
+        if (signal?.aborted) {
+          resolve();
+          return;
+        }
+        const timer = setTimeout(resolve, interval);
+        signal?.addEventListener(
+          "abort",
+          () => {
+            clearTimeout(timer);
+            resolve();
+          },
+          { once: true }
+        );
+      });
+    }
+  }
+};
+
+export {
+  scriptToAddress,
+  ChannelState,
+  toHex,
+  fromHex,
+  ckbToShannons,
+  shannonsToCkb,
+  randomBytes32,
+  nodeIdToPeerId,
+  buildMultiaddr,
+  buildMultiaddrFromNodeId,
+  buildMultiaddrFromRpcUrl,
+  FiberRpcError,
+  FiberRpcClient
+};
+//# sourceMappingURL=chunk-QQDMPGVR.js.map