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

XLINK js SDK

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/bitcoinUtils/apiHelpers/createBitcoinPegInRecipients.ts
var createBitcoinPegInRecipients_exports = {};
__export(createBitcoinPegInRecipients_exports, {
  createBitcoinPegInRecipients: () => createBitcoinPegInRecipients
});
module.exports = __toCommonJS(createBitcoinPegInRecipients_exports);
var import_btc_utils2 = require("@c4/btc-utils");
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/utils/BigNumber.ts
var import_big = require("big.js");

// src/utils/arrayHelpers.ts
function last(ary) {
  return ary[ary.length - 1];
}
var _concat = [].concat;
var _reduce = [].reduce;
function reduce(fn, initialValue, inputArray) {
  return _reduce.call(inputArray, fn, initialValue);
}

// src/utils/BigNumber.ts
import_big.Big.PE = 21;
import_big.Big.NE = -21;
var toBig = (num) => {
  if (num instanceof import_big.Big) {
    return num;
  }
  return new import_big.Big(num);
};
var fromBig = (num) => {
  return num;
};
var BigNumber;
((BigNumber2) => {
  ({ roundUp: BigNumber2.roundUp, roundDown: BigNumber2.roundDown, roundHalfUp: BigNumber2.roundHalfUp, roundHalfEven: BigNumber2.roundHalfEven } = import_big.Big);
  let defaultRoundingMode = BigNumber2.roundHalfUp;
  BigNumber2.setDefaultRoundingMode = (roundingMode) => {
    defaultRoundingMode = roundingMode;
  };
  BigNumber2.isBigNumber = (num) => {
    return num instanceof import_big.Big;
  };
  BigNumber2.safeFrom = (value) => {
    try {
      return (0, BigNumber2.from)(value);
    } catch (e) {
      return void 0;
    }
  };
  BigNumber2.from = (value) => {
    return fromBig(toBig(value));
  };
  BigNumber2.toString = (value) => {
    return toBig(value).toString();
  };
  BigNumber2.toNumber = (value) => {
    return toBig(value).toNumber();
  };
  BigNumber2.toBigInt = curry2(
    (options, value) => {
      return BigInt(
        (0, BigNumber2.toFixed)(
          {
            precision: 0,
            roundingMode: options.roundingMode ?? defaultRoundingMode
          },
          toBig(value)
        )
      );
    }
  );
  BigNumber2.toFixed = curry2(
    (options, value) => {
      return toBig(value).toFixed(
        options.precision,
        options.roundingMode ?? defaultRoundingMode
      );
    }
  );
  BigNumber2.toExponential = curry2(
    (options, value) => {
      return toBig(value).toExponential(
        options.precision,
        options.roundingMode ?? defaultRoundingMode
      );
    }
  );
  BigNumber2.isNegative = (value) => {
    return toBig(value).lt(0);
  };
  BigNumber2.isGtZero = (value) => {
    return toBig(value).gt(0);
  };
  BigNumber2.isZero = (value) => {
    return toBig(value).eq(0);
  };
  BigNumber2.isEq = curry2(
    (value, a) => {
      return toBig(value).eq(toBig(a));
    }
  );
  BigNumber2.isGt = curry2(
    (value, a) => {
      return toBig(value).gt(toBig(a));
    }
  );
  BigNumber2.isGte = curry2(
    (value, a) => {
      return toBig(value).gte(toBig(a));
    }
  );
  BigNumber2.isLt = curry2(
    (value, a) => {
      return toBig(value).lt(toBig(a));
    }
  );
  BigNumber2.isLte = curry2(
    (value, a) => {
      return toBig(value).lte(toBig(a));
    }
  );
  BigNumber2.setPrecision = curry2(
    (options, value) => {
      return fromBig(
        toBig(
          toBig(value).toPrecision(
            options.precision,
            options.roundingMode ?? defaultRoundingMode
          )
        )
      );
    }
  );
  BigNumber2.getPrecision = (value) => {
    return toBig(value).c.length - (toBig(value).e + 1);
  };
  BigNumber2.getIntegerLength = (value) => {
    return toBig(value).e + 1;
  };
  BigNumber2.leftMoveDecimals = curry2(
    (distance, value) => (0, BigNumber2.moveDecimals)({ distance }, value)
  );
  BigNumber2.rightMoveDecimals = curry2(
    (distance, value) => (0, BigNumber2.moveDecimals)({ distance: -distance }, value)
  );
  BigNumber2.moveDecimals = curry2(
    (options, value) => {
      if (options.distance > 0) {
        return fromBig(toBig(value).div(10 ** options.distance));
      }
      if (options.distance < 0) {
        return fromBig(toBig(value).mul(10 ** -options.distance));
      }
      return (0, BigNumber2.from)(value);
    }
  );
  BigNumber2.getDecimalPart = curry2(
    (options, value) => {
      const formatted = (0, BigNumber2.toFixed)(
        {
          precision: Math.min((0, BigNumber2.getPrecision)(value), options.precision),
          roundingMode: BigNumber2.roundDown
        },
        value
      );
      const [, decimals] = formatted.split(".");
      if (decimals == null) return void 0;
      return decimals;
    }
  );
  BigNumber2.abs = (value) => {
    return fromBig(toBig(value).abs());
  };
  BigNumber2.neg = (value) => {
    return fromBig(toBig(value).neg());
  };
  BigNumber2.sqrt = (value) => {
    return fromBig(toBig(value).sqrt());
  };
  BigNumber2.add = curry2(
    (value, a) => {
      return fromBig(toBig(value).add(toBig(a)));
    }
  );
  BigNumber2.minus = curry2(
    (value, a) => {
      return fromBig(toBig(value).minus(toBig(a)));
    }
  );
  BigNumber2.mul = curry2(
    (value, a) => {
      return fromBig(toBig(value).mul(toBig(a)));
    }
  );
  BigNumber2.cumulativeMul = curry2(
    (value, as) => {
      return reduce(
        (acc, currentRate) => [
          ...acc,
          BigNumber2.mul(last(acc), currentRate)
        ],
        [(0, BigNumber2.from)(value)],
        as
      );
    }
  );
  BigNumber2.div = curry2(
    (value, a) => {
      return fromBig(toBig(value).div(toBig(a)));
    }
  );
  BigNumber2.pow = curry2((value, a) => {
    return fromBig(toBig(value).pow(a));
  });
  BigNumber2.round = curry2(
    (options, value) => {
      return fromBig(
        toBig(value).round(
          options.precision,
          options.roundingMode ?? defaultRoundingMode
        )
      );
    }
  );
  BigNumber2.toPrecision = curry2(
    (options, value) => {
      return toBig(value).toPrecision(
        options.precision,
        options.roundingMode ?? defaultRoundingMode
      );
    }
  );
  BigNumber2.ascend = curry2(
    (a, b) => (0, BigNumber2.isLt)(a, b) ? -1 : (0, BigNumber2.isGt)(a, b) ? 1 : 0
  );
  BigNumber2.descend = curry2(
    (a, b) => (0, BigNumber2.isLt)(a, b) ? 1 : (0, BigNumber2.isGt)(a, b) ? -1 : 0
  );
  BigNumber2.sort = (comparator, numbers) => {
    const _numbers = numbers.map((a) => fromBig(toBig(a)));
    _numbers.sort(comparator);
    return _numbers;
  };
  BigNumber2.max = (numbers) => {
    return (0, BigNumber2.from)((0, BigNumber2.sort)(BigNumber2.descend, numbers)[0]);
  };
  BigNumber2.min = (numbers) => {
    return (0, BigNumber2.from)((0, BigNumber2.sort)(BigNumber2.ascend, numbers)[0]);
  };
  BigNumber2.clamp = (range, n) => {
    const [min2, max3] = range;
    if ((0, BigNumber2.isGte)(n, max3)) return max3;
    if ((0, BigNumber2.isLte)(n, min2)) return min2;
    return n;
  };
  BigNumber2.sum = (numbers) => {
    return numbers.map((n) => fromBig(toBig(n))).reduce((acc, n) => (0, BigNumber2.add)(acc, n), BigNumber2.ZERO);
  };
  BigNumber2.ZERO = BigNumber2.from(0);
  BigNumber2.ONE = BigNumber2.from(1);
})(BigNumber || (BigNumber = {}));
function curry2(fn) {
  return function(a, b) {
    if (arguments.length > 1) {
      return fn(a, b);
    }
    return (b2) => fn(a, b2);
  };
}

