@secondlayer/stacks 6.1.0 → 6.1.1

package/dist/src/pox5/index.js

@@ -1,49 +1,48 @@
 import {
-  EPOCH_4_ACTIVATION_BURN_HEIGHT_MAINNET,
-  buildTxProof
-} from "../../shared/stacks-esm-r6dejrgr.js";
+  bytesToHex2,
+  hexToBytes2,
+  concatBytes2,
+  intToBigInt2
+} from "../../shared/stacks-esm-7a0ehykf.js";
 import {
-  BtcAddress,
-  canonicalizeBtcAddress,
-  parseBtcAddress,
-  stringifyBtcAddress
-} from "../../shared/stacks-esm-q19a17fd.js";
+  serializeCVBytes2,
+  Cl2,
+  deserializeCVBytes2
+} from "../../shared/stacks-esm-hkw1kvd4.js";
+import"../../shared/stacks-esm-kbz5s6v8.js";
+import"../../shared/stacks-esm-a20wyky3.js";
+import"../../shared/stacks-esm-phgy8yqf.js";
+import"../../shared/stacks-esm-cmtj5vky.js";
 import {
-  BITCOIN_NETWORK_PARAMS,
-  parseBitcoinTx,
-  stripWitness
-} from "../../shared/stacks-esm-wv67m4g6.js";
+  parseBitcoinTx2,
+  stripWitness2,
+  BITCOIN_NETWORK_PARAMS
+} from "../../shared/stacks-esm-e2qhfgke.js";
 import {
-  getContract
-} from "../../shared/stacks-esm-aw2mj3sj.js";
+  structuredDataHash2
+} from "../../shared/stacks-esm-tdrdye4y.js";
 import {
-  getBalance,
-  getDataVar,
-  multicall
-} from "../../shared/stacks-esm-x1r01353.js";
+  canonicalizeBtcAddress,
+  parseBtcAddress2,
+  stringifyBtcAddress2,
+  BtcAddress2
+} from "../../shared/stacks-esm-ss9ap75h.js";
 import {
-  getMapEntry
-} from "../../shared/stacks-esm-qk0p9fr6.js";
-import"../../shared/stacks-esm-743jfh10.js";
-import"../../shared/stacks-esm-hr7fpxtj.js";
+  buildTxProof2,
+  EPOCH_4_ACTIVATION_BURN_HEIGHT_MAINNET2
+} from "../../shared/stacks-esm-nt5hf8ht.js";
 import {
-  structuredDataHash
-} from "../../shared/stacks-esm-pxhfqfff.js";
-import"../../shared/stacks-esm-r9q4wnyw.js";
-import"../../shared/stacks-esm-skmcf5n2.js";
+  getContract2
+} from "../../shared/stacks-esm-snj9s2q8.js";
 import {
-  Cl,
-  deserializeCVBytes,
-  serializeCVBytes
-} from "../../shared/stacks-esm-fcfdn2zx.js";
-import"../../shared/stacks-esm-1jae0a3r.js";
-import"../../shared/stacks-esm-2mc7ebrm.js";
+  getBalance2,
+  getDataVar2,
+  multicall2
+} from "../../shared/stacks-esm-t88hc019.js";
 import {
-  bytesToHex,
-  concatBytes,
-  hexToBytes,
-  intToBigInt
-} from "../../shared/stacks-esm-cvhazvhd.js";
+  getMapEntry2
+} from "../../shared/stacks-esm-ea4m4bk7.js";
+import"../../shared/stacks-esm-0pc6tmf0.js";
 
 // src/pox5/constants.ts
 var POX5_CONTRACT_NAME = "pox-5";
@@ -69,7 +68,8 @@ var POX5_EVENT_TOPICS = [
   "grant-signer-key",
   "revoke-signer-grant"
 ];
-var POX5_ACTIVATION_BURN_HEIGHT_MAINNET = EPOCH_4_ACTIVATION_BURN_HEIGHT_MAINNET;
+var POX5_ACTIVATION_BURN_HEIGHT_MAINNET = EPOCH_4_ACTIVATION_BURN_HEIGHT_MAINNET2;
+var MAINNET_PREPARE_CYCLE_LENGTH = 100;
 var BOND_LENGTH_CYCLES = 12;
 var BOND_GAP_CYCLES = 2;
 var MAX_NUM_CYCLES = 96;
