@secondlayer/stacks 2.14.1 → 2.15.1

package/dist/src/pox5/index.js

@@ -0,0 +1,540 @@
+import {
+  BITCOIN_NETWORK_PARAMS
+} from "../../shared/stacks-0cdm20eh.js";
+import {
+  bech32
+} from "../../shared/stacks-5nmz5ad9.js";
+import {
+  multicall
+} from "../../shared/stacks-f0hfqaj5.js";
+import {
+  callContract
+} from "../../shared/stacks-q45x3389.js";
+import {
+  readContract
+} from "../../shared/stacks-msmgyerb.js";
+import"../../shared/stacks-y9w78e2b.js";
+import"../../shared/stacks-fh48neva.js";
+import"../../shared/stacks-709tra19.js";
+import"../../shared/stacks-ssndnbbd.js";
+import {
+  Cl,
+  serializeCVBytes
+} from "../../shared/stacks-2mm20wqf.js";
+import"../../shared/stacks-azp00pve.js";
+import {
+  bytesToHex,
+  concatBytes,
+  hexToBytes
+} from "../../shared/stacks-qs5fzts5.js";
+import"../../shared/stacks-cfazrteq.js";
+
+// src/pox5/constants.ts
+var POX5_CONTRACT_NAME = "pox-5";
+var POX5_ACTIVATION_BURN_HEIGHT_MAINNET = 960230;
+var BOND_LENGTH_CYCLES = 12;
+var BOND_GAP_CYCLES = 2;
+var MAX_NUM_CYCLES = 96;
+var POX5_SIGNER_DOMAIN = {
+  name: "pox-5-signer",
+  version: "1.0.0"
+};
+var C_SCRIPT_NUM_MAX = 549755813888n;
+var BITCOIN_LOCKTIME_THRESHOLD = 500000000n;
+
+// src/pox5/activation.ts
+async function getPox5Activation(client) {
+  const info = await client.request("/v2/pox", {
+    method: "GET"
+  });
+  const entry = info.contract_versions?.find((v) => v.contract_id.endsWith(`.${POX5_CONTRACT_NAME}`));
+  if (!entry)
+    return;
+  return {
+    contractId: entry.contract_id,
+    activationBurnchainBlockHeight: entry.activation_burnchain_block_height,
+    firstRewardCycleId: entry.first_reward_cycle_id
+  };
+}
+async function isPox5Active(client) {
+  const info = await client.request("/v2/pox", {
+    method: "GET"
+  });
+  const entry = info.contract_versions?.find((v) => v.contract_id.endsWith(`.${POX5_CONTRACT_NAME}`));
+  if (!entry || typeof info.current_burnchain_block_height !== "number")
+    return false;
+  return info.current_burnchain_block_height >= entry.activation_burnchain_block_height;
+}
+async function assertPox5Active(client) {
+  if (!await isPox5Active(client)) {
+    throw new Error("pox-5 is not active on this chain yet (Epoch 4.0 activates at Bitcoin block 960,230 on mainnet, ~2026-07-29). " + "Check getPox5Activation(client) for this network's activation height.");
+  }
+}
+// src/pox5/cycles.ts
+function burnHeightToRewardCycle(burnHeight, params) {
+  if (burnHeight < params.firstBurnchainBlockHeight) {
+    throw new Error(`burnHeight ${burnHeight} precedes first burnchain block ${params.firstBurnchainBlockHeight}`);
+  }
+  return Math.floor((burnHeight - params.firstBurnchainBlockHeight) / params.rewardCycleLength);
+}
+function rewardCycleToBurnHeight(cycle, params) {
+  return params.firstBurnchainBlockHeight + cycle * params.rewardCycleLength;
+}
+function bondPeriodToRewardCycle(bondIndex, params) {
+  return params.firstBondPeriodCycle + bondIndex * BOND_GAP_CYCLES;
+}
+function bondPeriodToBurnHeight(bondIndex, params) {
+  return rewardCycleToBurnHeight(bondPeriodToRewardCycle(bondIndex, params), params);
+}
+function bondUnlockCycle(bondIndex, params) {
+  return bondPeriodToRewardCycle(bondIndex, params) + BOND_LENGTH_CYCLES;
+}
+function burnHeightToDistributionIndex(burnHeight, params) {
+  return Math.floor((burnHeight - params.firstBurnchainBlockHeight) / Math.floor(params.rewardCycleLength / 2));
+}
+function isInPreparePhase(burnHeight, params) {
+  const offset = (burnHeight - params.firstBurnchainBlockHeight) % params.rewardCycleLength;
+  return offset >= params.rewardCycleLength - params.prepareCycleLength;
+}
+function bondPhaseAtHeight(bondIndex, burnHeight, params) {
+  const cycle = burnHeightToRewardCycle(burnHeight, params);
+  const start = bondPeriodToRewardCycle(bondIndex, params);
+  const unlock = bondUnlockCycle(bondIndex, params);
+  if (cycle < start - BOND_GAP_CYCLES)
+    return "too-early";
+  if (cycle < start)
+    return "open";
+  if (cycle < unlock)
+    return "locked";
+  return "unlocked";
+}
+// src/pox5/script.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+function serializeCScriptNum(n) {
+  const big = typeof n === "bigint" ? n : BigInt(n);
+  if (big < 0n)
+    throw new Error("serializeCScriptNum: negative value");
+  if (big >= C_SCRIPT_NUM_MAX) {
+    throw new Error("serializeCScriptNum: n >= 2^39 (contract rejects with ERR_INVALID_UNLOCK_HEIGHT)");
+  }
+  if (big === 0n)
+    return new Uint8Array(0);
+  const out = [];
+  let v = big;
+  while (v > 0n) {
+    out.push(Number(v & 0xffn));
+    v >>= 8n;
+  }
+  if (out[out.length - 1] & 128)
+    out.push(0);
+  return Uint8Array.from(out);
+}
+function pushScriptBytes(bytes) {
+  const len = bytes.length;
+  if (len > 65535)
+    throw new Error(`pushScriptBytes: payload too large (${len} > 65535)`);
+  let prefix;
+  if (len < 76)
+    prefix = Uint8Array.of(len);
+  else if (len < 256)
+    prefix = Uint8Array.of(76, len);
+  else
+    prefix = Uint8Array.of(77, len & 255, len >> 8);
+  return concatBytes(prefix, bytes);
+}
+function pushCScriptNum(n) {
+  const big = typeof n === "bigint" ? n : BigInt(n);
+  if (big === 0n)
+    return Uint8Array.of(0);
+  if (big >= 1n && big <= 16n)
+    return Uint8Array.of(80 + Number(big));
+  return pushScriptBytes(serializeCScriptNum(big));
+}
+function stakerConsensusBuff(stxAddress) {
+  return serializeCVBytes(Cl.principal(stxAddress));
+}
+function stakerPreimage(stxAddress) {
+  return sha256(stakerConsensusBuff(stxAddress));
+}
+function toBytes(input) {
+  return typeof input === "string" ? hexToBytes(input) : input;
+}
+function buildLockupScript(opts) {
+  const height = BigInt(opts.unlockBurnHeight);
+  if (height >= BITCOIN_LOCKTIME_THRESHOLD) {
+    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), toBytes(opts.earlyUnlockBytes), Uint8Array.of(104, 105), toBytes(opts.stakerUnlockBytes));
+}
+function buildLockupOutputScript(opts) {
+  return concatBytes(Uint8Array.of(0, 32), sha256(buildLockupScript(opts)));
+}
+function buildLockupAddress(opts, network = "mainnet") {
+  const hash = sha256(buildLockupScript(opts));
+  return bech32.encode(BITCOIN_NETWORK_PARAMS[network].hrp, [
+    0,
+    ...bech32.toWords(hash)
+  ]);
+}
+function buildDefaultStakerUnlockBytes(publicKey) {
+  const pubkey = toBytes(publicKey);
+  if (pubkey.length !== 33)
+    throw new Error(`Expected 33-byte compressed pubkey, got ${pubkey.length}`);
+  return concatBytes(pushScriptBytes(pubkey), Uint8Array.of(172));
+}
+// src/pox5/grants.ts
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+var SIP018_PREFIX = hexToBytes("534950303138");
+function computeSignerGrantHash(opts) {
+  const domain = serializeCVBytes(Cl.tuple({
+    name: Cl.stringAscii(POX5_SIGNER_DOMAIN.name),
+    version: Cl.stringAscii(POX5_SIGNER_DOMAIN.version),
+    "chain-id": Cl.uint(opts.chainId)
+  }));
+  const message = serializeCVBytes(Cl.tuple({
+    topic: Cl.stringAscii("grant-authorization"),
+    "signer-manager": Cl.principal(opts.signerManager),
+    "auth-id": Cl.uint(opts.authId)
+  }));
+  return sha2562(concatBytes(SIP018_PREFIX, sha2562(domain), sha2562(message)));
+}
+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)));
+}
+function verifySignerGrant(opts) {
+  try {
+    const sig = typeof opts.signature === "string" ? hexToBytes(opts.signature) : opts.signature;
+    if (sig.length !== 65)
+      return false;
+    const pubkey = typeof opts.publicKey === "string" ? hexToBytes(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);
+  } catch {
+    return false;
+  }
+}
+// src/pox5/actions.ts
+function pox5ContractId(client) {
+  const boot = client.chain?.bootAddress;
+  if (!boot)
+    throw new Error("Client must have a chain with a bootAddress");
+  return `${boot}.${POX5_CONTRACT_NAME}`;
+}
+function call(client, functionName, functionArgs, options = {}) {
+  return callContract(client, {
+    contract: pox5ContractId(client),
+    functionName,
+    functionArgs,
+    ...options
+  });
+}
+function read(client, functionName, functionArgs = []) {
+  const [address, name] = pox5ContractId(client).split(".");
+  return readContract(client, {
+    contract: `${address}.${name}`,
+    functionName,
+    args: functionArgs
+  });
+}
+function bufferCV(input) {
+  return typeof input === "string" ? Cl.bufferFromHex(input) : Cl.buffer(input);
+}
+function btcLockupCV(lockup) {
+  if ("sbtcSats" in lockup)
+    return Cl.error(Cl.uint(lockup.sbtcSats));
+  return Cl.ok(Cl.tuple({
+    outputs: Cl.list(lockup.l1Outputs.map((o) => Cl.tuple({
+      height: Cl.uint(o.height),
+      tx: bufferCV(o.tx),
+      "output-index": Cl.uint(o.outputIndex),
+      header: bufferCV(o.header),
+      "leaf-hashes": Cl.list(o.leafHashes.map(bufferCV)),
+      "tx-count": Cl.uint(o.txCount),
+      "tx-index": Cl.uint(o.txIndex),
+      amount: Cl.uint(o.amount),
+      "unlock-burn-height": Cl.uint(o.unlockBurnHeight)
+    }))),
+    "staker-unlock-bytes": bufferCV(lockup.stakerUnlockBytes)
+  }));
+}
+function optionalBuffer(input) {
+  return input === undefined ? Cl.none() : Cl.some(bufferCV(input));
+}
+function setupBond(client, params) {
+  const {
+    bondIndex,
+    targetRate,
+    stxValueRatio,
+    minUstxRatio,
+    earlyUnlockBytes,
+    allowlist,
+    ...tx
+  } = params;
+  return call(client, "setup-bond", [
+    Cl.uint(bondIndex),
+    Cl.uint(targetRate),
+    Cl.uint(stxValueRatio),
+    Cl.uint(minUstxRatio),
+    bufferCV(earlyUnlockBytes),
+    Cl.list(allowlist.map((a) => Cl.tuple({
+      staker: Cl.principal(a.staker),
+      "max-sats": Cl.uint(a.maxSats)
+    })))
+  ], tx);
+}
+function registerForBond(client, params) {
+  const {
+    bondIndex,
+    signerManager,
+    amountUstx,
+    btcLockup,
+    signerCalldata,
+    ...tx
+  } = params;
+  return call(client, "register-for-bond", [
+    Cl.uint(bondIndex),
+    Cl.principal(signerManager),
+    Cl.uint(amountUstx),
+    btcLockupCV(btcLockup),
+    optionalBuffer(signerCalldata)
+  ], tx);
+}
+function updateBondRegistration(client, params) {
+  const { signerManager, oldSignerManager, signerCalldata, ...tx } = params;
+  return call(client, "update-bond-registration", [
+    Cl.principal(signerManager),
+    Cl.principal(oldSignerManager),
+    optionalBuffer(signerCalldata)
+  ], tx);
+}
+function stake(client, params) {
+  const {
+    signerManager,
+    amountUstx,
+    numCycles,
+    startBurnHeight,
+    signerCalldata,
+    ...tx
+  } = params;
+  return call(client, "stake", [
+    Cl.principal(signerManager),
+    Cl.uint(amountUstx),
+    Cl.uint(numCycles),
+    Cl.uint(startBurnHeight),
+    optionalBuffer(signerCalldata)
+  ], tx);
+}
+function stakeUpdate(client, params) {
+  const {
+    signerManager,
+    oldSignerManager,
+    cyclesToExtend,
+    amountIncrease,
+    signerCalldata,
+    ...tx
+  } = params;
+  return call(client, "stake-update", [
+    Cl.principal(signerManager),
+    Cl.principal(oldSignerManager),
+    Cl.uint(cyclesToExtend),
+    Cl.uint(amountIncrease),
+    optionalBuffer(signerCalldata)
+  ], tx);
+}
+function unstake(client, params) {
+  const { oldSignerManager, ...tx } = params;
+  return call(client, "unstake", [Cl.principal(oldSignerManager)], tx);
+}
+function unstakeSbtc(client, params) {
+  const { signerManager, amountSats, ...tx } = params;
+  return call(client, "unstake-sbtc", [Cl.principal(signerManager), Cl.uint(amountSats)], tx);
+}
+function announceL1EarlyExit(client, params) {
+  const { staker, oldSignerManager, ...tx } = params;
+  return call(client, "announce-l1-early-exit", [Cl.principal(staker), Cl.principal(oldSignerManager)], tx);
+}
+function calculateRewards(client, params) {
+  const { bondPeriods, ...tx } = params;
+  return call(client, "calculate-rewards", [Cl.list(bondPeriods.map((p) => Cl.uint(p)))], tx);
+}
+function claimRewards(client, params) {
+  const { bondPeriods, rewardCycle, ...tx } = params;
+  return call(client, "claim-rewards", [Cl.list(bondPeriods.map((p) => Cl.uint(p))), Cl.uint(rewardCycle)], tx);
+}
+function claimStakerRewardsForSigner(client, params) {
+  const { staker, rewardCycle, bondIndex, ...tx } = params;
+  return call(client, "claim-staker-rewards-for-signer", [
+    Cl.principal(staker),
+    Cl.uint(rewardCycle),
+    bondIndex === undefined ? Cl.none() : Cl.some(Cl.uint(bondIndex))
+  ], tx);
+}
+function grantSignerKey(client, params) {
+  const { signerKey, signerManager, authId, signerSig, ...tx } = params;
+  return call(client, "grant-signer-key", [
+    bufferCV(signerKey),
+    Cl.principal(signerManager),
+    Cl.uint(authId),
+    bufferCV(signerSig)
+  ], tx);
+}
+function revokeSignerGrant(client, params) {
+  const { signerManager, signerKey, ...tx } = params;
+  return call(client, "revoke-signer-grant", [Cl.principal(signerManager), bufferCV(signerKey)], tx);
+}
+function getStakerInfo(client, staker) {
+  return read(client, "get-staker-info", [Cl.principal(staker)]);
+}
+function getBondMembership(client, staker) {
+  return read(client, "get-bond-membership", [Cl.principal(staker)]);
+}
+function getProtocolBond(client, bondIndex) {
+  return read(client, "get-protocol-bond", [Cl.uint(bondIndex)]);
+}
+function getBondAllowance(client, bondIndex, staker) {
+  return read(client, "get-bond-allowance", [
+    Cl.uint(bondIndex),
+    Cl.principal(staker)
+  ]);
+}
+function getTotalSbtcStakedForBond(client, bondIndex) {
+  return read(client, "get-total-sbtc-staked-for-bond", [Cl.uint(bondIndex)]);
+}
+function getStakerCustodiedSbtc(client, staker) {
+  return read(client, "get-staker-custodied-sbtc", [Cl.principal(staker)]);
+}
+function hasAnnouncedL1EarlyExit(client, bondIndex, staker) {
+  return read(client, "has-announced-l1-early-exit", [
+    Cl.uint(bondIndex),
+    Cl.principal(staker)
+  ]);
+}
+function getBondL1UnlockHeight(client, bondIndex) {
+  return read(client, "get-bond-l1-unlock-height", [Cl.uint(bondIndex)]);
+}
+function getSignerInfo(client, signer) {
+  return read(client, "get-signer-info", [Cl.principal(signer)]);
+}
+function verifySignerKeyGrantOnChain(client, signerManager, signerKey) {
+  return read(client, "verify-signer-key-grant", [
+    Cl.principal(signerManager),
+    bufferCV(signerKey)
+  ]);
+}
+function getCurrentRewardCycle(client) {
+  return read(client, "current-pox-reward-cycle");
+}
+function getFirstPox5RewardCycle(client) {
+  return read(client, "get-first-pox-5-reward-cycle");
+}
+// src/pox5/extension.ts
+async function getStakerState(client, staker) {
+  const contract = pox5ContractId(client);
+  const results = await multicall(client, {
+    allowFailure: false,
+    calls: [
+      {
+        contract,
+        functionName: "get-staker-info",
+        args: [Cl.principal(staker)]
+      },
+      {
+        contract,
+        functionName: "get-bond-membership",
+        args: [Cl.principal(staker)]
+      },
+      {
+        contract,
+        functionName: "get-staker-custodied-sbtc",
+        args: [Cl.principal(staker)]
+      },
+      { contract, functionName: "current-pox-reward-cycle", args: [] }
+    ]
+  });
+  const [stakerInfo, bondMembership, custodiedSbtc, currentCycle] = results;
+  return {
+    stakerInfo,
+    bondMembership,
+    custodiedSbtc,
+    currentCycle
+  };
+}
+function pox5() {
+  return (client) => ({
+    pox5: {
+      isActive: () => isPox5Active(client),
+      getActivation: () => getPox5Activation(client),
+      contractId: () => pox5ContractId(client),
+      getStakerState: (staker) => getStakerState(client, staker),
+      getStakerInfo: (staker) => getStakerInfo(client, staker),
+      getBondMembership: (staker) => getBondMembership(client, staker),
+      getProtocolBond: (bondIndex) => getProtocolBond(client, bondIndex),
+      getBondAllowance: (bondIndex, staker) => getBondAllowance(client, bondIndex, staker),
+      getTotalSbtcStakedForBond: (bondIndex) => getTotalSbtcStakedForBond(client, bondIndex),
+      getStakerCustodiedSbtc: (staker) => getStakerCustodiedSbtc(client, staker),
+      hasAnnouncedL1EarlyExit: (bondIndex, staker) => hasAnnouncedL1EarlyExit(client, bondIndex, staker),
+      getBondL1UnlockHeight: (bondIndex) => getBondL1UnlockHeight(client, bondIndex),
+      getSignerInfo: (signer) => getSignerInfo(client, signer),
+      verifySignerKeyGrant: (signerManager, signerKey) => verifySignerKeyGrantOnChain(client, signerManager, signerKey),
+      getCurrentRewardCycle: () => getCurrentRewardCycle(client),
+      getFirstRewardCycle: () => getFirstPox5RewardCycle(client),
+      setupBond: (params) => setupBond(client, params),
+      registerForBond: (params) => registerForBond(client, params),
+      updateBondRegistration: (params) => updateBondRegistration(client, params),
+      stake: (params) => stake(client, params),
+      stakeUpdate: (params) => stakeUpdate(client, params),
+      unstake: (params) => unstake(client, params),
+      unstakeSbtc: (params) => unstakeSbtc(client, params),
+      announceL1EarlyExit: (params) => announceL1EarlyExit(client, params),
+      calculateRewards: (params) => calculateRewards(client, params),
+      claimRewards: (params) => claimRewards(client, params),
+      claimStakerRewardsForSigner: (params) => claimStakerRewardsForSigner(client, params),
+      grantSignerKey: (params) => grantSignerKey(client, params),
+      revokeSignerGrant: (params) => revokeSignerGrant(client, params)
+    }
+  });
+}
+export {
+  verifySignerGrant,
+  stakerPreimage,
+  stakerConsensusBuff,
+  signSignerGrant,
+  serializeCScriptNum,
+  rewardCycleToBurnHeight,
+  pushScriptBytes,
+  pushCScriptNum,
+  pox5ContractId,
+  pox5,
+  isPox5Active,
+  isInPreparePhase,
+  getPox5Activation,
+  computeSignerGrantHash,
+  burnHeightToRewardCycle,
+  burnHeightToDistributionIndex,
+  buildLockupScript,
+  buildLockupOutputScript,
+  buildLockupAddress,
+  buildDefaultStakerUnlockBytes,
+  bondUnlockCycle,
+  bondPhaseAtHeight,
+  bondPeriodToRewardCycle,
+  bondPeriodToBurnHeight,
+  assertPox5Active,
+  POX5_SIGNER_DOMAIN,
+  POX5_CONTRACT_NAME,
+  POX5_ACTIVATION_BURN_HEIGHT_MAINNET,
+  MAX_NUM_CYCLES,
+  C_SCRIPT_NUM_MAX,
+  BOND_LENGTH_CYCLES,
+  BOND_GAP_CYCLES,
+  BITCOIN_LOCKTIME_THRESHOLD
+};
+
+//# debugId=922D98973998F42C64756E2164756E21
+//# sourceMappingURL=index.js.map