// src/utils/errors.ts
var XLinkSDKErrorBase = class extends Error {
  constructor(...args) {
    super(...args);
    this.name = "XLinkSDKErrorBase";
  }
};
var UnsupportedBridgeRouteError = class extends XLinkSDKErrorBase {
  constructor(fromChain, toChain, fromToken, toToken) {
    super(
      `Unsupported chain combination: ${fromToken}(${fromChain}) -> ${toToken ?? "Unknown Token"}(${toChain})`
    );
    this.fromChain = fromChain;
    this.toChain = toChain;
    this.fromToken = fromToken;
    this.toToken = toToken;
    this.name = "UnsupportedBridgeRouteError";
  }
};

// src/utils/hexHelpers.ts
function decodeHex(hex) {
  let hexString = hex.startsWith("0x") ? hex.slice(2) : hex;
  if (hexString.length % 2) hexString = `0${hexString}`;
  const length = hexString.length / 2;
  const bytes = new Uint8Array(length);
  for (let index = 0, j = 0; index < length; index++) {
    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
    if (nibbleLeft === void 0 || nibbleRight === void 0) {
      throw new XLinkSDKErrorBase(
        `Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`
      );
    }
    bytes[index] = nibbleLeft * 16 + nibbleRight;
  }
  return bytes;
}
var charCodeMap = {
  zero: 48,
  nine: 57,
  A: 65,
  F: 70,
  a: 97,
  f: 102
};
function charCodeToBase16(char) {
  if (char >= charCodeMap.zero && char <= charCodeMap.nine)
    return char - charCodeMap.zero;
  if (char >= charCodeMap.A && char <= charCodeMap.F)
    return char - (charCodeMap.A - 10);
  if (char >= charCodeMap.a && char <= charCodeMap.f)
    return char - (charCodeMap.a - 10);
  return void 0;
}
var hexes = Array.from(
  { length: 256 },
  (_v, i) => i.toString(16).padStart(2, "0")
);