@@ -945,10 +945,10 @@ function pox5ContractId(client) {
 }
 function getPox5Contract(client) {
   const [address, name] = pox5ContractId(client).split(".");
-  return getContract({ client, address, name, abi: POX5_ABI });
+  return getContract2({ client, address, name, abi: POX5_ABI });
 }
 function toBytes(input) {
-  return typeof input === "string" ? hexToBytes(input) : input;
+  return typeof input === "string" ? hexToBytes2(input) : input;
 }
 function optionalBytes(input) {
   return input === undefined ? null : toBytes(input);
@@ -957,7 +957,7 @@ var MAX_LOCKUP_OUTPUTS = 10;
 var MAX_LEAF_HASHES = 14;
 function btcLockupArg(lockup) {
   if ("sbtcSats" in lockup)
-    return { err: intToBigInt(lockup.sbtcSats) };
+    return { err: intToBigInt2(lockup.sbtcSats) };
   if (lockup.l1Outputs.length === 0) {
     throw new Error("registerForBond: l1Outputs is empty — nothing would be locked");
   }
@@ -973,15 +973,15 @@ function btcLockupArg(lockup) {
   return {
     ok: {
       outputs: lockup.l1Outputs.map((o) => ({
-        height: intToBigInt(o.height),
+        height: intToBigInt2(o.height),
         tx: toBytes(o.tx),
-        outputIndex: intToBigInt(o.outputIndex),
+        outputIndex: intToBigInt2(o.outputIndex),
         header: toBytes(o.header),
         leafHashes: o.leafHashes.map(toBytes),
-        txCount: intToBigInt(o.txCount),
-        txIndex: intToBigInt(o.txIndex),
-        amount: intToBigInt(o.amount),
-        unlockBurnHeight: intToBigInt(o.unlockBurnHeight)
+        txCount: intToBigInt2(o.txCount),
+        txIndex: intToBigInt2(o.txIndex),
+        amount: intToBigInt2(o.amount),
+        unlockBurnHeight: intToBigInt2(o.unlockBurnHeight)
       })),
       stakerUnlockBytes: toBytes(lockup.stakerUnlockBytes)
     }
@@ -998,14 +998,14 @@ function setupBond(client, params) {
     ...tx
   } = params;
   return getPox5Contract(client).call.setupBond({
-    bondIndex: intToBigInt(bondIndex),
-    targetRate: intToBigInt(targetRate),
-    stxValueRatio: intToBigInt(stxValueRatio),
-    minUstxRatio: intToBigInt(minUstxRatio),
+    bondIndex: intToBigInt2(bondIndex),
+    targetRate: intToBigInt2(targetRate),
+    stxValueRatio: intToBigInt2(stxValueRatio),
+    minUstxRatio: intToBigInt2(minUstxRatio),
     earlyUnlockBytes: toBytes(earlyUnlockBytes),
     allowlist: allowlist.map((a) => ({
       staker: a.staker,
-      maxSats: intToBigInt(a.maxSats)
+      maxSats: intToBigInt2(a.maxSats)
     }))
   }, tx);
 }
@@ -1019,9 +1019,9 @@ function registerForBond(client, params) {
     ...tx
   } = params;
   return getPox5Contract(client).call.registerForBond({
-    bondIndex: intToBigInt(bondIndex),
+    bondIndex: intToBigInt2(bondIndex),
     signerManager,
-    amountUstx: intToBigInt(amountUstx),
+    amountUstx: intToBigInt2(amountUstx),
     btcLockup: btcLockupArg(btcLockup),
     signerCalldata: optionalBytes(signerCalldata)
   }, tx);
@@ -1045,9 +1045,9 @@ function stake(client, params) {
   } = params;
   return getPox5Contract(client).call.stake({
     signerManager,
-    amountUstx: intToBigInt(amountUstx),
-    numCycles: intToBigInt(numCycles),
-    startBurnHt: intToBigInt(startBurnHeight),
+    amountUstx: intToBigInt2(amountUstx),
+    numCycles: intToBigInt2(numCycles),
+    startBurnHt: intToBigInt2(startBurnHeight),
     signerCalldata: optionalBytes(signerCalldata)
   }, tx);
 }
@@ -1063,8 +1063,8 @@ function stakeUpdate(client, params) {
   return getPox5Contract(client).call.stakeUpdate({
     signerManager,
     oldSignerManager,
-    cyclesToExtend: intToBigInt(cyclesToExtend),
-    amountIncrease: intToBigInt(amountIncrease),
+    cyclesToExtend: intToBigInt2(cyclesToExtend),
+    amountIncrease: intToBigInt2(amountIncrease),
     signerCalldata: optionalBytes(signerCalldata)
   }, tx);
 }
@@ -1074,7 +1074,7 @@ function unstake(client, params) {
 }
 function unstakeSbtc(client, params) {
   const { signerManager, amountSats, ...tx } = params;
-  return getPox5Contract(client).call.unstakeSbtc({ signerManager, amountToWithdrawalSats: intToBigInt(amountSats) }, tx);
+  return getPox5Contract(client).call.unstakeSbtc({ signerManager, amountToWithdrawalSats: intToBigInt2(amountSats) }, tx);
 }
 function announceL1EarlyExit(client, params) {
   const { staker, oldSignerManager, ...tx } = params;
@@ -1082,21 +1082,21 @@ function announceL1EarlyExit(client, params) {
 }
 function calculateRewards(client, params) {
   const { bondPeriods, ...tx } = params;
-  return getPox5Contract(client).call.calculateRewards({ bondPeriods: bondPeriods.map(intToBigInt) }, tx);
+  return getPox5Contract(client).call.calculateRewards({ bondPeriods: bondPeriods.map(intToBigInt2) }, tx);
 }
 function claimRewards(client, params) {
   const { bondPeriods, rewardCycle, ...tx } = params;
   return getPox5Contract(client).call.claimRewards({
-    bondPeriods: bondPeriods.map(intToBigInt),
-    rewardCycle: intToBigInt(rewardCycle)
+    bondPeriods: bondPeriods.map(intToBigInt2),
+    rewardCycle: intToBigInt2(rewardCycle)
   }, tx);
 }
 function claimStakerRewardsForSigner(client, params) {
   const { staker, rewardCycle, bondIndex, ...tx } = params;
   return getPox5Contract(client).call.claimStakerRewardsForSigner({
     staker,
-    rewardCycle: intToBigInt(rewardCycle),
-    bondIndex: bondIndex === undefined ? null : intToBigInt(bondIndex)
+    rewardCycle: intToBigInt2(rewardCycle),
+    bondIndex: bondIndex === undefined ? null : intToBigInt2(bondIndex)
   }, tx);
 }
 function grantSignerKey(client, params) {
@@ -1104,7 +1104,7 @@ function grantSignerKey(client, params) {
   return getPox5Contract(client).call.grantSignerKey({
     signerKey: toBytes(signerKey),
     signerManager,
-    authId: intToBigInt(authId),
+    authId: intToBigInt2(authId),
     signerSig: toBytes(signerSig)
   }, tx);
 }
@@ -1135,18 +1135,18 @@ async function getBondMembership(client, staker) {
 }
 async function getProtocolBond(client, bondIndex) {
   return await getPox5Contract(client).read.getProtocolBond({
-    bondIndex: intToBigInt(bondIndex)
+    bondIndex: intToBigInt2(bondIndex)
   });
 }
 async function getBondAllowance(client, bondIndex, staker) {
   return await getPox5Contract(client).read.getBondAllowance({
-    bondIndex: intToBigInt(bondIndex),
+    bondIndex: intToBigInt2(bondIndex),
     staker
   });
 }
 function getTotalSbtcStakedForBond(client, bondIndex) {
   return getPox5Contract(client).read.getTotalSbtcStakedForBond({
-    bondIndex: intToBigInt(bondIndex)
+    bondIndex: intToBigInt2(bondIndex)
   });
 }
 function getStakerCustodiedSbtc(client, staker) {
@@ -1154,13 +1154,13 @@ function getStakerCustodiedSbtc(client, staker) {
 }
 function hasAnnouncedL1EarlyExit(client, bondIndex, staker) {
   return getPox5Contract(client).read.hasAnnouncedL1EarlyExit({
-    bondIndex: intToBigInt(bondIndex),
+    bondIndex: intToBigInt2(bondIndex),
     staker
   });
 }
 function getBondL1UnlockHeight(client, bondIndex) {
   return getPox5Contract(client).read.getBondL1UnlockHeight({
-    bondIndex: intToBigInt(bondIndex)
+    bondIndex: intToBigInt2(bondIndex)
   });
 }
 async function getSignerInfo(client, signer) {
@@ -1183,15 +1183,15 @@ function getFirstPox5RewardCycle(client) {
 function getEarned(client, params) {
   return getPox5Contract(client).read.getEarned({
     signer: params.signer,
-    rewardCycle: intToBigInt(params.rewardCycle),
-    bondIndex: params.bondIndex === undefined ? null : intToBigInt(params.bondIndex)
+    rewardCycle: intToBigInt2(params.rewardCycle),
+    bondIndex: params.bondIndex === undefined ? null : intToBigInt2(params.bondIndex)
   });
 }
 function getEarnedStakerRewards(client, params) {
   return getPox5Contract(client).read.getEarnedStakerRewards({
     signer: params.signer,
-    rewardCycle: intToBigInt(params.rewardCycle),
-    bondIndex: params.bondIndex === undefined ? null : intToBigInt(params.bondIndex),
+    rewardCycle: intToBigInt2(params.rewardCycle),
+    bondIndex: params.bondIndex === undefined ? null : intToBigInt2(params.bondIndex),
     staker: params.staker
   });
 }
@@ -1200,8 +1200,8 @@ function getLastRewardComputeHeight(client) {
 }
 function getTotalSharesStakedForCycle(client, rewardCycle, bondIndex) {
   return getPox5Contract(client).read.getTotalSharesStakedForCycle({
-    rewardCycle: intToBigInt(rewardCycle),
-    bondIndex: bondIndex === undefined ? null : intToBigInt(bondIndex)
+    rewardCycle: intToBigInt2(rewardCycle),
+    bondIndex: bondIndex === undefined ? null : intToBigInt2(bondIndex)
   });
 }
 
@@ -1285,11 +1285,11 @@ function finish(reasons) {
   return { ok: false, reasons: unique };
 }
 function toBytes2(input) {
-  return typeof input === "string" ? hexToBytes(input) : input;
+  return typeof input === "string" ? hexToBytes2(input) : input;
 }
 function outpointKey(tx, outputIndex) {
-  const hex = typeof tx === "string" ? tx.toLowerCase() : bytesToHex(tx);
-  return `${hex}:${intToBigInt(outputIndex)}`;
+  const hex = typeof tx === "string" ? tx.toLowerCase() : bytesToHex2(tx);
+  return `${hex}:${intToBigInt2(outputIndex)}`;
 }
 async function readCycleClock(client) {
   const info = await getPoxInfo(client);
@@ -1338,7 +1338,7 @@ function bondOverlaps(membership, newFirstCycle, clock) {
   return start + BOND_LENGTH_CYCLES > newFirstCycle;
 }
 async function stxFloor(client, staker, amountUstx) {
-  const balance = await getBalance(client, { address: staker });
+  const balance = await getBalance2(client, { address: staker });
   if (balance < amountUstx)
     return Pox5ErrorCode.InsufficientStx;
   return;
@@ -1353,9 +1353,9 @@ function minUstxForSats(sats, stxValueRatio, minUstxRatio) {
 }
 async function eligibleStake(client, params) {
   const reasons = [];
-  const amountUstx = intToBigInt(params.amountUstx);
-  const numCycles = intToBigInt(params.numCycles);
-  const startBurnHeight = intToBigInt(params.startBurnHeight);
+  const amountUstx = intToBigInt2(params.amountUstx);
+  const numCycles = intToBigInt2(params.numCycles);
+  const startBurnHeight = intToBigInt2(params.startBurnHeight);
   const [clock, stakerInfo, membership, signerErrs, floor] = await Promise.all([
     readCycleClock(client),
     getStakerInfo(client, params.staker),
@@ -1396,18 +1396,18 @@ async function eligibleStake(client, params) {
 }
 async function eligibleRegisterForBond(client, params) {
   const reasons = [];
-  const amountUstx = intToBigInt(params.amountUstx);
+  const amountUstx = intToBigInt2(params.amountUstx);
   const lockup = params.btcLockup;
   let sats = 0n;
   if ("sbtcSats" in lockup) {
-    sats = intToBigInt(lockup.sbtcSats);
+    sats = intToBigInt2(lockup.sbtcSats);
   } else {
     if (lockup.l1Outputs.length === 0) {
       reasons.push(Pox5ErrorCode.InvalidLockupAmount);
     }
     const seen = new Set;
     for (const output of lockup.l1Outputs) {
-      sats += intToBigInt(output.amount);
+      sats += intToBigInt2(output.amount);
       const key = outpointKey(output.tx, output.outputIndex);
       if (seen.has(key))
         reasons.push(Pox5ErrorCode.DuplicateLockupOutpoint);
@@ -1440,14 +1440,14 @@ async function eligibleRegisterForBond(client, params) {
       reasons.push(Pox5ErrorCode.InsufficientStx);
   }
   if (clock) {
-    const bondStart = bondPeriodToBurnHeight(Number(intToBigInt(params.bondIndex)), {
+    const bondStart = bondPeriodToBurnHeight(Number(intToBigInt2(params.bondIndex)), {
       ...clock.params,
       firstBondPeriodCycle: clock.firstBondPeriodCycle
     });
     if (clock.burnHeight >= bondStart) {
       reasons.push(Pox5ErrorCode.BondAlreadyStarted);
     }
-    const firstRewardCycle = bondPeriodToRewardCycle(Number(intToBigInt(params.bondIndex)), { ...clock.params, firstBondPeriodCycle: clock.firstBondPeriodCycle });
+    const firstRewardCycle = bondPeriodToRewardCycle(Number(intToBigInt2(params.bondIndex)), { ...clock.params, firstBondPeriodCycle: clock.firstBondPeriodCycle });
     if (stakerInfo) {
       const unlockCycle = Number(stakerInfo.firstRewardCycle) + Number(stakerInfo.numCycles);
       if (unlockCycle > firstRewardCycle) {
@@ -1467,7 +1467,7 @@ async function eligibleRegisterForBond(client, params) {
   if ("l1Outputs" in lockup && lockup.l1Outputs.length > 0) {
     const minUnlock = await getBondL1UnlockHeight(client, params.bondIndex);
     for (const output of lockup.l1Outputs) {
-      const height = intToBigInt(output.unlockBurnHeight);
+      const height = intToBigInt2(output.unlockBurnHeight);
       if (height < minUnlock || height >= BITCOIN_LOCKTIME_THRESHOLD) {
         reasons.push(Pox5ErrorCode.InvalidUnlockHeight);
       }
@@ -1492,7 +1492,7 @@ async function eligibleUnstake(client, params) {
 }
 async function eligibleUnstakeSbtc(client, params) {
   const reasons = [];
-  const amount = intToBigInt(params.amountSats);
+  const amount = intToBigInt2(params.amountSats);
   const [clock, membership] = await Promise.all([
     readCycleClock(client),
     getBondMembership(client, params.staker)
@@ -1516,7 +1516,7 @@ async function eligibleUnstakeSbtc(client, params) {
 async function eligibleClaimRewards(client, params) {
   const reasons = [];
   const contract = pox5ContractId(client);
-  const paused = await getDataVar(client, {
+  const paused = await getDataVar2(client, {
     contract,
     varName: "rewards-paused"
   });
@@ -1544,13 +1544,13 @@ async function eligibleClaimRewards(client, params) {
 }
 async function eligibleGrantSignerKey(client, params) {
   const reasons = [];
-  const used = await getMapEntry(client, {
+  const used = await getMapEntry2(client, {
     contract: pox5ContractId(client),
     mapName: "used-signer-key-grants",
-    key: Cl.tuple({
-      "signer-key": Cl.buffer(toBytes2(params.signerKey)),
-      "signer-manager": Cl.principal(params.signerManager),
-      "auth-id": Cl.uint(intToBigInt(params.authId))
+    key: Cl2.tuple({
+      "signer-key": Cl2.buffer(toBytes2(params.signerKey)),
+      "signer-manager": Cl2.principal(params.signerManager),
+      "auth-id": Cl2.uint(intToBigInt2(params.authId))
     })
   });
   if (used.type === "some")
@@ -1558,7 +1558,7 @@ async function eligibleGrantSignerKey(client, params) {
   return finish(reasons);
 }
 async function eligibleSetBondAdmin(client, params) {
-  const admin = await getDataVar(client, {
+  const admin = await getDataVar2(client, {
     contract: pox5ContractId(client),
     varName: "bond-admin"
   });
@@ -1568,7 +1568,7 @@ async function eligibleSetBondAdmin(client, params) {
   return { ok: true };
 }
 async function eligiblePauseRewards(client, params) {
-  const admin = await getDataVar(client, {
+  const admin = await getDataVar2(client, {
     contract: pox5ContractId(client),
     varName: "pause-admin"
   });
@@ -1610,7 +1610,7 @@ function pushScriptBytes(bytes) {
     prefix = Uint8Array.of(76, len);
   else
     prefix = Uint8Array.of(77, len & 255, len >> 8);
-  return concatBytes(prefix, bytes);
+  return concatBytes2(prefix, bytes);
 }
 function pushCScriptNum(n) {
   const big = typeof n === "bigint" ? n : BigInt(n);
@@ -1621,13 +1621,13 @@ function pushCScriptNum(n) {
   return pushScriptBytes(serializeCScriptNum(big));
 }
 function stakerConsensusBuff(stxAddress) {
-  return serializeCVBytes(Cl.principal(stxAddress));
+  return serializeCVBytes2(Cl2.principal(stxAddress));
 }
 function stakerPreimage(stxAddress) {
   return sha256(stakerConsensusBuff(stxAddress));
 }
 function toBytes3(input) {
-  return typeof input === "string" ? hexToBytes(input) : input;
+  return typeof input === "string" ? hexToBytes2(input) : input;
 }
 function buildLockupScript(opts) {
   const height = BigInt(opts.unlockBurnHeight);
@@ -1638,10 +1638,10 @@ function buildLockupScript(opts) {
     throw new Error("unlockBurnHeight >= 500,000,000 would be read by Bitcoin as a timestamp (contract rejects it)");
   }
   const stakerHash = sha256(stakerPreimage(opts.stxAddress));
-  return concatBytes(Uint8Array.of(99), pushCScriptNum(height), Uint8Array.of(177, 103), hexToBytes("82012088a820"), stakerHash, Uint8Array.of(136), toBytes3(opts.earlyUnlockBytes), Uint8Array.of(104, 105), toBytes3(opts.stakerUnlockBytes));
+  return concatBytes2(Uint8Array.of(99), pushCScriptNum(height), Uint8Array.of(177, 103), hexToBytes2("82012088a820"), stakerHash, Uint8Array.of(136), toBytes3(opts.earlyUnlockBytes), Uint8Array.of(104, 105), toBytes3(opts.stakerUnlockBytes));
 }
 function buildLockupOutputScript(opts) {
-  return concatBytes(Uint8Array.of(0, 32), sha256(buildLockupScript(opts)));
+  return concatBytes2(Uint8Array.of(0, 32), sha256(buildLockupScript(opts)));
 }
 function buildLockupAddress(opts, network = "mainnet") {
   const hash = sha256(buildLockupScript(opts));
@@ -1658,7 +1658,7 @@ function buildDefaultStakerUnlockBytes(publicKey) {
   if (prefix !== 2 && prefix !== 3) {
     throw new Error(`Expected compressed pubkey prefix 0x02 or 0x03, got ${prefix}`);
   }
-  return concatBytes(pushScriptBytes(pubkey), Uint8Array.of(172));
+  return concatBytes2(pushScriptBytes(pubkey), Uint8Array.of(172));
 }
 function buildRegisterMetadata(opts) {
   const unlockHeight = computeBondUnlockHeight(opts.bondIndex, opts.cycle);
@@ -1680,16 +1680,16 @@ function buildRegisterMetadata(opts) {
 // src/pox5/grants.ts
 import { secp256k1 } from "@noble/curves/secp256k1.js";
 function computeSignerGrantHash(opts) {
-  return structuredDataHash({
-    domain: Cl.tuple({
-      name: Cl.stringAscii(POX5_SIGNER_DOMAIN.name),
-      version: Cl.stringAscii(POX5_SIGNER_DOMAIN.version),
-      "chain-id": Cl.uint(opts.chainId)
+  return structuredDataHash2({
+    domain: Cl2.tuple({
+      name: Cl2.stringAscii(POX5_SIGNER_DOMAIN.name),
+      version: Cl2.stringAscii(POX5_SIGNER_DOMAIN.version),
+      "chain-id": Cl2.uint(opts.chainId)
     }),
-    message: Cl.tuple({
-      topic: Cl.stringAscii("grant-authorization"),
-      "signer-manager": Cl.principal(opts.signerManager),
-      "auth-id": Cl.uint(opts.authId)
+    message: Cl2.tuple({
+      topic: Cl2.stringAscii("grant-authorization"),
+      "signer-manager": Cl2.principal(opts.signerManager),
+      "auth-id": Cl2.uint(opts.authId)
     })
   });
 }
@@ -1697,17 +1697,17 @@ async function signSignerGrant(account, opts) {
   const vrs = await account.sign(computeSignerGrantHash(opts));
   if (vrs.length !== 65)
     throw new Error(`Expected 65-byte recoverable signature, got ${vrs.length}`);
-  return bytesToHex(concatBytes(vrs.slice(1), vrs.slice(0, 1)));
+  return bytesToHex2(concatBytes2(vrs.slice(1), vrs.slice(0, 1)));
 }
 function verifySignerGrant(opts) {
   try {
-    const sig = typeof opts.signature === "string" ? hexToBytes(opts.signature) : opts.signature;
+    const sig = typeof opts.signature === "string" ? hexToBytes2(opts.signature) : opts.signature;
     if (sig.length !== 65)
       return false;
-    const pubkey = typeof opts.publicKey === "string" ? hexToBytes(opts.publicKey) : opts.publicKey;
+    const pubkey = typeof opts.publicKey === "string" ? hexToBytes2(opts.publicKey) : opts.publicKey;
     const hash = computeSignerGrantHash(opts);
     const recovered = secp256k1.Signature.fromBytes(sig.slice(0, 64)).addRecoveryBit(sig[64]).recoverPublicKey(hash).toBytes(true);
-    return bytesToHex(recovered) === bytesToHex(pubkey);
+    return bytesToHex2(recovered) === bytesToHex2(pubkey);
   } catch {
     return false;
   }
@@ -1716,15 +1716,15 @@ function verifySignerGrant(opts) {
 import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
 var MAX_LEAF_HASHES2 = 14;
 function lockupScriptPubKey(lockScript) {
-  return concatBytes(Uint8Array.of(0, 32), sha2562(lockScript));
+  return concatBytes2(Uint8Array.of(0, 32), sha2562(lockScript));
 }
 function scriptsEqual(a, b) {
-  return bytesToHex(a) === bytesToHex(b);
+  return bytesToHex2(a) === bytesToHex2(b);
 }
 function spvProofToL1LockupOutput(opts) {
   const { proof, lockScript, unlockBurnHeight } = opts;
-  const tx = stripWitness(proof.rawTx);
-  const parsed = parseBitcoinTx(proof.rawTx);
+  const tx = stripWitness2(proof.rawTx);
+  const parsed = parseBitcoinTx2(proof.rawTx);
   const expected = lockupScriptPubKey(lockScript);
   let outputIndex = opts.vout ?? proof.vout;
   if (outputIndex === undefined) {
@@ -1763,7 +1763,7 @@ function spvProofToL1LockupOutput(opts) {
   };
 }
 async function buildPox5LockProof(opts) {
-  const proof = await buildTxProof(opts.source, {
+  const proof = await buildTxProof2(opts.source, {
     txid: opts.txid,
     vout: opts.vout
   });
@@ -1796,16 +1796,16 @@ function btcNetworkFrom(network) {
   return REGTEST_NETWORK;
 }
 function toBytes4(value) {
-  return typeof value === "string" ? hexToBytes(value) : value;
+  return typeof value === "string" ? hexToBytes2(value) : value;
 }
 function toPrivBytes(value) {
   return toBytes4(value).slice(0, 32);
 }
 function bytesEqual(a, b) {
-  return bytesToHex(a) === bytesToHex(b);
+  return bytesToHex2(a) === bytesToHex2(b);
 }
 function scriptToWshOutput(lockScript) {
-  return concatBytes(Uint8Array.of(0, 32), sha2563(lockScript));
+  return concatBytes2(Uint8Array.of(0, 32), sha2563(lockScript));
 }
 var SCAFFOLD_PREFIX_LEN = 10;
 function decodeLockScript(script) {
@@ -1829,9 +1829,9 @@ function buildReclaim(opts) {
   const network = btcNetworkFrom(opts.network);
   const lockScript = toBytes4(opts.lockScript);
   const { unlockHeight: scriptHeight } = decodeLockScript(lockScript);
-  const amount = intToBigInt(opts.utxo.value);
+  const amount = intToBigInt2(opts.utxo.value);
   const { address } = opts.output;
-  const feeSats = intToBigInt(opts.output.feeSats);
+  const feeSats = intToBigInt2(opts.output.feeSats);
   if (feeSats < 0n) {
     throw new Error(`buildReclaim: feeSats (${feeSats}) must be non-negative`);
   }
@@ -1865,7 +1865,7 @@ function buildReclaim(opts) {
 function computeReclaimSighash(tx, opts) {
   const input = tx.getInput(0);
   const witnessScript = opts?.witnessScript != null ? toBytes4(opts.witnessScript) : input.witnessScript;
-  const amount = opts?.amountSats != null ? intToBigInt(opts.amountSats) : input.witnessUtxo?.amount;
+  const amount = opts?.amountSats != null ? intToBigInt2(opts.amountSats) : input.witnessUtxo?.amount;
   if (!witnessScript || amount == null) {
     throw new Error("computeReclaimSighash: need witnessScript + amount (pass `opts` for a raw-hex tx)");
   }
@@ -1873,7 +1873,7 @@ function computeReclaimSighash(tx, opts) {
 }
 function signReclaim(sighash, privateKey, opts) {
   const priv = toPrivBytes(privateKey);
-  return concatBytes(signECDSA(sighash, priv, opts?.lowR ?? false), Uint8Array.of(SIGHASH_ALL));
+  return concatBytes2(signECDSA(sighash, priv, opts?.lowR ?? false), Uint8Array.of(SIGHASH_ALL));
 }
 function finalizeReclaim(opts) {
   const { tx } = opts;
@@ -1941,23 +1941,23 @@ function reclaim(opts) {
 // src/pox5/extension.ts
 async function getStakerState(client, staker) {
   const contract = pox5ContractId(client);
-  const results = await multicall(client, {
+  const results = await multicall2(client, {
     allowFailure: false,
     calls: [
       {
         contract,
         functionName: "get-staker-info",
-        args: [Cl.principal(staker)]
+        args: [Cl2.principal(staker)]
       },
       {
         contract,
         functionName: "get-bond-membership",
-        args: [Cl.principal(staker)]
+        args: [Cl2.principal(staker)]
       },
       {
         contract,
         functionName: "get-staker-custodied-sbtc",
-        args: [Cl.principal(staker)]
+        args: [Cl2.principal(staker)]
       },
       { contract, functionName: "current-pox-reward-cycle", args: [] }
     ]
@@ -2024,17 +2024,17 @@ function pox5() {
 }
 // src/pox5/signerCalldata.ts
 function buildSignerCalldata(opts) {
-  const repr = canonicalizeBtcAddress(typeof opts.poxAddress === "string" ? parseBtcAddress(opts.poxAddress) : opts.poxAddress);
-  return serializeCVBytes(Cl.tuple({
-    "pox-addr": Cl.tuple({
-      version: Cl.buffer(Uint8Array.of(repr.version)),
-      hashbytes: Cl.buffer(repr.hashbytes)
+  const repr = canonicalizeBtcAddress(typeof opts.poxAddress === "string" ? parseBtcAddress2(opts.poxAddress) : opts.poxAddress);
+  return serializeCVBytes2(Cl2.tuple({
+    "pox-addr": Cl2.tuple({
+      version: Cl2.buffer(Uint8Array.of(repr.version)),
+      hashbytes: Cl2.buffer(repr.hashbytes)
     }),
-    "max-fee": Cl.uint(opts.maxFeeSats)
+    "max-fee": Cl2.uint(opts.maxFeeSats)
   }));
 }
 function parseSignerCalldata(calldata) {
-  const cv = deserializeCVBytes(calldata);
+  const cv = deserializeCVBytes2(calldata);
   if (cv.type !== "tuple") {
     throw new Error("signer calldata is not a Clarity tuple");
   }
@@ -2054,7 +2054,7 @@ function parseSignerCalldata(calldata) {
   if (!hashCv || hashCv.type !== "buffer") {
     throw new Error("signer calldata pox-addr missing hashbytes buffer");
   }
-  const versionBytes = hexToBytes(versionCv.value);
+  const versionBytes = hexToBytes2(versionCv.value);
   if (versionBytes.length !== 1) {
     throw new Error(`signer calldata version must be buff 1, got ${versionBytes.length}`);
   }
@@ -2065,79 +2065,80 @@ function parseSignerCalldata(calldata) {
   return {
     poxAddress: canonicalizeBtcAddress({
       version,
-      hashbytes: hexToBytes(hashCv.value)
+      hashbytes: hexToBytes2(hashCv.value)
     }),
     maxFeeSats: maxFee.value
   };
 }
 export {
-  verifySignerGrant,
-  stringifyBtcAddress,
-  stakerPreimage,
-  stakerConsensusBuff,
-  spvProofToL1LockupOutput,
-  signSignerGrant,
-  signReclaim,
-  serializeCScriptNum,
-  rewardCycleToBurnHeight,
-  reclaim,
-  pushScriptBytes,
-  pushCScriptNum,
-  pox5ContractId,
-  pox5,
-  parseSignerCalldata,
-  parsePox5Error,
-  parseBtcAddress,
-  isPox5Active,
-  isInPreparePhase,
-  getPoxInfo,
-  getPox5Activation,
-  finalizeReclaim,
-  eligibleUnstakeSbtc,
-  eligibleUnstake,
-  eligibleStake,
-  eligibleSetBondAdmin,
-  eligibleRegisterForBond,
-  eligiblePauseRewards,
-  eligibleGrantSignerKey,
-  eligibleClaimRewards,
-  distributionCycleToBurnHeight,
-  describePox5Error,
-  currentDistributionCycle,
-  computeSignerGrantHash,
-  computeReclaimSighash,
-  computeBondUnlockHeight,
-  burnHeightToRewardCycle,
-  burnHeightToDistributionIndex,
-  buildSignerCalldata,
-  buildRegisterMetadata,
-  buildReclaim,
-  buildPox5LockProof,
-  buildLockupScript,
-  buildLockupOutputScript,
-  buildLockupAddress,
-  buildDefaultStakerUnlockBytes,
-  bondUnlockCycle,
-  bondStatusAtHeight,
-  bondPhaseAtHeight,
-  bondPeriodToRewardCycle,
-  bondPeriodToBurnHeight,
-  assertPox5Active,
-  Pox5ErrorCode,
-  POX5_SIGNER_DOMAIN,
-  POX5_EVENT_TOPICS,
-  POX5_ERROR_NAMES,
-  POX5_CONTRACT_NAME,
-  POX5_CONTRACT_ID_MAINNET,
-  POX5_ACTIVATION_BURN_HEIGHT_MAINNET,
-  POX5_ABI,
-  MAX_NUM_CYCLES,
-  C_SCRIPT_NUM_MAX,
-  BtcAddress,
-  BOND_LENGTH_CYCLES,
+  BITCOIN_LOCKTIME_THRESHOLD,
   BOND_GAP_CYCLES,
-  BITCOIN_LOCKTIME_THRESHOLD
+  BOND_LENGTH_CYCLES,
+  BtcAddress2 as BtcAddress,
+  C_SCRIPT_NUM_MAX,
+  MAINNET_PREPARE_CYCLE_LENGTH,
+  MAX_NUM_CYCLES,
+  POX5_ABI,
+  POX5_ACTIVATION_BURN_HEIGHT_MAINNET,
+  POX5_CONTRACT_ID_MAINNET,
+  POX5_CONTRACT_NAME,
+  POX5_ERROR_NAMES,
+  POX5_EVENT_TOPICS,
+  POX5_SIGNER_DOMAIN,
+  Pox5ErrorCode,
+  assertPox5Active,
+  bondPeriodToBurnHeight,
+  bondPeriodToRewardCycle,
+  bondPhaseAtHeight,
+  bondStatusAtHeight,
+  bondUnlockCycle,
+  buildDefaultStakerUnlockBytes,
+  buildLockupAddress,
+  buildLockupOutputScript,
+  buildLockupScript,
+  buildPox5LockProof,
+  buildReclaim,
+  buildRegisterMetadata,
+  buildSignerCalldata,
+  burnHeightToDistributionIndex,
+  burnHeightToRewardCycle,
+  computeBondUnlockHeight,
+  computeReclaimSighash,
+  computeSignerGrantHash,
+  currentDistributionCycle,
+  describePox5Error,
+  distributionCycleToBurnHeight,
+  eligibleClaimRewards,
+  eligibleGrantSignerKey,
+  eligiblePauseRewards,
+  eligibleRegisterForBond,
+  eligibleSetBondAdmin,
+  eligibleStake,
+  eligibleUnstake,
+  eligibleUnstakeSbtc,
+  finalizeReclaim,
+  getPox5Activation,
+  getPoxInfo,
+  isInPreparePhase,
+  isPox5Active,
+  parseBtcAddress2 as parseBtcAddress,
+  parsePox5Error,
+  parseSignerCalldata,
+  pox5,
+  pox5ContractId,
+  pushCScriptNum,
+  pushScriptBytes,
+  reclaim,
+  rewardCycleToBurnHeight,
+  serializeCScriptNum,
+  signReclaim,
+  signSignerGrant,
+  spvProofToL1LockupOutput,
+  stakerConsensusBuff,
+  stakerPreimage,
+  stringifyBtcAddress2 as stringifyBtcAddress,
+  verifySignerGrant
 };
 
-//# debugId=C098453496026E0064756E2164756E21
+//# debugId=ACA0F7197C35CC4B64756E2164756E21
 //# sourceMappingURL=index.js.map