@secondlayer/stacks 2.16.0 → 2.17.0

package/dist/src/pox5/index.cjs

@@ -227,6 +227,539 @@ function verifySignerGrant(opts) {
     return false;
   }
 }
+// src/pox5/abi.ts
+var optionalSignerCalldata = {
+  optional: { buff: { length: 500 } }
+};
+var earnedRewardsTuple = {
+  tuple: [
+    { name: "earned", type: "uint128" },
+    { name: "rewards-per-token", type: "uint128" }
+  ]
+};
+var l1LockupOutputTuple = {
+  tuple: [
+    { name: "amount", type: "uint128" },
+    { name: "header", type: { buff: { length: 80 } } },
+    { name: "height", type: "uint128" },
+    {
+      name: "leaf-hashes",
+      type: { list: { type: { buff: { length: 32 } }, length: 14 } }
+    },
+    { name: "output-index", type: "uint128" },
+    { name: "tx", type: { buff: { length: 1e5 } } },
+    { name: "tx-count", type: "uint128" },
+    { name: "tx-index", type: "uint128" },
+    { name: "unlock-burn-height", type: "uint128" }
+  ]
+};
+var POX5_ABI = {
+  functions: [
+    {
+      name: "current-pox-reward-cycle",
+      access: "read-only",
+      args: [],
+      outputs: "uint128"
+    },
+    {
+      name: "get-bond-allowance",
+      access: "read-only",
+      args: [
+        { name: "bond-index", type: "uint128" },
+        { name: "staker", type: "principal" }
+      ],
+      outputs: { optional: "uint128" }
+    },
+    {
+      name: "get-bond-l1-unlock-height",
+      access: "read-only",
+      args: [{ name: "bond-index", type: "uint128" }],
+      outputs: "uint128"
+    },
+    {
+      name: "get-bond-membership",
+      access: "read-only",
+      args: [{ name: "staker", type: "principal" }],
+      outputs: {
+        optional: {
+          tuple: [
+            { name: "amount-sats", type: "uint128" },
+            { name: "amount-ustx", type: "uint128" },
+            { name: "bond-index", type: "uint128" },
+            { name: "is-l1-lock", type: "bool" },
+            { name: "signer", type: "principal" }
+          ]
+        }
+      }
+    },
+    {
+      name: "get-first-pox-5-reward-cycle",
+      access: "read-only",
+      args: [],
+      outputs: "uint128"
+    },
+    {
+      name: "get-protocol-bond",
+      access: "read-only",
+      args: [{ name: "bond-index", type: "uint128" }],
+      outputs: {
+        optional: {
+          tuple: [
+            { name: "early-unlock-bytes", type: { buff: { length: 683 } } },
+            { name: "min-ustx-ratio", type: "uint128" },
+            { name: "stx-value-ratio", type: "uint128" },
+            { name: "target-rate", type: "uint128" }
+          ]
+        }
+      }
+    },
+    {
+      name: "get-signer-info",
+      access: "read-only",
+      args: [{ name: "signer", type: "principal" }],
+      outputs: { optional: { buff: { length: 33 } } }
+    },
+    {
+      name: "get-staker-custodied-sbtc",
+      access: "read-only",
+      args: [{ name: "staker", type: "principal" }],
+      outputs: "uint128"
+    },
+    {
+      name: "get-staker-info",
+      access: "read-only",
+      args: [{ name: "staker", type: "principal" }],
+      outputs: {
+        optional: {
+          tuple: [
+            { name: "amount-ustx", type: "uint128" },
+            { name: "first-reward-cycle", type: "uint128" },
+            { name: "num-cycles", type: "uint128" },
+            { name: "signer", type: "principal" }
+          ]
+        }
+      }
+    },
+    {
+      name: "get-total-sbtc-staked-for-bond",
+      access: "read-only",
+      args: [{ name: "bond-index", type: "uint128" }],
+      outputs: "uint128"
+    },
+    {
+      name: "has-announced-l1-early-exit",
+      access: "read-only",
+      args: [
+        { name: "bond-index", type: "uint128" },
+        { name: "staker", type: "principal" }
+      ],
+      outputs: "bool"
+    },
+    {
+      name: "verify-signer-key-grant",
+      access: "read-only",
+      args: [
+        { name: "signer-manager", type: "principal" },
+        { name: "signer-key", type: { buff: { length: 33 } } }
+      ],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    },
+    {
+      name: "announce-l1-early-exit",
+      access: "public",
+      args: [
+        { name: "staker", type: "principal" },
+        { name: "old-signer-manager", type: "trait_reference" }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "amount-sats-released", type: "uint128" },
+              { name: "bond-index", type: "uint128" },
+              { name: "signer", type: "principal" },
+              { name: "staker", type: "principal" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "calculate-rewards",
+      access: "public",
+      args: [
+        {
+          name: "bond-periods",
+          type: { list: { type: "uint128", length: 6 } }
+        }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "accrued-rewards-per-ustx", type: "uint128" },
+              {
+                name: "bond-periods",
+                type: { list: { type: "uint128", length: 6 } }
+              },
+              { name: "calculation-height", type: "uint128" },
+              { name: "cumulative-rewards-per-ustx", type: "uint128" },
+              { name: "cycle-staked-ustx", type: "uint128" },
+              { name: "gross-accrued-rewards", type: "uint128" },
+              { name: "reserve-balance", type: "uint128" },
+              { name: "reserve-deposit", type: "uint128" },
+              { name: "stx-cycle", type: "uint128" },
+              { name: "total-bond-rewards", type: "uint128" },
+              { name: "total-stx-staker-rewards", type: "uint128" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "claim-rewards",
+      access: "public",
+      args: [
+        {
+          name: "bond-periods",
+          type: { list: { type: "uint128", length: 6 } }
+        },
+        { name: "reward-cycle", type: "uint128" }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              {
+                name: "bond-rewards",
+                type: {
+                  list: {
+                    type: {
+                      tuple: [
+                        { name: "bond-index", type: "uint128" },
+                        { name: "earned", type: "uint128" },
+                        { name: "rewards-per-token", type: "uint128" }
+                      ]
+                    },
+                    length: 6
+                  }
+                }
+              },
+              { name: "bond-totals", type: "uint128" },
+              { name: "stx-rewards", type: earnedRewardsTuple },
+              { name: "total-rewards", type: "uint128" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "claim-staker-rewards-for-signer",
+      access: "public",
+      args: [
+        { name: "staker", type: "principal" },
+        { name: "reward-cycle", type: "uint128" },
+        { name: "bond-index", type: { optional: "uint128" } }
+      ],
+      outputs: {
+        response: { ok: earnedRewardsTuple, error: "uint128" }
+      }
+    },
+    {
+      name: "grant-signer-key",
+      access: "public",
+      args: [
+        { name: "signer-key", type: { buff: { length: 33 } } },
+        { name: "signer-manager", type: "principal" },
+        { name: "auth-id", type: "uint128" },
+        { name: "signer-sig", type: { buff: { length: 65 } } }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "auth-id", type: "uint128" },
+              { name: "signer-key", type: { buff: { length: 33 } } },
+              { name: "signer-manager", type: "principal" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "register-for-bond",
+      access: "public",
+      args: [
+        { name: "bond-index", type: "uint128" },
+        { name: "signer-manager", type: "trait_reference" },
+        { name: "amount-ustx", type: "uint128" },
+        {
+          name: "btc-lockup",
+          type: {
+            response: {
+              ok: {
+                tuple: [
+                  {
+                    name: "outputs",
+                    type: { list: { type: l1LockupOutputTuple, length: 10 } }
+                  },
+                  {
+                    name: "staker-unlock-bytes",
+                    type: { buff: { length: 683 } }
+                  }
+                ]
+              },
+              error: "uint128"
+            }
+          }
+        },
+        { name: "signer-calldata", type: optionalSignerCalldata }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "amount-ustx", type: "uint128" },
+              { name: "bond-index", type: "uint128" },
+              {
+                name: "btc-lockup",
+                type: {
+                  tuple: [
+                    {
+                      name: "txs",
+                      type: {
+                        optional: {
+                          list: {
+                            type: {
+                              tuple: [
+                                { name: "output-index", type: "uint128" },
+                                {
+                                  name: "txid",
+                                  type: { buff: { length: 32 } }
+                                }
+                              ]
+                            },
+                            length: 10
+                          }
+                        }
+                      }
+                    },
+                    {
+                      name: "type",
+                      type: { "string-ascii": { length: 2 } }
+                    }
+                  ]
+                }
+              },
+              { name: "first-reward-cycle", type: "uint128" },
+              { name: "is-l1-lock", type: "bool" },
+              { name: "sats-total", type: "uint128" },
+              { name: "signer", type: "principal" },
+              { name: "staker", type: "principal" },
+              { name: "unlock-burn-height", type: "uint128" },
+              { name: "unlock-cycle", type: "uint128" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "revoke-signer-grant",
+      access: "public",
+      args: [
+        { name: "signer-manager", type: "principal" },
+        { name: "signer-key", type: { buff: { length: 33 } } }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "existed", type: "bool" },
+              { name: "signer-key", type: { buff: { length: 33 } } },
+              { name: "signer-manager", type: "principal" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "setup-bond",
+      access: "public",
+      args: [
+        { name: "bond-index", type: "uint128" },
+        { name: "target-rate", type: "uint128" },
+        { name: "stx-value-ratio", type: "uint128" },
+        { name: "min-ustx-ratio", type: "uint128" },
+        { name: "early-unlock-bytes", type: { buff: { length: 683 } } },
+        {
+          name: "allowlist",
+          type: {
+            list: {
+              type: {
+                tuple: [
+                  { name: "max-sats", type: "uint128" },
+                  { name: "staker", type: "principal" }
+                ]
+              },
+              length: 1000
+            }
+          }
+        }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "bond-index", type: "uint128" },
+              {
+                name: "early-unlock-bytes",
+                type: { buff: { length: 683 } }
+              },
+              { name: "max-allocation-sats", type: "uint128" },
+              { name: "min-ustx-ratio", type: "uint128" },
+              { name: "stx-value-ratio", type: "uint128" },
+              { name: "target-rate", type: "uint128" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "stake",
+      access: "public",
+      args: [
+        { name: "signer-manager", type: "trait_reference" },
+        { name: "amount-ustx", type: "uint128" },
+        { name: "num-cycles", type: "uint128" },
+        { name: "start-burn-ht", type: "uint128" },
+        { name: "signer-calldata", type: optionalSignerCalldata }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "amount-ustx", type: "uint128" },
+              { name: "first-reward-cycle", type: "uint128" },
+              { name: "num-cycles", type: "uint128" },
+              { name: "signer", type: "principal" },
+              { name: "staker", type: "principal" },
+              { name: "unlock-burn-height", type: "uint128" },
+              { name: "unlock-cycle", type: "uint128" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "stake-update",
+      access: "public",
+      args: [
+        { name: "signer-manager", type: "trait_reference" },
+        { name: "old-signer-manager", type: "trait_reference" },
+        { name: "cycles-to-extend", type: "uint128" },
+        { name: "amount-increase", type: "uint128" },
+        { name: "signer-calldata", type: optionalSignerCalldata }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "amount-increase", type: "uint128" },
+              { name: "amount-ustx", type: "uint128" },
+              { name: "cycles-to-extend", type: "uint128" },
+              { name: "num-cycles", type: "uint128" },
+              { name: "old-signer", type: "principal" },
+              { name: "prev-unlock-height", type: "uint128" },
+              { name: "signer", type: "principal" },
+              { name: "staker", type: "principal" },
+              { name: "unlock-burn-height", type: "uint128" },
+              { name: "unlock-cycle", type: "uint128" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "unstake",
+      access: "public",
+      args: [{ name: "old-signer-manager", type: "trait_reference" }],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "amount-ustx", type: "uint128" },
+              { name: "first-reward-cycle", type: "uint128" },
+              { name: "signer", type: "principal" },
+              { name: "staker", type: "principal" },
+              { name: "unlock-burn-height", type: "uint128" },
+              { name: "unlock-cycle", type: "uint128" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "unstake-sbtc",
+      access: "public",
+      args: [
+        { name: "signer-manager", type: "trait_reference" },
+        { name: "amount-to-withdrawal-sats", type: "uint128" }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "amount-withdrawn-sats", type: "uint128" },
+              { name: "bond-index", type: "uint128" },
+              { name: "new-amount-sats", type: "uint128" },
+              { name: "signer", type: "principal" },
+              { name: "staker", type: "principal" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "update-bond-registration",
+      access: "public",
+      args: [
+        { name: "signer-manager", type: "trait_reference" },
+        { name: "old-signer-manager", type: "trait_reference" },
+        { name: "signer-calldata", type: optionalSignerCalldata }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "amount-sats", type: "uint128" },
+              { name: "amount-ustx", type: "uint128" },
+              { name: "bond-index", type: "uint128" },
+              { name: "first-reward-cycle", type: "uint128" },
+              { name: "is-l1-lock", type: "bool" },
+              { name: "num-cycles", type: "uint128" },
+              { name: "old-signer", type: "principal" },
+              { name: "signer", type: "principal" },
+              { name: "staker", type: "principal" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    }
+  ]
+};
+
 // src/pox5/actions.ts
 function pox5ContractId(client) {
   const boot = client.chain?.bootAddress;
@@ -234,45 +767,35 @@ function pox5ContractId(client) {
     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 = []) {
+function getPox5Contract(client) {
   const [address, name] = pox5ContractId(client).split(".");
-  return readContract(client, {
-    contract: `${address}.${name}`,
-    functionName,
-    args: functionArgs
-  });
+  return getContract({ client, address, name, abi: POX5_ABI });
 }
-function bufferCV(input) {
-  return typeof input === "string" ? Cl.bufferFromHex(input) : Cl.buffer(input);
+function toBytes2(input) {
+  return typeof input === "string" ? hexToBytes(input) : 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 optionalBytes(input) {
+  return input === undefined ? null : toBytes2(input);
 }
-function optionalBuffer(input) {
-  return input === undefined ? Cl.none() : Cl.some(bufferCV(input));
+function btcLockupArg(lockup) {
+  if ("sbtcSats" in lockup)
+    return { err: intToBigInt(lockup.sbtcSats) };
+  return {
+    ok: {
+      outputs: lockup.l1Outputs.map((o) => ({
+        height: intToBigInt(o.height),
+        tx: toBytes2(o.tx),
+        outputIndex: intToBigInt(o.outputIndex),
+        header: toBytes2(o.header),
+        leafHashes: o.leafHashes.map(toBytes2),
+        txCount: intToBigInt(o.txCount),
+        txIndex: intToBigInt(o.txIndex),
+        amount: intToBigInt(o.amount),
+        unlockBurnHeight: intToBigInt(o.unlockBurnHeight)
+      })),
+      stakerUnlockBytes: toBytes2(lockup.stakerUnlockBytes)
+    }
+  };
 }
 function setupBond(client, params) {
   const {
@@ -284,17 +807,17 @@ function setupBond(client, params) {
     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);
+  return getPox5Contract(client).call.setupBond({
+    bondIndex: intToBigInt(bondIndex),
+    targetRate: intToBigInt(targetRate),
+    stxValueRatio: intToBigInt(stxValueRatio),
+    minUstxRatio: intToBigInt(minUstxRatio),
+    earlyUnlockBytes: toBytes2(earlyUnlockBytes),
+    allowlist: allowlist.map((a) => ({
+      staker: a.staker,
+      maxSats: intToBigInt(a.maxSats)
+    }))
+  }, tx);
 }
 function registerForBond(client, params) {
   const {
@@ -305,21 +828,21 @@ function registerForBond(client, params) {
     signerCalldata,
     ...tx
   } = params;
-  return call(client, "register-for-bond", [
-    Cl.uint(bondIndex),
-    Cl.principal(signerManager),
-    Cl.uint(amountUstx),
-    btcLockupCV(btcLockup),
-    optionalBuffer(signerCalldata)
-  ], tx);
+  return getPox5Contract(client).call.registerForBond({
+    bondIndex: intToBigInt(bondIndex),
+    signerManager,
+    amountUstx: intToBigInt(amountUstx),
+    btcLockup: btcLockupArg(btcLockup),
+    signerCalldata: optionalBytes(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);
+  return getPox5Contract(client).call.updateBondRegistration({
+    signerManager,
+    oldSignerManager,
+    signerCalldata: optionalBytes(signerCalldata)
+  }, tx);
 }
 function stake(client, params) {
   const {
@@ -330,13 +853,13 @@ function stake(client, params) {
     signerCalldata,
     ...tx
   } = params;
-  return call(client, "stake", [
-    Cl.principal(signerManager),
-    Cl.uint(amountUstx),
-    Cl.uint(numCycles),
-    Cl.uint(startBurnHeight),
-    optionalBuffer(signerCalldata)
-  ], tx);
+  return getPox5Contract(client).call.stake({
+    signerManager,
+    amountUstx: intToBigInt(amountUstx),
+    numCycles: intToBigInt(numCycles),
+    startBurnHt: intToBigInt(startBurnHeight),
+    signerCalldata: optionalBytes(signerCalldata)
+  }, tx);
 }
 function stakeUpdate(client, params) {
   const {
@@ -347,99 +870,114 @@ function stakeUpdate(client, params) {
     signerCalldata,
     ...tx
   } = params;
-  return call(client, "stake-update", [
-    Cl.principal(signerManager),
-    Cl.principal(oldSignerManager),
-    Cl.uint(cyclesToExtend),
-    Cl.uint(amountIncrease),
-    optionalBuffer(signerCalldata)
-  ], tx);
+  return getPox5Contract(client).call.stakeUpdate({
+    signerManager,
+    oldSignerManager,
+    cyclesToExtend: intToBigInt(cyclesToExtend),
+    amountIncrease: intToBigInt(amountIncrease),
+    signerCalldata: optionalBytes(signerCalldata)
+  }, tx);
 }
 function unstake(client, params) {
   const { oldSignerManager, ...tx } = params;
-  return call(client, "unstake", [Cl.principal(oldSignerManager)], tx);
+  return getPox5Contract(client).call.unstake({ oldSignerManager }, tx);
 }
 function unstakeSbtc(client, params) {
   const { signerManager, amountSats, ...tx } = params;
-  return call(client, "unstake-sbtc", [Cl.principal(signerManager), Cl.uint(amountSats)], tx);
+  return getPox5Contract(client).call.unstakeSbtc({ signerManager, amountToWithdrawalSats: intToBigInt(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);
+  return getPox5Contract(client).call.announceL1EarlyExit({ staker, oldSignerManager }, tx);
 }
 function calculateRewards(client, params) {
   const { bondPeriods, ...tx } = params;
-  return call(client, "calculate-rewards", [Cl.list(bondPeriods.map((p) => Cl.uint(p)))], tx);
+  return getPox5Contract(client).call.calculateRewards({ bondPeriods: bondPeriods.map(intToBigInt) }, 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);
+  return getPox5Contract(client).call.claimRewards({
+    bondPeriods: bondPeriods.map(intToBigInt),
+    rewardCycle: intToBigInt(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);
+  return getPox5Contract(client).call.claimStakerRewardsForSigner({
+    staker,
+    rewardCycle: intToBigInt(rewardCycle),
+    bondIndex: bondIndex === undefined ? null : intToBigInt(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);
+  return getPox5Contract(client).call.grantSignerKey({
+    signerKey: toBytes2(signerKey),
+    signerManager,
+    authId: intToBigInt(authId),
+    signerSig: toBytes2(signerSig)
+  }, tx);
 }
 function revokeSignerGrant(client, params) {
   const { signerManager, signerKey, ...tx } = params;
-  return call(client, "revoke-signer-grant", [Cl.principal(signerManager), bufferCV(signerKey)], tx);
+  return getPox5Contract(client).call.revokeSignerGrant({ signerManager, signerKey: toBytes2(signerKey) }, tx);
 }
-function getStakerInfo(client, staker) {
-  return read(client, "get-staker-info", [Cl.principal(staker)]);
+async function getStakerInfo(client, staker) {
+  return await getPox5Contract(client).read.getStakerInfo({
+    staker
+  });
 }
-function getBondMembership(client, staker) {
-  return read(client, "get-bond-membership", [Cl.principal(staker)]);
+async function getBondMembership(client, staker) {
+  return await getPox5Contract(client).read.getBondMembership({
+    staker
+  });
 }
-function getProtocolBond(client, bondIndex) {
-  return read(client, "get-protocol-bond", [Cl.uint(bondIndex)]);
+async function getProtocolBond(client, bondIndex) {
+  return await getPox5Contract(client).read.getProtocolBond({
+    bondIndex: intToBigInt(bondIndex)
+  });
 }
-function getBondAllowance(client, bondIndex, staker) {
-  return read(client, "get-bond-allowance", [
-    Cl.uint(bondIndex),
-    Cl.principal(staker)
-  ]);
+async function getBondAllowance(client, bondIndex, staker) {
+  return await getPox5Contract(client).read.getBondAllowance({
+    bondIndex: intToBigInt(bondIndex),
+    staker
+  });
 }
 function getTotalSbtcStakedForBond(client, bondIndex) {
-  return read(client, "get-total-sbtc-staked-for-bond", [Cl.uint(bondIndex)]);
+  return getPox5Contract(client).read.getTotalSbtcStakedForBond({
+    bondIndex: intToBigInt(bondIndex)
+  });
 }
 function getStakerCustodiedSbtc(client, staker) {
-  return read(client, "get-staker-custodied-sbtc", [Cl.principal(staker)]);
+  return getPox5Contract(client).read.getStakerCustodiedSbtc({ staker });
 }
 function hasAnnouncedL1EarlyExit(client, bondIndex, staker) {
-  return read(client, "has-announced-l1-early-exit", [
-    Cl.uint(bondIndex),
-    Cl.principal(staker)
-  ]);
+  return getPox5Contract(client).read.hasAnnouncedL1EarlyExit({
+    bondIndex: intToBigInt(bondIndex),
+    staker
+  });
 }
 function getBondL1UnlockHeight(client, bondIndex) {
-  return read(client, "get-bond-l1-unlock-height", [Cl.uint(bondIndex)]);
+  return getPox5Contract(client).read.getBondL1UnlockHeight({
+    bondIndex: intToBigInt(bondIndex)
+  });
 }
-function getSignerInfo(client, signer) {
-  return read(client, "get-signer-info", [Cl.principal(signer)]);
+async function getSignerInfo(client, signer) {
+  return await getPox5Contract(client).read.getSignerInfo({
+    signer
+  });
 }
 function verifySignerKeyGrantOnChain(client, signerManager, signerKey) {
-  return read(client, "verify-signer-key-grant", [
-    Cl.principal(signerManager),
-    bufferCV(signerKey)
-  ]);
+  return getPox5Contract(client).read.verifySignerKeyGrant({
+    signerManager,
+    signerKey: toBytes2(signerKey)
+  });
 }
 function getCurrentRewardCycle(client) {
-  return read(client, "current-pox-reward-cycle");
+  return getPox5Contract(client).read.currentPoxRewardCycle({});
 }
 function getFirstPox5RewardCycle(client) {
-  return read(client, "get-first-pox-5-reward-cycle");
+  return getPox5Contract(client).read.getFirstPox5RewardCycle({});
 }
 // src/pox5/extension.ts
 async function getStakerState(client, staker) {
@@ -509,5 +1047,5 @@ function pox5() {
   });
 }
 
-//# debugId=9EC46D11CA68C21664756E2164756E21
+//# debugId=83632C2153CE9C7864756E2164756E21
 //# sourceMappingURL=index.cjs.map