// src/utils/typeHelpers.ts
function checkNever(_x) {
  return;
}
function assertExclude(asserting, excluding) {
  return;
}
((assertExclude2) => {
  assertExclude2.i = () => null;
})(assertExclude || (assertExclude = {}));

// src/utils/types/knownIds.ts
var chainId = (value) => value;
var tokenId = (value) => value;
var KnownTokenId;
((KnownTokenId2) => {
  function isKnownToken(value) {
    return isBitcoinToken(value) || isBRC20Token(value) || isRunesToken(value) || isEVMToken(value) || isStacksToken(value);
  }
  KnownTokenId2.isKnownToken = isKnownToken;
  let Bitcoin;
  ((Bitcoin2) => {
    Bitcoin2.BTC = tokenId("btc-btc");
  })(Bitcoin = KnownTokenId2.Bitcoin || (KnownTokenId2.Bitcoin = {}));
  function isBitcoinToken(value) {
    return _allKnownBitcoinTokens.includes(value);
  }
  KnownTokenId2.isBitcoinToken = isBitcoinToken;
  function isBRC20Token(value) {
    return value.startsWith("brc20-");
  }
  KnownTokenId2.isBRC20Token = isBRC20Token;
  function isRunesToken(value) {
    return value.startsWith("runes-");
  }
  KnownTokenId2.isRunesToken = isRunesToken;
  let EVM;
  ((EVM2) => {
    EVM2.sUSDT = tokenId("evm-susdt");
    EVM2.USDT = tokenId("evm-usdt");
    EVM2.USDC = tokenId("evm-usdc");
    EVM2.aBTC = tokenId("evm-abtc");
    EVM2.WBTC = tokenId("evm-wbtc");
    EVM2.BTCB = tokenId("evm-btcb");
    EVM2.cbBTC = tokenId("evm-cbbtc");
    EVM2.LUNR = tokenId("evm-lunr");
    EVM2.ALEX = tokenId("evm-alex");
    EVM2.SKO = tokenId("evm-sko");
    EVM2.vLiSTX = tokenId("evm-vlistx");
    EVM2.vLiALEX = tokenId("evm-vlialex");
    EVM2.uBTC = tokenId("evm-ubtc");
    EVM2.wuBTC = tokenId("evm-wubtc");
    EVM2.DB20 = tokenId("evm-db20");
    EVM2.DOG = tokenId("evm-dog");
  })(EVM = KnownTokenId2.EVM || (KnownTokenId2.EVM = {}));
  function isEVMToken(value) {
    return _allKnownEVMTokens.includes(value);
  }
  KnownTokenId2.isEVMToken = isEVMToken;
  let Stacks;
  ((Stacks2) => {
    Stacks2.sUSDT = tokenId("stx-susdt");
    Stacks2.sLUNR = tokenId("stx-slunr");
    Stacks2.aBTC = tokenId("stx-abtc");
    Stacks2.ALEX = tokenId("stx-alex");
    Stacks2.sSKO = tokenId("stx-ssko");
    Stacks2.vLiSTX = tokenId("stx-vlistx");
    Stacks2.vLiALEX = tokenId("stx-vlialex");
    Stacks2.uBTC = tokenId("stx-ubtc");
    Stacks2.DB20 = tokenId("stx-db20");
    Stacks2.DOG = tokenId("stx-dog");
  })(Stacks = KnownTokenId2.Stacks || (KnownTokenId2.Stacks = {}));
  function isStacksToken(value) {
    return _allKnownStacksTokens.includes(value);
  }
  KnownTokenId2.isStacksToken = isStacksToken;
})(KnownTokenId || (KnownTokenId = {}));
var _allKnownBitcoinTokens = Object.values(KnownTokenId.Bitcoin);
var _allKnownEVMTokens = Object.values(KnownTokenId.EVM);
var _allKnownStacksTokens = Object.values(KnownTokenId.Stacks);
var KnownChainId;
((KnownChainId3) => {
  function isKnownChain(value) {
    return isBitcoinChain(value) || isBRC20Chain(value) || isRunesChain(value) || isEVMChain(value) || isStacksChain(value);
  }
  KnownChainId3.isKnownChain = isKnownChain;
  let Bitcoin;
  ((Bitcoin2) => {
    Bitcoin2.Mainnet = chainId("bitcoin-mainnet");
    Bitcoin2.Testnet = chainId("bitcoin-testnet");
  })(Bitcoin = KnownChainId3.Bitcoin || (KnownChainId3.Bitcoin = {}));
  function isBitcoinChain(value) {
    return _allKnownBitcoinChains.includes(value);
  }
  KnownChainId3.isBitcoinChain = isBitcoinChain;
  let Runes;
  ((Runes2) => {
    Runes2.Mainnet = chainId("runes-mainnet");
    Runes2.Testnet = chainId("runes-testnet");
  })(Runes = KnownChainId3.Runes || (KnownChainId3.Runes = {}));
  function isRunesChain(value) {
    return _allKnownRunesChains.includes(value);
  }
  KnownChainId3.isRunesChain = isRunesChain;
  let BRC20;
  ((BRC202) => {
    BRC202.Mainnet = chainId("brc20-mainnet");
    BRC202.Testnet = chainId("brc20-testnet");
  })(BRC20 = KnownChainId3.BRC20 || (KnownChainId3.BRC20 = {}));
  function isBRC20Chain(value) {
    return _allKnownBRC20Chains.includes(value);
  }
  KnownChainId3.isBRC20Chain = isBRC20Chain;
  let EVM;
  ((EVM2) => {
    EVM2.Ethereum = chainId("evm-ethereum");
    EVM2.Sepolia = chainId("evm-sepolia");
    EVM2.BSC = chainId("evm-bsc");
    EVM2.BSCTestnet = chainId("evm-bsctestnet");
    EVM2.CoreDAO = chainId("evm-coredao");
    EVM2.CoreDAOTestnet = chainId("evm-coredao-testnet");
    EVM2.Bsquared = chainId("evm-bsquared");
    EVM2.BOB = chainId("evm-bob");
    EVM2.Bitlayer = chainId("evm-bitlayer");
    EVM2.Lorenzo = chainId("evm-lorenzo");
    EVM2.Merlin = chainId("evm-merlin");
    EVM2.AILayer = chainId("evm-ailayer");
    EVM2.Mode = chainId("evm-mode");
    EVM2.XLayer = chainId("evm-xlayer");
    EVM2.Arbitrum = chainId("evm-arbitrum");
    EVM2.Aurora = chainId("evm-aurora");
    EVM2.BlifeTestnet = chainId("evm-blife-testnet");
    EVM2.BitboyTestnet = chainId("evm-bitboy-testnet");
    EVM2.Manta = chainId("evm-manta");
    EVM2.Linea = chainId("evm-linea");
    EVM2.Base = chainId("evm-base");
    EVM2.BeraTestnet = chainId("evm-bera-testnet");
  })(EVM = KnownChainId3.EVM || (KnownChainId3.EVM = {}));
  function isEVMMainnetChain(value) {
    return _allKnownEVMMainnetChains.includes(value);
  }
  KnownChainId3.isEVMMainnetChain = isEVMMainnetChain;
  function isEVMTestnetChain(value) {
    return _allKnownEVMTestnetChains.includes(value);
  }
  KnownChainId3.isEVMTestnetChain = isEVMTestnetChain;
  function isEVMChain(value) {
    return _allKnownEVMChains.includes(value);
  }
  KnownChainId3.isEVMChain = isEVMChain;
  let Stacks;
  ((Stacks2) => {
    Stacks2.Mainnet = chainId("stacks-mainnet");
    Stacks2.Testnet = chainId("stacks-testnet");
  })(Stacks = KnownChainId3.Stacks || (KnownChainId3.Stacks = {}));
  function isStacksChain(value) {
    return _allKnownStacksChains.includes(value);
  }
  KnownChainId3.isStacksChain = isStacksChain;
})(KnownChainId || (KnownChainId = {}));
var _allKnownBitcoinChains = Object.values(KnownChainId.Bitcoin);
var _allKnownRunesChains = Object.values(KnownChainId.Runes);
var _allKnownBRC20Chains = Object.values(KnownChainId.BRC20);
var _allKnownEVMChains = Object.values(KnownChainId.EVM);
var _allKnownStacksChains = Object.values(KnownChainId.Stacks);
var _allKnownEVMMainnetChains = [
  KnownChainId.EVM.Ethereum,
  KnownChainId.EVM.BSC,
  KnownChainId.EVM.CoreDAO,
  KnownChainId.EVM.Bsquared,
  KnownChainId.EVM.BOB,
  KnownChainId.EVM.Bitlayer,
  KnownChainId.EVM.Lorenzo,
  KnownChainId.EVM.Merlin,
  KnownChainId.EVM.AILayer,
  KnownChainId.EVM.Mode,
  KnownChainId.EVM.XLayer,
  KnownChainId.EVM.Arbitrum,
  KnownChainId.EVM.Aurora,
  KnownChainId.EVM.Manta,
  KnownChainId.EVM.Linea,
  KnownChainId.EVM.Base
];
var _allKnownEVMTestnetChains = [
  KnownChainId.EVM.Sepolia,
  KnownChainId.EVM.BSCTestnet,
  KnownChainId.EVM.CoreDAOTestnet,
  KnownChainId.EVM.BlifeTestnet,
  KnownChainId.EVM.BitboyTestnet,
  KnownChainId.EVM.BeraTestnet
];
var _allNoLongerSupportedEVMChains = [
  KnownChainId.EVM.Lorenzo
];
var _restEVMChain = null;
checkNever(_restEVMChain);

