@secondlayer/stacks 0.0.1

package/dist/src/pox/index.js

@@ -0,0 +1,877 @@
+import {
+  getContract
+} from "../../shared/stacks-vdfs3e5v.js";
+import"../../shared/stacks-zm0b3tgy.js";
+import"../../shared/stacks-709tra19.js";
+import"../../shared/stacks-d1fmkv3p.js";
+import {
+  Pc
+} from "../../shared/stacks-yfveb68e.js";
+import"../../shared/stacks-f7wdrzs3.js";
+import"../../shared/stacks-yfgsm6ap.js";
+import"../../shared/stacks-j2cy7qtt.js";
+import"../../shared/stacks-8yykgdww.js";
+import"../../shared/stacks-v9jqcpd4.js";
+import"../../shared/stacks-bycy6t9k.js";
+import"../../shared/stacks-gjvbq6w7.js";
+import {
+  hexToBytes
+} from "../../shared/stacks-nqytwfcc.js";
+import"../../shared/stacks-8m9byk2j.js";
+
+// src/pox/abi.ts
+var poxAddressTuple = {
+  tuple: [
+    { name: "version", type: { buff: { length: 1 } } },
+    { name: "hashbytes", type: { buff: { length: 32 } } }
+  ]
+};
+var POX_ABI = {
+  functions: [
+    {
+      name: "get-pox-info",
+      access: "read-only",
+      args: [],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "reward-cycle-id", type: "uint128" },
+              { name: "min-amount-ustx", type: "uint128" },
+              { name: "prepare-cycle-length", type: "uint128" },
+              { name: "first-burnchain-block-height", type: "uint128" },
+              { name: "reward-cycle-length", type: "uint128" },
+              { name: "total-liquid-supply-ustx", type: "uint128" }
+            ]
+          },
+          error: "none"
+        }
+      }
+    },
+    {
+      name: "get-stacker-info",
+      access: "read-only",
+      args: [{ name: "stacker", type: "principal" }],
+      outputs: {
+        optional: {
+          tuple: [
+            { name: "pox-addr", type: poxAddressTuple },
+            { name: "lock-period", type: "uint128" },
+            { name: "first-reward-cycle", type: "uint128" },
+            {
+              name: "reward-set-indexes",
+              type: { list: { type: "uint128", length: 12 } }
+            },
+            { name: "delegated-to", type: { optional: "principal" } }
+          ]
+        }
+      }
+    },
+    {
+      name: "get-delegation-info",
+      access: "read-only",
+      args: [{ name: "stacker", type: "principal" }],
+      outputs: {
+        optional: {
+          tuple: [
+            { name: "amount-ustx", type: "uint128" },
+            { name: "delegated-to", type: "principal" },
+            { name: "until-burn-ht", type: { optional: "uint128" } },
+            { name: "pox-addr", type: { optional: poxAddressTuple } }
+          ]
+        }
+      }
+    },
+    {
+      name: "can-stack-stx",
+      access: "read-only",
+      args: [
+        { name: "pox-addr", type: poxAddressTuple },
+        { name: "amount-ustx", type: "uint128" },
+        { name: "first-reward-cycle", type: "uint128" },
+        { name: "num-cycles", type: "uint128" }
+      ],
+      outputs: { response: { ok: "bool", error: "int128" } }
+    },
+    {
+      name: "stack-stx",
+      access: "public",
+      args: [
+        { name: "amount-ustx", type: "uint128" },
+        { name: "pox-addr", type: poxAddressTuple },
+        { name: "start-burn-ht", type: "uint128" },
+        { name: "lock-period", type: "uint128" },
+        {
+          name: "signer-sig",
+          type: { optional: { buff: { length: 65 } } }
+        },
+        { name: "signer-key", type: { buff: { length: 33 } } },
+        { name: "max-amount", type: "uint128" },
+        { name: "auth-id", type: "uint128" }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "stacker", type: "principal" },
+              { name: "lock-amount", type: "uint128" },
+              { name: "signer-key", type: { buff: { length: 33 } } },
+              { name: "unlock-burn-height", type: "uint128" }
+            ]
+          },
+          error: "int128"
+        }
+      }
+    },
+    {
+      name: "delegate-stx",
+      access: "public",
+      args: [
+        { name: "amount-ustx", type: "uint128" },
+        { name: "delegate-to", type: "principal" },
+        { name: "until-burn-ht", type: { optional: "uint128" } },
+        { name: "pox-addr", type: { optional: poxAddressTuple } }
+      ],
+      outputs: { response: { ok: "bool", error: "int128" } }
+    },
+    {
+      name: "revoke-delegate-stx",
+      access: "public",
+      args: [],
+      outputs: {
+        response: {
+          ok: {
+            optional: {
+              tuple: [
+                { name: "amount-ustx", type: "uint128" },
+                { name: "delegated-to", type: "principal" },
+                { name: "until-burn-ht", type: { optional: "uint128" } },
+                { name: "pox-addr", type: { optional: poxAddressTuple } }
+              ]
+            }
+          },
+          error: "int128"
+        }
+      }
+    },
+    {
+      name: "stack-extend",
+      access: "public",
+      args: [
+        { name: "extend-count", type: "uint128" },
+        { name: "pox-addr", type: poxAddressTuple },
+        {
+          name: "signer-sig",
+          type: { optional: { buff: { length: 65 } } }
+        },
+        { name: "signer-key", type: { buff: { length: 33 } } },
+        { name: "max-amount", type: "uint128" },
+        { name: "auth-id", type: "uint128" }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "stacker", type: "principal" },
+              { name: "unlock-burn-height", type: "uint128" }
+            ]
+          },
+          error: "int128"
+        }
+      }
+    },
+    {
+      name: "stack-increase",
+      access: "public",
+      args: [
+        { name: "increase-by", type: "uint128" },
+        {
+          name: "signer-sig",
+          type: { optional: { buff: { length: 65 } } }
+        },
+        { name: "signer-key", type: { buff: { length: 33 } } },
+        { name: "max-amount", type: "uint128" },
+        { name: "auth-id", type: "uint128" }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "stacker", type: "principal" },
+              { name: "total-locked", type: "uint128" }
+            ]
+          },
+          error: "int128"
+        }
+      }
+    }
+  ]
+};
+
+// src/pox/constants.ts
+var POX_CONTRACTS = {
+  mainnet: {
+    address: "SP000000000000000000002Q6VF78",
+    name: "pox-4"
+  },
+  testnet: {
+    address: "ST000000000000000000002AMW42H",
+    name: "pox-4"
+  }
+};
+var MIN_LOCK_PERIOD = 1;
+var MAX_LOCK_PERIOD = 12;
+var POX_ADDRESS_VERSION = {
+  p2pkh: 0,
+  p2sh: 1,
+  p2sh_p2wpkh: 2,
+  p2sh_p2wsh: 3,
+  p2wpkh: 4,
+  p2wsh: 5,
+  p2tr: 6
+};
+
+// ../../node_modules/@scure/base/index.js
+/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(b) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr))
+    return false;
+  if (arr.length === 0)
+    return true;
+  if (isString) {
+    return arr.every((item) => typeof item === "string");
+  } else {
+    return arr.every((item) => Number.isSafeInteger(item));
+  }
+}
+function afn(input) {
+  if (typeof input !== "function")
+    throw new Error("function expected");
+  return true;
+}
+function astr(label, input) {
+  if (typeof input !== "string")
+    throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n))
+    throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input))
+    throw new Error("array expected");
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input))
+    throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input))
+    throw new Error(`${label}: array of numbers expected`);
+}
+function chain(...args) {
+  const id = (a) => a;
+  const wrap = (a, b) => (c) => a(b(c));
+  const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+  const decode = args.map((x) => x.decode).reduce(wrap, id);
+  return { encode, decode };
+}
+function alphabet(letters) {
+  const lettersA = typeof letters === "string" ? letters.split("") : letters;
+  const len = lettersA.length;
+  astrArr("alphabet", lettersA);
+  const indexes = new Map(lettersA.map((l, i) => [l, i]));
+  return {
+    encode: (digits) => {
+      aArr(digits);
+      return digits.map((i) => {
+        if (!Number.isSafeInteger(i) || i < 0 || i >= len)
+          throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
+        return lettersA[i];
+      });
+    },
+    decode: (input) => {
+      aArr(input);
+      return input.map((letter) => {
+        astr("alphabet.decode", letter);
+        const i = indexes.get(letter);
+        if (i === undefined)
+          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i;
+      });
+    }
+  };
+}
+function join(separator = "") {
+  astr("join", separator);
+  return {
+    encode: (from) => {
+      astrArr("join.decode", from);
+      return from.join(separator);
+    },
+    decode: (to) => {
+      astr("join.decode", to);
+      return to.split(separator);
+    }
+  };
+}
+function padding(bits, chr = "=") {
+  anumber(bits);
+  astr("padding", chr);
+  return {
+    encode(data) {
+      astrArr("padding.encode", data);
+      while (data.length * bits % 8)
+        data.push(chr);
+      return data;
+    },
+    decode(input) {
+      astrArr("padding.decode", input);
+      let end = input.length;
+      if (end * bits % 8)
+        throw new Error("padding: invalid, string should have whole number of bytes");
+      for (;end > 0 && input[end - 1] === chr; end--) {
+        const last = end - 1;
+        const byte = last * bits;
+        if (byte % 8 === 0)
+          throw new Error("padding: invalid, string has too much padding");
+      }
+      return input.slice(0, end);
+    }
+  };
+}
+function normalize(fn) {
+  afn(fn);
+  return { encode: (from) => from, decode: (to) => fn(to) };
+}
+function convertRadix(data, from, to) {
+  if (from < 2)
+    throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+  if (to < 2)
+    throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+  aArr(data);
+  if (!data.length)
+    return [];
+  let pos = 0;
+  const res = [];
+  const digits = Array.from(data, (d) => {
+    anumber(d);
+    if (d < 0 || d >= from)
+      throw new Error(`invalid integer: ${d}`);
+    return d;
+  });
+  const dlen = digits.length;
+  while (true) {
+    let carry = 0;
+    let done = true;
+    for (let i = pos;i < dlen; i++) {
+      const digit = digits[i];
+      const fromCarry = from * carry;
+      const digitBase = fromCarry + digit;
+      if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) {
+        throw new Error("convertRadix: carry overflow");
+      }
+      const div = digitBase / to;
+      carry = digitBase % to;
+      const rounded = Math.floor(div);
+      digits[i] = rounded;
+      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+        throw new Error("convertRadix: carry overflow");
+      if (!done)
+        continue;
+      else if (!rounded)
+        pos = i;
+      else
+        done = false;
+    }
+    res.push(carry);
+    if (done)
+      break;
+  }
+  for (let i = 0;i < data.length - 1 && data[i] === 0; i++)
+    res.push(0);
+  return res.reverse();
+}
+var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+var radix2carry = (from, to) => from + (to - gcd(from, to));
+var powers = /* @__PURE__ */ (() => {
+  let res = [];
+  for (let i = 0;i < 40; i++)
+    res.push(2 ** i);
+  return res;
+})();
+function convertRadix2(data, from, to, padding2) {
+  aArr(data);
+  if (from <= 0 || from > 32)
+    throw new Error(`convertRadix2: wrong from=${from}`);
+  if (to <= 0 || to > 32)
+    throw new Error(`convertRadix2: wrong to=${to}`);
+  if (radix2carry(from, to) > 32) {
+    throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`);
+  }
+  let carry = 0;
+  let pos = 0;
+  const max = powers[from];
+  const mask = powers[to] - 1;
+  const res = [];
+  for (const n of data) {
+    anumber(n);
+    if (n >= max)
+      throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+    carry = carry << from | n;
+    if (pos + from > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+    pos += from;
+    for (;pos >= to; pos -= to)
+      res.push((carry >> pos - to & mask) >>> 0);
+    const pow = powers[pos];
+    if (pow === undefined)
+      throw new Error("invalid carry");
+    carry &= pow - 1;
+  }
+  carry = carry << to - pos & mask;
+  if (!padding2 && pos >= from)
+    throw new Error("Excess padding");
+  if (!padding2 && carry > 0)
+    throw new Error(`Non-zero padding: ${carry}`);
+  if (padding2 && pos > 0)
+    res.push(carry >>> 0);
+  return res;
+}
+function radix(num) {
+  anumber(num);
+  const _256 = 2 ** 8;
+  return {
+    encode: (bytes) => {
+      if (!isBytes(bytes))
+        throw new Error("radix.encode input should be Uint8Array");
+      return convertRadix(Array.from(bytes), _256, num);
+    },
+    decode: (digits) => {
+      anumArr("radix.decode", digits);
+      return Uint8Array.from(convertRadix(digits, num, _256));
+    }
+  };
+}
+function radix2(bits, revPadding = false) {
+  anumber(bits);
+  if (bits <= 0 || bits > 32)
+    throw new Error("radix2: bits should be in (0..32]");
+  if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (bytes) => {
+      if (!isBytes(bytes))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+    },
+    decode: (digits) => {
+      anumArr("radix2.decode", digits);
+      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+    }
+  };
+}
+function unsafeWrapper(fn) {
+  afn(fn);
+  return function(...args) {
+    try {
+      return fn.apply(null, args);
+    } catch (e) {}
+  };
+}
+var base16 = chain(radix2(4), alphabet("0123456789ABCDEF"), join(""));
+var base32 = chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding(5), join(""));
+var base32nopad = chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), join(""));
+var base32hex = chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), padding(5), join(""));
+var base32hexnopad = chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), join(""));
+var base32crockford = chain(radix2(5), alphabet("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), join(""), normalize((s) => s.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1")));
+var hasBase64Builtin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toBase64 === "function" && typeof Uint8Array.fromBase64 === "function")();
+var decodeBase64Builtin = (s, isUrl) => {
+  astr("base64", s);
+  const re = isUrl ? /^[A-Za-z0-9=_-]+$/ : /^[A-Za-z0-9=+/]+$/;
+  const alphabet2 = isUrl ? "base64url" : "base64";
+  if (s.length > 0 && !re.test(s))
+    throw new Error("invalid base64");
+  return Uint8Array.fromBase64(s, { alphabet: alphabet2, lastChunkHandling: "strict" });
+};
+var base64 = hasBase64Builtin ? {
+  encode(b) {
+    abytes(b);
+    return b.toBase64();
+  },
+  decode(s) {
+    return decodeBase64Builtin(s, false);
+  }
+} : chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding(6), join(""));
+var base64nopad = chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), join(""));
+var base64url = hasBase64Builtin ? {
+  encode(b) {
+    abytes(b);
+    return b.toBase64({ alphabet: "base64url" });
+  },
+  decode(s) {
+    return decodeBase64Builtin(s, true);
+  }
+} : chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding(6), join(""));
+var base64urlnopad = chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), join(""));
+var genBase58 = (abc) => chain(radix(58), alphabet(abc), join(""));
+var base58 = genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+var base58flickr = genBase58("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ");
+var base58xrp = genBase58("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz");
+var BECH_ALPHABET = chain(alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), join(""));
+var POLYMOD_GENERATORS = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function bech32Polymod(pre) {
+  const b = pre >> 25;
+  let chk = (pre & 33554431) << 5;
+  for (let i = 0;i < POLYMOD_GENERATORS.length; i++) {
+    if ((b >> i & 1) === 1)
+      chk ^= POLYMOD_GENERATORS[i];
+  }
+  return chk;
+}
+function bechChecksum(prefix, words, encodingConst = 1) {
+  const len = prefix.length;
+  let chk = 1;
+  for (let i = 0;i < len; i++) {
+    const c = prefix.charCodeAt(i);
+    if (c < 33 || c > 126)
+      throw new Error(`Invalid prefix (${prefix})`);
+    chk = bech32Polymod(chk) ^ c >> 5;
+  }
+  chk = bech32Polymod(chk);
+  for (let i = 0;i < len; i++)
+    chk = bech32Polymod(chk) ^ prefix.charCodeAt(i) & 31;
+  for (let v of words)
+    chk = bech32Polymod(chk) ^ v;
+  for (let i = 0;i < 6; i++)
+    chk = bech32Polymod(chk);
+  chk ^= encodingConst;
+  return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));
+}
+function genBech32(encoding) {
+  const ENCODING_CONST = encoding === "bech32" ? 1 : 734539939;
+  const _words = radix2(5);
+  const fromWords = _words.decode;
+  const toWords = _words.encode;
+  const fromWordsUnsafe = unsafeWrapper(fromWords);
+  function encode(prefix, words, limit = 90) {
+    astr("bech32.encode prefix", prefix);
+    if (isBytes(words))
+      words = Array.from(words);
+    anumArr("bech32.encode", words);
+    const plen = prefix.length;
+    if (plen === 0)
+      throw new TypeError(`Invalid prefix length ${plen}`);
+    const actualLength = plen + 7 + words.length;
+    if (limit !== false && actualLength > limit)
+      throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
+    const lowered = prefix.toLowerCase();
+    const sum = bechChecksum(lowered, words, ENCODING_CONST);
+    return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
+  }
+  function decode(str, limit = 90) {
+    astr("bech32.decode input", str);
+    const slen = str.length;
+    if (slen < 8 || limit !== false && slen > limit)
+      throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);
+    const lowered = str.toLowerCase();
+    if (str !== lowered && str !== str.toUpperCase())
+      throw new Error(`String must be lowercase or uppercase`);
+    const sepIndex = lowered.lastIndexOf("1");
+    if (sepIndex === 0 || sepIndex === -1)
+      throw new Error(`Letter "1" must be present between prefix and data only`);
+    const prefix = lowered.slice(0, sepIndex);
+    const data = lowered.slice(sepIndex + 1);
+    if (data.length < 6)
+      throw new Error("Data must be at least 6 characters long");
+    const words = BECH_ALPHABET.decode(data).slice(0, -6);
+    const sum = bechChecksum(prefix, words, ENCODING_CONST);
+    if (!data.endsWith(sum))
+      throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
+    return { prefix, words };
+  }
+  const decodeUnsafe = unsafeWrapper(decode);
+  function decodeToBytes(str) {
+    const { prefix, words } = decode(str, false);
+    return { prefix, words, bytes: fromWords(words) };
+  }
+  function encodeFromBytes(prefix, bytes) {
+    return encode(prefix, toWords(bytes));
+  }
+  return {
+    encode,
+    decode,
+    encodeFromBytes,
+    decodeToBytes,
+    decodeUnsafe,
+    fromWords,
+    fromWordsUnsafe,
+    toWords
+  };
+}
+var bech32 = genBech32("bech32");
+var bech32m = genBech32("bech32m");
+var hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+var hexBuiltin = {
+  encode(data) {
+    abytes(data);
+    return data.toHex();
+  },
+  decode(s) {
+    astr("hex", s);
+    return Uint8Array.fromHex(s);
+  }
+};
+var hex = hasHexBuiltin ? hexBuiltin : chain(radix2(4), alphabet("0123456789abcdef"), join(""), normalize((s) => {
+  if (typeof s !== "string" || s.length % 2 !== 0)
+    throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);
+  return s.toLowerCase();
+}));
+
+// src/pox/utils.ts
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Decode(str) {
+  let num = 0n;
+  for (const char of str) {
+    const idx = BASE58_ALPHABET.indexOf(char);
+    if (idx === -1)
+      throw new Error(`Invalid base58 character: ${char}`);
+    num = num * 58n + BigInt(idx);
+  }
+  const hex2 = num.toString(16).padStart(2, "0");
+  const padded = hex2.length % 2 ? "0" + hex2 : hex2;
+  const rawBytes = hexToBytes(padded);
+  let leadingZeros = 0;
+  for (const char of str) {
+    if (char === "1")
+      leadingZeros++;
+    else
+      break;
+  }
+  const result = new Uint8Array(leadingZeros + rawBytes.length);
+  result.set(rawBytes, leadingZeros);
+  return result;
+}
+function parseBtcAddress(address) {
+  if (address.startsWith("bc1") || address.startsWith("tb1") || address.startsWith("bcrt1")) {
+    return parseSegwitAddress(address);
+  }
+  return parseLegacyAddress(address);
+}
+function parseSegwitAddress(address) {
+  let decoded;
+  try {
+    decoded = bech32.decode(address);
+  } catch {
+    decoded = bech32m.decode(address);
+  }
+  const witnessVersion = decoded.words[0];
+  const data = bech32.fromWords(decoded.words.slice(1));
+  const hashbytes = new Uint8Array(data);
+  let version;
+  if (witnessVersion === 0) {
+    if (hashbytes.length === 20) {
+      version = POX_ADDRESS_VERSION.p2wpkh;
+    } else if (hashbytes.length === 32) {
+      version = POX_ADDRESS_VERSION.p2wsh;
+    } else {
+      throw new Error(`Invalid witness v0 program length: ${hashbytes.length}`);
+    }
+  } else if (witnessVersion === 1) {
+    if (hashbytes.length !== 32) {
+      throw new Error(`Invalid witness v1 program length: ${hashbytes.length}`);
+    }
+    version = POX_ADDRESS_VERSION.p2tr;
+  } else {
+    throw new Error(`Unsupported witness version: ${witnessVersion}`);
+  }
+  const padded = new Uint8Array(32);
+  padded.set(hashbytes);
+  return {
+    version: new Uint8Array([version]),
+    hashbytes: padded
+  };
+}
+function parseLegacyAddress(address) {
+  const decoded = base58Decode(address);
+  if (decoded.length !== 25) {
+    throw new Error(`Invalid legacy address length: ${decoded.length}`);
+  }
+  const versionByte = decoded[0];
+  const hashbytes = decoded.slice(1, 21);
+  let version;
+  if (versionByte === 0 || versionByte === 111) {
+    version = POX_ADDRESS_VERSION.p2pkh;
+  } else if (versionByte === 5 || versionByte === 196) {
+    version = POX_ADDRESS_VERSION.p2sh;
+  } else {
+    throw new Error(`Unknown legacy address version byte: 0x${versionByte.toString(16)}`);
+  }
+  const padded = new Uint8Array(32);
+  padded.set(hashbytes);
+  return {
+    version: new Uint8Array([version]),
+    hashbytes: padded
+  };
+}
+function validateLockPeriod(periods) {
+  return Number.isInteger(periods) && periods >= MIN_LOCK_PERIOD && periods <= MAX_LOCK_PERIOD;
+}
+function burnHeightToRewardCycle(burnHeight, firstBurnchainBlockHeight, rewardCycleLength) {
+  return (burnHeight - firstBurnchainBlockHeight) / rewardCycleLength;
+}
+function rewardCycleToBurnHeight(cycle, firstBurnchainBlockHeight, rewardCycleLength) {
+  return firstBurnchainBlockHeight + cycle * rewardCycleLength;
+}
+
+// src/pox/actions.ts
+function getPoxContract(client) {
+  if (!client.chain) {
+    throw new Error("Client must have a chain configured");
+  }
+  const network = client.chain.network;
+  const contract = network === "mainnet" ? POX_CONTRACTS.mainnet : POX_CONTRACTS.testnet;
+  return getContract({
+    client,
+    address: contract.address,
+    name: contract.name,
+    abi: POX_ABI
+  });
+}
+async function getPoxInfo(client) {
+  const pox = getPoxContract(client);
+  return await pox.read["get-pox-info"]({});
+}
+async function getStackerInfo(client, address) {
+  const pox = getPoxContract(client);
+  return await pox.read["get-stacker-info"]({
+    stacker: address
+  });
+}
+async function getDelegationInfo(client, address) {
+  const pox = getPoxContract(client);
+  return await pox.read["get-delegation-info"]({
+    stacker: address
+  });
+}
+async function canStack(client, amount) {
+  const info = await getPoxInfo(client);
+  return amount >= info.minAmountUstx;
+}
+async function stackStx(client, params) {
+  if (!client.account)
+    throw new Error("Wallet client required");
+  if (!validateLockPeriod(params.lockPeriod)) {
+    throw new Error("Lock period must be 1-12 cycles");
+  }
+  const info = await getPoxInfo(client);
+  if (params.amount < info.minAmountUstx) {
+    throw new Error(`Amount below minimum: ${info.minAmountUstx}`);
+  }
+  const poxAddr = parseBtcAddress(params.btcAddress);
+  const pox = getPoxContract(client);
+  return pox.call["stack-stx"]({
+    amountUstx: params.amount,
+    poxAddr,
+    startBurnHt: params.startBurnHeight,
+    lockPeriod: BigInt(params.lockPeriod),
+    signerSig: params.signerSig,
+    signerKey: params.signerKey,
+    maxAmount: params.maxAmount,
+    authId: params.authId
+  }, {
+    postConditions: [
+      Pc.principal(client.account.address).willSendEq(params.amount).ustx()
+    ]
+  });
+}
+async function delegateStx(client, params) {
+  if (!client.account)
+    throw new Error("Wallet client required");
+  const poxAddr = params.poxAddr ? parseBtcAddress(params.poxAddr) : null;
+  const pox = getPoxContract(client);
+  return pox.call["delegate-stx"]({
+    amountUstx: params.amount,
+    delegateTo: params.delegateTo,
+    untilBurnHt: params.untilBurnHeight ?? null,
+    poxAddr
+  });
+}
+async function revokeDelegateStx(client) {
+  if (!client.account)
+    throw new Error("Wallet client required");
+  const pox = getPoxContract(client);
+  return pox.call["revoke-delegate-stx"]({});
+}
+async function stackExtend(client, params) {
+  if (!client.account)
+    throw new Error("Wallet client required");
+  if (!validateLockPeriod(params.extendCount)) {
+    throw new Error("Extend count must be 1-12 cycles");
+  }
+  const poxAddr = parseBtcAddress(params.btcAddress);
+  const pox = getPoxContract(client);
+  return pox.call["stack-extend"]({
+    extendCount: BigInt(params.extendCount),
+    poxAddr,
+    signerSig: params.signerSig,
+    signerKey: params.signerKey,
+    maxAmount: params.maxAmount,
+    authId: params.authId
+  });
+}
+async function stackIncrease(client, params) {
+  if (!client.account)
+    throw new Error("Wallet client required");
+  const pox = getPoxContract(client);
+  return pox.call["stack-increase"]({
+    increaseBy: params.increaseBy,
+    signerSig: params.signerSig,
+    signerKey: params.signerKey,
+    maxAmount: params.maxAmount,
+    authId: params.authId
+  }, {
+    postConditions: [
+      Pc.principal(client.account.address).willSendEq(params.increaseBy).ustx()
+    ]
+  });
+}
+
+// src/pox/index.ts
+function pox() {
+  return (client) => ({
+    pox: {
+      getPoxInfo: () => getPoxInfo(client),
+      getStackerInfo: (address) => getStackerInfo(client, address),
+      getDelegationInfo: (address) => getDelegationInfo(client, address),
+      canStack: (amount) => canStack(client, amount),
+      stackStx: (params) => stackStx(client, params),
+      delegateStx: (params) => delegateStx(client, params),
+      revokeDelegateStx: () => revokeDelegateStx(client),
+      stackExtend: (params) => stackExtend(client, params),
+      stackIncrease: (params) => stackIncrease(client, params)
+    }
+  });
+}
+export {
+  validateLockPeriod,
+  rewardCycleToBurnHeight,
+  pox,
+  parseBtcAddress,
+  burnHeightToRewardCycle,
+  POX_CONTRACTS,
+  POX_ADDRESS_VERSION,
+  MIN_LOCK_PERIOD,
+  MAX_LOCK_PERIOD
+};
+
+//# debugId=4940239BB9C22EB664756E2164756E21
+//# sourceMappingURL=index.js.map