@xlink-network/xlink-sdk/lib/bitcoinUtils/apiHelpers/broadcastRevealableTransaction.js

XLINK js SDK

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/bitcoinUtils/apiHelpers/broadcastRevealableTransaction.ts
var broadcastRevealableTransaction_exports = {};
__export(broadcastRevealableTransaction_exports, {
  broadcastRevealableTransaction: () => broadcastRevealableTransaction
});
module.exports = __toCommonJS(broadcastRevealableTransaction_exports);
var import_viem = require("viem");

// src/config.ts
var import_network = require("@stacks/network");
var backendAPIPrefix = "https://sdk-api.xlink.network/";
var STACKS_MAINNET = new import_network.StacksMainnet({
  url: "https://stacks-node-api.alexlab.co"
});
var STACKS_TESTNET = new import_network.StacksMocknet({
  url: "https://nakamoto-dev-api.alexlab.co"
});

// src/utils/apiHelpers.ts
async function requestAPI(sdkContext, options) {
  const queryPairs = Object.entries(options.query ?? {});
  const querystring = new URLSearchParams(queryPairs).toString();
  const res = await fetch(
    `${backendAPIPrefix}${options.path}`.replace(/(\w)\/\//g, "$1/") + (querystring ? "?" + querystring : ""),
    {
      method: options.method,
      headers: {
        "Content-Type": "application/json",
        "X-Xlink-Runtime-Env": sdkContext.backendAPI.runtimeEnv
      },
      body: JSON.stringify(options.body)
    }
  );
  return readAPIResponse(res);
}
var readAPIResponse = async (resp) => {
  if (resp.status >= 200 && resp.status < 300) {
    return resp.json();
  }
  if (resp.status === 429) {
    throw new TooManyRequestsError(resp);
  }
  const respText = await resp.text();
  let respData = null;
  try {
    respData = JSON.parse(respText);
  } catch {
    respData = respText;
  }
  const thirdPartyError = ThirdPartyRequestError.fromSerializedError(respData);
  if (thirdPartyError != null) {
    throw thirdPartyError;
  }
  throw new RequestError(
    {
      url: resp.url,
      status: resp.status,
      body: respText
    },
    {
      cause: respData
    }
  );
};
var TooManyRequestsError = class extends Error {
  requestUrl;
  retryAfter;
  constructor(resp, options) {
    const _retryAfter = Number(resp.headers.get("Retry-After"));
    const retryAfter = Number.isNaN(_retryAfter) ? void 0 : _retryAfter;
    let errMsg = `Too many requests to SDK API server`;
    if (retryAfter != null) {
      errMsg += `; retry after ${retryAfter} seconds`;
    }
    super(errMsg, {
      ...options,
      cause: options?.cause ?? resp
    });
    this.requestUrl = resp.url;
    this.retryAfter = retryAfter;
  }
};
var ThirdPartyRequestError = class _ThirdPartyRequestError extends Error {
  constructor(serviceName, options) {
    super(`Request service ${serviceName} failed`, options);
    this.serviceName = serviceName;
  }
  isThirdPartyRequestError = true;
  static fromSerializedError(err) {
    if (!err.isThirdPartyRequestError) return;
    return new _ThirdPartyRequestError(err.serviceName, {
      cause: err.cause
    });
  }
};
var RequestError = class extends Error {
  constructor(response, options) {
    super(
      `Request failed:
url: ${response.url}
detail: ${response.body}`,
      options
    );
    this.response = response;
  }
};

// src/bitcoinUtils/apiHelpers/broadcastRevealableTransaction.ts
async function broadcastRevealableTransaction(sdkContext, info) {
  const resp = await requestAPI(sdkContext, {
    path: `/2024-10-01/bitcoin/broadcast`,
    method: "POST",
    body: {
      fromChain: info.fromChain,
      transactionHex: info.transactionHex,
      orderDataHex: (0, import_viem.toHex)(info.orderData),
      orderOutputIndex: info.orderOutputIndex,
      orderOutputSatoshiAmount: info.orderOutputSatsAmount.toString(),
      xlinkPegInAddress: {
        address: info.xlinkPegInAddress.address,
        scriptPubKeyHex: (0, import_viem.toHex)(info.xlinkPegInAddress.scriptPubKey)
      }
    }
  });
  return { txid: resp.txId };
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  broadcastRevealableTransaction
});
//# sourceMappingURL=broadcastRevealableTransaction.js.map