// src/bitcoinUtils/btcAddresses.ts
var import_btc_signer2 = require("@scure/btc-signer");

// src/bitcoinUtils/bitcoinHelpers.ts
var btc = __toESM(require("@scure/btc-signer"));
var import_btc_signer = require("@scure/btc-signer");

// src/utils/bigintHelpers.ts
var MAX_BIGINT = BigInt(Number.MAX_VALUE);
function max(nums) {
  return nums.reduce((acc, val) => acc > val ? acc : val, 0n);
}

// src/bitcoinUtils/bitcoinHelpers.ts
function addressToScriptPubKey(network, address) {
  const addr = (0, import_btc_signer.Address)(network).decode(address);
  return import_btc_signer.OutScript.encode(addr);
}

// src/bitcoinUtils/btcAddresses.ts
function getBTCPegInAddress(fromChain, toChain) {
  let addr;
  switch (fromChain) {
    case KnownChainId.Bitcoin.Mainnet:
      addr = "bc1q9hs56nskqsxmgend4w0823lmef33sux6p8rzlp";
      break;
    case KnownChainId.Bitcoin.Testnet:
      addr = "tb1qeprcndv9n8luumegjsnljjcf68e7ay62n5a667";
      break;
    default:
      checkNever(fromChain);
  }
  if (addr == null) return void 0;
  const script = addressToScriptPubKey(
    fromChain === KnownChainId.Bitcoin.Mainnet ? import_btc_signer2.NETWORK : import_btc_signer2.TEST_NETWORK,
    addr
  );
  return {
    address: addr,
    scriptPubKey: script
  };
}

