@babylonlabs-io/ts-sdk 0.27.1 → 0.28.0

package/dist/types-CQ86O7NX.js

@@ -0,0 +1,650 @@
+var R = Object.defineProperty;
+var h = (e, t, n) => t in e ? R(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var p = (e, t, n) => h(e, typeof t != "symbol" ? t + "" : t, n);
+const k = [
+  {
+    type: "function",
+    name: "submitPeginRequest",
+    inputs: [
+      {
+        name: "depositor",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "depositorBtcPubKey",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "btcPopSignature",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "unsignedPrePeginTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "depositorSignedPeginTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "vaultProvider",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "hashlock",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "htlcVout",
+        type: "uint8",
+        internalType: "uint8"
+      },
+      {
+        name: "depositorPayoutBtcAddress",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "depositorWotsPkHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "submitPeginRequest",
+    inputs: [
+      {
+        name: "depositor",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "depositorBtcPubKey",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "btcPopSignature",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "unsignedPrePeginTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "depositorSignedPeginTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "vaultProvider",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "hashlock",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "htlcVout",
+        type: "uint8",
+        internalType: "uint8"
+      },
+      {
+        name: "referralCode",
+        type: "uint32",
+        internalType: "uint32"
+      },
+      {
+        name: "depositorPayoutBtcAddress",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "depositorWotsPkHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "submitPeginRequestBatch",
+    inputs: [
+      { name: "depositor", type: "address", internalType: "address" },
+      { name: "vaultProvider", type: "address", internalType: "address" },
+      {
+        name: "requests",
+        type: "tuple[]",
+        internalType: "struct IBTCVaultRegistry.BatchPeginRequest[]",
+        components: [
+          { name: "depositorBtcPubKey", type: "bytes32", internalType: "bytes32" },
+          { name: "btcPopSignature", type: "bytes", internalType: "bytes" },
+          { name: "unsignedPrePeginTx", type: "bytes", internalType: "bytes" },
+          { name: "depositorSignedPeginTx", type: "bytes", internalType: "bytes" },
+          { name: "hashlock", type: "bytes32", internalType: "bytes32" },
+          { name: "htlcVout", type: "uint8", internalType: "uint8" },
+          { name: "referralCode", type: "uint32", internalType: "uint32" },
+          { name: "depositorPayoutBtcAddress", type: "bytes", internalType: "bytes" },
+          { name: "depositorWotsPkHash", type: "bytes32", internalType: "bytes32" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "vaultIds", type: "bytes32[]", internalType: "bytes32[]" }
+    ],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "activateVaultWithSecret",
+    inputs: [
+      {
+        name: "vaultId",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "s",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "activationMetadata",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getPegInFee",
+    inputs: [
+      {
+        name: "vaultProvider",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "totalFee",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getBtcVaultBasicInfo",
+    inputs: [
+      {
+        name: "vaultId",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      { name: "depositor", type: "address", internalType: "address" },
+      { name: "depositorBtcPubKey", type: "bytes32", internalType: "bytes32" },
+      { name: "amount", type: "uint256", internalType: "uint256" },
+      { name: "vaultProvider", type: "address", internalType: "address" },
+      { name: "status", type: "uint8", internalType: "enum IBTCVaultRegistry.BTCVaultStatus" },
+      { name: "applicationEntryPoint", type: "address", internalType: "address" },
+      { name: "createdAt", type: "uint256", internalType: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "error",
+    name: "InvalidPeginFee",
+    inputs: [
+      {
+        name: "provided",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "required",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "InvalidSecret",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "ActivationDeadlineExpired",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidHashlock",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "DuplicateHashlock",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "CapExceeded",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "InvalidOutputIndex",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "PeginSignaturesIncomplete",
+    inputs: []
+  },
+  {
+    type: "function",
+    name: "getBtcVaultProtocolInfo",
+    inputs: [
+      {
+        name: "vaultId",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "depositorSignedPeginTx",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "universalChallengersVersion",
+        type: "uint16",
+        internalType: "uint16"
+      },
+      {
+        name: "appVaultKeepersVersion",
+        type: "uint16",
+        internalType: "uint16"
+      },
+      {
+        name: "offchainParamsVersion",
+        type: "uint16",
+        internalType: "uint16"
+      },
+      {
+        name: "verifiedAt",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "depositorWotsPkHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "hashlock",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "htlcVout",
+        type: "uint8",
+        internalType: "uint8"
+      },
+      {
+        name: "depositorPopSignature",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "prePeginTxHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "vaultProviderCommissionBps",
+        type: "uint16",
+        internalType: "uint16"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "protocolParams",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contract IProtocolParams"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "applicationRegistry",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "contract IApplicationRegistry"
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+class d extends Error {
+  constructor(t, n, r = "local", i) {
+    super(n), this.code = t, this.source = r, this.data = i, this.name = "JsonRpcError";
+  }
+}
+const T = {
+  TIMEOUT: -32e3,
+  NETWORK: -32001,
+  /** VP proxy: request timed out at proxy level */
+  PROXY_TIMEOUT: -32002,
+  /** VP proxy: VP unreachable / DNS failure / response too large */
+  PROXY_UNAVAILABLE: -32003,
+  /** SDK client: response missing "result" field (malformed JSON-RPC) */
+  INVALID_RESPONSE: -32700
+}, A = "2.0", _ = 3, S = 1e3, N = /* @__PURE__ */ new Set([
+  408,
+  // Request Timeout
+  429,
+  // Too Many Requests
+  500,
+  // Internal Server Error
+  502,
+  // Bad Gateway
+  503,
+  // Service Unavailable
+  504
+  // Gateway Timeout
+]), g = /* @__PURE__ */ new Set([
+  "vaultProvider_getPeginStatus",
+  "vaultProvider_getPegoutStatus",
+  "vaultProvider_requestDepositorPresignTransactions"
+]);
+function v(e) {
+  return g.has(e);
+}
+const O = "auth_expired";
+function f(e) {
+  if (!(e instanceof d) || e.source !== "wire") return !1;
+  const t = e.data;
+  return t === null || typeof t != "object" ? !1 : t.kind === O;
+}
+class C {
+  constructor(t) {
+    p(this, "baseUrl");
+    p(this, "timeout");
+    p(this, "headers");
+    p(this, "requestId", 0);
+    p(this, "retries");
+    p(this, "retryDelay");
+    p(this, "retryableFor");
+    p(this, "tokenProvider");
+    this.baseUrl = t.baseUrl.replace(/\/$/, ""), this.timeout = t.timeout, this.headers = {
+      "Content-Type": "application/json",
+      ...t.headers
+    }, this.retries = t.retries ?? _, this.retryDelay = t.retryDelay ?? S, this.retryableFor = t.retryableFor ?? v, this.tokenProvider = t.tokenProvider;
+  }
+  async buildHeaders(t) {
+    const n = { ...this.headers };
+    if (this.tokenProvider) {
+      const r = await this.tokenProvider.getToken(t);
+      r && (n.Authorization = `Bearer ${r}`);
+    }
+    return n;
+  }
+  /**
+   * Make a JSON-RPC request with optional retry for safe methods.
+   *
+   * If the request fails with a wire-origin `auth_expired` error and a
+   * `tokenProvider` is configured, the client invalidates its cached
+   * token and retries the request once with a freshly-acquired bearer.
+   *
+   * @param method - The RPC method name
+   * @param params - The method parameters
+   * @param signal - Optional AbortSignal for caller-controlled cancellation
+   * @returns The result from the RPC method
+   * @throws JsonRpcError if the RPC call fails
+   */
+  async call(t, n, r) {
+    try {
+      return await this.callOnce(t, n, r);
+    } catch (i) {
+      if (this.tokenProvider && f(i))
+        return this.tokenProvider.invalidate(), await this.callOnce(t, n, r);
+      throw i;
+    }
+  }
+  async callOnce(t, n, r) {
+    const i = await this.fetchWithRetry(t, n, r);
+    let s;
+    try {
+      s = await i.json();
+    } catch {
+      throw new d(
+        T.INVALID_RESPONSE,
+        "Invalid JSON-RPC response: body is not valid JSON",
+        "local"
+      );
+    }
+    if (s === null || typeof s != "object" || Array.isArray(s))
+      throw new d(
+        T.INVALID_RESPONSE,
+        `Invalid JSON-RPC response: expected an object, got ${typeof s}`,
+        "local"
+      );
+    const o = s;
+    if ("error" in o && o.error != null) {
+      const P = o.error;
+      throw new d(
+        P.code ?? T.INVALID_RESPONSE,
+        P.message ?? "Unknown RPC error",
+        "wire",
+        P.data
+      );
+    }
+    if (!("result" in o))
+      throw new d(
+        T.INVALID_RESPONSE,
+        'Invalid JSON-RPC response: missing "result" field',
+        "local"
+      );
+    return o.result;
+  }
+  /**
+   * Make a JSON-RPC request returning the raw Response (unparsed body).
+   *
+   * Bearer tokens are injected identically to `call`. **Reactive refresh
+   * is NOT performed here** — the response body may be unbounded (e.g.
+   * claimer-artifact downloads), so the client refuses to parse it to
+   * detect auth errors. Callers relying on token-expired retries for
+   * large downloads must read the body themselves and re-invoke
+   * `callRaw` after `tokenProvider.invalidate()`.
+   */
+  async callRaw(t, n, r) {
+    return this.fetchWithRetry(t, n, r);
+  }
+  async fetchWithRetry(t, n, r) {
+    const i = ++this.requestId, s = this.retryableFor(t) ? this.retries : 0, P = JSON.stringify({
+      jsonrpc: A,
+      method: t,
+      params: [n],
+      id: i
+    });
+    let b = null;
+    for (let u = 0; u <= s; u++) {
+      const c = new AbortController(), m = setTimeout(
+        () => c.abort(),
+        this.timeout
+      ), l = r ? w(r, c.signal) : null, E = l ? l.signal : c.signal;
+      try {
+        const a = await this.buildHeaders(t), y = await fetch(this.baseUrl, {
+          method: "POST",
+          headers: a,
+          body: P,
+          signal: E
+        });
+        if (clearTimeout(m), l == null || l.cleanup(), !y.ok) {
+          if (u < s && N.has(y.status)) {
+            const I = this.retryDelay * Math.pow(2, u);
+            await this.sleep(I, r);
+            continue;
+          }
+          throw new Error(
+            `HTTP error: ${y.status} ${y.statusText}`
+          );
+        }
+        return y;
+      } catch (a) {
+        if (clearTimeout(m), l == null || l.cleanup(), b = a instanceof Error ? a : new Error(String(a)), r != null && r.aborted)
+          throw new Error("Request aborted");
+        if (a instanceof Error && a.name === "AbortError") {
+          if (u < s) {
+            const y = this.retryDelay * Math.pow(2, u);
+            await this.sleep(y, r);
+            continue;
+          }
+          throw new d(
+            T.TIMEOUT,
+            `Request timeout after ${this.timeout}ms (${s + 1} attempts)`,
+            "local"
+          );
+        }
+        if (a instanceof TypeError) {
+          if (u < s) {
+            const y = this.retryDelay * Math.pow(2, u);
+            await this.sleep(y, r);
+            continue;
+          }
+          throw new d(
+            T.NETWORK,
+            `Network error: ${a.message} (${s + 1} attempts)`,
+            "local"
+          );
+        }
+        throw a;
+      }
+    }
+    throw b || new Error("Unknown error after retries");
+  }
+  sleep(t, n) {
+    return new Promise((r, i) => {
+      if (n != null && n.aborted) {
+        i(new Error("Request aborted"));
+        return;
+      }
+      const s = setTimeout(() => {
+        n == null || n.removeEventListener("abort", o), r();
+      }, t), o = () => {
+        clearTimeout(s), i(new Error("Request aborted"));
+      };
+      n == null || n.addEventListener("abort", o, { once: !0 });
+    });
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+}
+function w(e, t) {
+  if (e.aborted) return { signal: e, cleanup: () => {
+  } };
+  if (t.aborted) return { signal: t, cleanup: () => {
+  } };
+  const n = new AbortController(), r = () => {
+    t.removeEventListener("abort", i), n.abort();
+  }, i = () => {
+    e.removeEventListener("abort", r), n.abort();
+  };
+  e.addEventListener("abort", r, { once: !0 }), t.addEventListener("abort", i, { once: !0 });
+  const s = () => {
+    e.removeEventListener("abort", r), t.removeEventListener("abort", i);
+  };
+  return { signal: n.signal, cleanup: s };
+}
+var D = /* @__PURE__ */ ((e) => (e.PENDING_INGESTION = "PendingIngestion", e.PENDING_DEPOSITOR_WOTS_PK = "PendingDepositorWotsPK", e.PENDING_BABE_SETUP = "PendingBabeSetup", e.PENDING_CHALLENGER_PRESIGNING = "PendingChallengerPresigning", e.PENDING_PEGIN_SIGS_AVAILABILITY = "PendingPeginSigsAvailability", e.PENDING_PRE_PEGIN_CONFIRMATIONS = "PendingPrePegInConfirmations", e.PENDING_DEPOSITOR_SIGNATURES = "PendingDepositorSignatures", e.PENDING_ACKS = "PendingACKs", e.PENDING_ACTIVATION = "PendingActivation", e.ACTIVATED = "Activated", e.EXPIRED = "Expired", e.CLAIM_POSTED = "ClaimPosted", e.PEGGED_OUT = "PeggedOut", e))(D || {});
+const M = [
+  "PendingIngestion",
+  "PendingBabeSetup",
+  "PendingChallengerPresigning",
+  "PendingPeginSigsAvailability",
+  "PendingPrePegInConfirmations"
+  /* PENDING_PRE_PEGIN_CONFIRMATIONS */
+], L = [
+  "PendingACKs",
+  "PendingActivation",
+  "Activated"
+  /* ACTIVATED */
+], B = /* @__PURE__ */ new Set([
+  "PendingBabeSetup",
+  "PendingChallengerPresigning",
+  "PendingPeginSigsAvailability",
+  "PendingPrePegInConfirmations",
+  ...L
+]), x = /* @__PURE__ */ new Set([
+  "Expired",
+  "ClaimPosted",
+  "PeggedOut"
+  /* PEGGED_OUT */
+]), H = /* @__PURE__ */ new Set([
+  ...B,
+  "PendingDepositorSignatures"
+  /* PENDING_DEPOSITOR_SIGNATURES */
+]);
+var V = /* @__PURE__ */ ((e) => (e[e.DATABASE_ERROR = -32005] = "DATABASE_ERROR", e[e.PRESIGN_ERROR = -32006] = "PRESIGN_ERROR", e[e.JSON_SERIALIZATION_ERROR = -32007] = "JSON_SERIALIZATION_ERROR", e[e.TX_GRAPH_ERROR = -32008] = "TX_GRAPH_ERROR", e[e.INVALID_GRAPH = -32009] = "INVALID_GRAPH", e[e.VALIDATION_ERROR = -32010] = "VALIDATION_ERROR", e[e.NOT_FOUND = -32011] = "NOT_FOUND", e[e.INTERNAL_ERROR = -32603] = "INTERNAL_ERROR", e))(V || {});
+export {
+  k as B,
+  D,
+  C as J,
+  M as P,
+  V as R,
+  B as V,
+  d as a,
+  T as b,
+  x as c,
+  H as d
+};
+//# sourceMappingURL=types-CQ86O7NX.js.map