// src/bitcoinUtils/prepareTransaction.ts
var import_btc_utils = require("@c4/btc-utils");
var btc2 = __toESM(require("@scure/btc-signer"));

// src/bitcoinUtils/errors.ts
var UnsupportedBitcoinInput = class extends XLinkSDKErrorBase {
  constructor(txid, index, ...args) {
    super(...args);
    this.txid = txid;
    this.index = index;
    this.message = this.message || `Not supported bitcoin input: ${txid}:${index}`;
  }
};

// src/bitcoinUtils/prepareTransaction.ts
var DEFAULT_MIN_RELAY_TX_FEE = 1000n;
async function calculateFee(info) {
  const outputs = [
    ...info.recipientAddressScriptPubKeys.map((r) => ({
      scriptPubKey: r
    })),
    ...info.opReturnData.map((data) => ({
      scriptPubKey: btc2.Script.encode(["RETURN", data])
    }))
  ];
  try {
    const vSize = (0, import_btc_utils.estimateTransactionVSizeAfterSign)({
      inputs: info.selectedUTXOs,
      outputs
    });
    const txSize = BigInt(Math.ceil(vSize));
    return {
      estimatedVSize: vSize,
      fee: max([info.feeRate * txSize, DEFAULT_MIN_RELAY_TX_FEE])
    };
  } catch (e) {
    if (e instanceof import_btc_utils.UnsupportedInputTypeError) {
      const input = e.cause;
      throw new UnsupportedBitcoinInput(input.txId, input.index);
    }
    throw e;
  }
}

// src/bitcoinUtils/apiHelpers/createBitcoinPegInRecipients.ts
var REVEAL_TX_OUTPUT_AMOUNT = 546n;
async function createBitcoinPegInRecipients(sdkContext, info) {
  const pegInAddress = await getBTCPegInAddress(info.fromChain, info.toChain);
  if (pegInAddress == null) {
    throw new UnsupportedBridgeRouteError(
      info.fromChain,
      info.toChain,
      KnownTokenId.Bitcoin.BTC
    );
  }
  const resp = await requestAPI(sdkContext, {
    path: `/2024-10-01/bitcoin/peg-in-recipients`,
    method: "POST",
    body: {
      fromChain: info.fromChain,
      toChain: info.toChain,
      fromToken: info.fromToken,
      toToken: info.toToken,
      fromAddress: {
        address: info.fromAddress.address,
        scriptPubKeyHex: (0, import_viem.toHex)(info.fromAddress.scriptPubKey)
      },
      toAddress: info.toAddress,
      fromAmount: BigNumber.toString(info.fromAmount),
      orderDataHex: (0, import_viem.toHex)(info.orderData)
    }
  });
  const recipient = resp.addresses.find(
    (address) => address.type === "commitOrder"
  );
  const revealInputSize = (0, import_btc_utils2.estimateInputVSizeAfterSign)({
    addressType: "p2tr-leafScript",
    tapLeafScriptArgumentByteLengths: [
      /* signature */
      64
    ],
    tapLeafScriptByteLength: recipient.tapScriptHex.length / 2,
    controlBlockByteLength: 33
  });
  const { fee: newTxFee } = await calculateFee({
    recipientAddressScriptPubKeys: [pegInAddress.scriptPubKey],
    opReturnData: [],
    selectedUTXOs: [],
    feeRate: info.feeRate,
    extraSize: revealInputSize.inputSize + revealInputSize.witnessDataSize / 4
  });
  const revealUTXOSatsAmount = BigNumber.sum([
    newTxFee,
    REVEAL_TX_OUTPUT_AMOUNT
  ]);
  return {
    address: recipient.address,
    scriptPubKey: decodeHex(recipient.scriptPubKeyHex),
    satsAmount: BigNumber.toBigInt(
      { roundingMode: BigNumber.roundUp },
      revealUTXOSatsAmount
    )
  };
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  createBitcoinPegInRecipients
});
//# sourceMappingURL=createBitcoinPegInRecipients.js.map