@opendatalabs/vana-sdk 2.2.2 → 2.2.3-canary.07f70f7

package/dist/controllers/staking.cjs

@@ -0,0 +1,666 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var staking_exports = {};
+__export(staking_exports, {
+  StakingController: () => StakingController
+});
+module.exports = __toCommonJS(staking_exports);
+var import_base = require("./base");
+var import_viem = require("viem");
+var import_addresses = require("../generated/addresses");
+var import_abi = require("../generated/abi");
+var import_errors = require("../errors");
+class StakingController extends import_base.BaseController {
+  constructor(context) {
+    super(context);
+  }
+  /**
+   * Gets the chain ID from context.
+   */
+  getChainId() {
+    const chainId = this.context.walletClient?.chain?.id ?? this.context.publicClient.chain?.id;
+    if (!chainId) {
+      throw new Error("Chain ID not available");
+    }
+    return chainId;
+  }
+  /**
+   * Gets the VanaPoolEntity contract instance.
+   */
+  getEntityContract() {
+    const chainId = this.getChainId();
+    return (0, import_viem.getContract)({
+      address: (0, import_addresses.getContractAddress)(chainId, "VanaPoolEntity"),
+      abi: (0, import_abi.getAbi)("VanaPoolEntity"),
+      client: this.context.publicClient
+    });
+  }
+  /**
+   * Gets the VanaPoolStaking contract instance.
+   */
+  getStakingContract() {
+    const chainId = this.getChainId();
+    return (0, import_viem.getContract)({
+      address: (0, import_addresses.getContractAddress)(chainId, "VanaPoolStaking"),
+      abi: (0, import_abi.getAbi)("VanaPoolStaking"),
+      client: this.context.publicClient
+    });
+  }
+  /**
+   * Gets the total amount of VANA staked in the VanaPool protocol or a specific entity.
+   *
+   * @remarks
+   * When called without an entityId, this retrieves the sum of activeRewardPool
+   * across all active entities in the VanaPool protocol.
+   * When called with an entityId, this returns the activeRewardPool for that specific entity.
+   * The value is returned in wei (10^18 = 1 VANA).
+   *
+   * @param entityId - Optional entity ID to get staked amount for a specific entity
+   * @returns The total amount of VANA staked in wei
+   *
+   * @example
+   * ```typescript
+   * // Get total staked across all entities
+   * const totalStaked = await vana.staking.getTotalVanaStaked();
+   * console.log(`Total staked: ${Number(totalStaked) / 1e18} VANA`);
+   *
+   * // Get staked amount for a specific entity
+   * const entityStaked = await vana.staking.getTotalVanaStaked(1n);
+   * console.log(`Entity 1 staked: ${Number(entityStaked) / 1e18} VANA`);
+   * ```
+   */
+  async getTotalVanaStaked(entityId) {
+    const entityContract = this.getEntityContract();
+    if (entityId !== void 0) {
+      const entity = await entityContract.read.entities([entityId]);
+      return entity.activeRewardPool;
+    }
+    const activeEntityIds = await entityContract.read.activeEntitiesValues();
+    let totalStaked = 0n;
+    for (const id of activeEntityIds) {
+      const entity = await entityContract.read.entities([id]);
+      totalStaked += entity.activeRewardPool;
+    }
+    return totalStaked;
+  }
+  /**
+   * Gets information about a specific staking entity.
+   *
+   * @param entityId - The ID of the entity to query
+   * @returns The entity information including name, APY, shares, and reward pools
+   *
+   * @example
+   * ```typescript
+   * const entity = await vana.staking.getEntity(1n);
+   * console.log(`Entity: ${entity.name}`);
+   * console.log(`Total shares: ${entity.totalShares}`);
+   * console.log(`Max APY: ${Number(entity.maxAPY) / 100}%`);
+   * ```
+   */
+  async getEntity(entityId) {
+    const entityContract = this.getEntityContract();
+    const result = await entityContract.read.entities([entityId]);
+    return {
+      entityId: result.entityId,
+      ownerAddress: result.ownerAddress,
+      status: result.status,
+      name: result.name,
+      maxAPY: result.maxAPY,
+      lockedRewardPool: result.lockedRewardPool,
+      activeRewardPool: result.activeRewardPool,
+      totalShares: result.totalShares,
+      lastUpdateTimestamp: result.lastUpdateTimestamp
+    };
+  }
+  /**
+   * Gets the total number of staking entities in the protocol.
+   *
+   * @returns The count of entities
+   *
+   * @example
+   * ```typescript
+   * const count = await vana.staking.getEntitiesCount();
+   * console.log(`Total entities: ${count}`);
+   * ```
+   */
+  async getEntitiesCount() {
+    const entityContract = this.getEntityContract();
+    return entityContract.read.entitiesCount();
+  }
+  /**
+   * Gets the IDs of all active staking entities.
+   *
+   * @returns Array of active entity IDs
+   *
+   * @example
+   * ```typescript
+   * const activeIds = await vana.staking.getActiveEntities();
+   * console.log(`Active entities: ${activeIds.join(', ')}`);
+   * ```
+   */
+  async getActiveEntities() {
+    const entityContract = this.getEntityContract();
+    return entityContract.read.activeEntitiesValues();
+  }
+  /**
+   * Gets a staker's position in a specific entity.
+   *
+   * @param staker - The address of the staker
+   * @param entityId - The ID of the entity
+   * @returns The staker's position information
+   *
+   * @example
+   * ```typescript
+   * const position = await vana.staking.getStakerPosition(
+   *   '0x742d35...',
+   *   1n
+   * );
+   * console.log(`Shares: ${position.shares}`);
+   * console.log(`Rewards: ${position.realizedRewards}`);
+   * ```
+   */
+  async getStakerPosition(staker, entityId) {
+    const stakingContract = this.getStakingContract();
+    const result = await stakingContract.read.stakerEntities([
+      staker,
+      entityId
+    ]);
+    return {
+      shares: result.shares,
+      costBasis: result.costBasis,
+      rewardEligibilityTimestamp: result.rewardEligibilityTimestamp,
+      realizedRewards: result.realizedRewards,
+      vestedRewards: result.vestedRewards
+    };
+  }
+  /**
+   * Gets the earned rewards for a staker in an entity.
+   *
+   * @param staker - The address of the staker
+   * @param entityId - The ID of the entity
+   * @returns The earned rewards amount in wei
+   *
+   * @example
+   * ```typescript
+   * const rewards = await vana.staking.getEarnedRewards(
+   *   '0x742d35...',
+   *   1n
+   * );
+   * console.log(`Earned: ${Number(rewards) / 1e18} VANA`);
+   * ```
+   */
+  async getEarnedRewards(staker, entityId) {
+    const stakingContract = this.getStakingContract();
+    return stakingContract.read.getEarnedRewards([staker, entityId]);
+  }
+  /**
+   * Gets the minimum stake amount required to stake.
+   *
+   * @returns The minimum stake amount in wei
+   *
+   * @example
+   * ```typescript
+   * const minStake = await vana.staking.getMinStakeAmount();
+   * console.log(`Minimum stake: ${Number(minStake) / 1e18} VANA`);
+   * ```
+   */
+  async getMinStakeAmount() {
+    const stakingContract = this.getStakingContract();
+    return stakingContract.read.minStakeAmount();
+  }
+  /**
+   * Gets the count of active stakers in the protocol.
+   *
+   * @returns The number of active stakers
+   *
+   * @example
+   * ```typescript
+   * const count = await vana.staking.getActiveStakersCount();
+   * console.log(`Active stakers: ${count}`);
+   * ```
+   */
+  async getActiveStakersCount() {
+    const stakingContract = this.getStakingContract();
+    return stakingContract.read.activeStakersListCount();
+  }
+  /**
+   * Gets the bonding period for staking.
+   *
+   * @returns The bonding period in seconds
+   *
+   * @example
+   * ```typescript
+   * const bondingPeriod = await vana.staking.getBondingPeriod();
+   * console.log(`Bonding period: ${bondingPeriod / 86400n} days`);
+   * ```
+   */
+  async getBondingPeriod() {
+    const stakingContract = this.getStakingContract();
+    return stakingContract.read.bondingPeriod();
+  }
+  /**
+   * Gets the total distributed rewards for a specific entity from the subgraph.
+   *
+   * @remarks
+   * This queries the VanaPool subgraph to retrieve the cumulative `totalDistributedRewards`
+   * for a staking entity. This value represents the sum of all rewards that have been
+   * processed (moved from lockedRewardPool to activeRewardPool) minus any forfeited
+   * rewards that were returned.
+   *
+   * Requires a configured `subgraphUrl` in the Vana constructor options.
+   *
+   * @param entityId - The ID of the entity to query
+   * @param options - Optional configuration including custom subgraph URL
+   * @returns The total distributed rewards in wei
+   * @throws {BlockchainError} When subgraph URL is not configured or query fails
+   *
+   * @example
+   * ```typescript
+   * const totalRewards = await vana.staking.getTotalDistributedRewards(1n);
+   * const totalRewardsVana = Number(totalRewards) / 1e18;
+   * console.log(`Total distributed rewards: ${totalRewardsVana.toLocaleString()} VANA`);
+   * ```
+   */
+  async getTotalDistributedRewards(entityId, options = {}) {
+    const graphqlEndpoint = options.subgraphUrl ?? this.context.subgraphUrl;
+    if (!graphqlEndpoint) {
+      throw new import_errors.BlockchainError(
+        "subgraphUrl is required. Please provide a valid subgraph endpoint or configure it in Vana constructor."
+      );
+    }
+    const query = `
+      query GetStakingEntityRewards($entityId: ID!) {
+        stakingEntity(id: $entityId) {
+          totalDistributedRewards
+        }
+      }
+    `;
+    const response = await fetch(graphqlEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        query,
+        variables: {
+          entityId: entityId.toString()
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new import_errors.BlockchainError(
+        `Subgraph query failed with status ${response.status}`
+      );
+    }
+    const result = await response.json();
+    if (result.errors && result.errors.length > 0) {
+      throw new import_errors.BlockchainError(
+        `Subgraph query error: ${result.errors[0].message}`
+      );
+    }
+    if (!result.data?.stakingEntity) {
+      throw new import_errors.BlockchainError(`Staking entity ${entityId} not found`);
+    }
+    return BigInt(result.data.stakingEntity.totalDistributedRewards);
+  }
+  /**
+   * Gets a comprehensive staking summary for a staker in an entity.
+   *
+   * @remarks
+   * This method aggregates all relevant staking information for a staker in a single call,
+   * including staked amount, current value, bonding status, and all reward types.
+   *
+   * Reward breakdown:
+   * - `earnedRewards` = pendingInterest + vestedRewards + realizedRewards
+   * - `pendingInterest` = currentValue - costBasis (unvested appreciation)
+   * - `vestedRewards` = rewards that have vested but not yet withdrawn
+   * - `realizedRewards` = rewards already withdrawn during unstakes
+   *
+   * @param staker - The address of the staker
+   * @param entityId - The ID of the entity
+   * @returns A comprehensive summary of the staker's position
+   *
+   * @example
+   * ```typescript
+   * const summary = await vana.staking.getStakerSummary('0x742d35...', 1n);
+   * console.log(`Total staked: ${Number(summary.totalStaked) / 1e18} VANA`);
+   * console.log(`Current value: ${Number(summary.currentValue) / 1e18} VANA`);
+   * console.log(`In bonding period: ${summary.isInBondingPeriod}`);
+   * console.log(`Remaining bonding time: ${Number(summary.remainingBondingTime) / 86400} days`);
+   * console.log(`Vested rewards: ${Number(summary.vestedRewards) / 1e18} VANA`);
+   * console.log(`Unvested rewards: ${Number(summary.unvestedRewards) / 1e18} VANA`);
+   * console.log(`Realized rewards: ${Number(summary.realizedRewards) / 1e18} VANA`);
+   * console.log(`Total earned: ${Number(summary.earnedRewards) / 1e18} VANA`);
+   * ```
+   */
+  async getStakerSummary(staker, entityId) {
+    const chainId = this.getChainId();
+    const stakingAddress = (0, import_addresses.getContractAddress)(chainId, "VanaPoolStaking");
+    const entityAddress = (0, import_addresses.getContractAddress)(chainId, "VanaPoolEntity");
+    const stakingAbi = (0, import_abi.getAbi)("VanaPoolStaking");
+    const entityAbi = (0, import_abi.getAbi)("VanaPoolEntity");
+    const block = await this.context.publicClient.getBlock();
+    const blockNumber = block.number;
+    const multicallResults = await this.context.publicClient.multicall({
+      contracts: [
+        {
+          address: stakingAddress,
+          abi: stakingAbi,
+          functionName: "stakerEntities",
+          args: [staker, entityId]
+        },
+        {
+          address: stakingAddress,
+          abi: stakingAbi,
+          functionName: "getEarnedRewards",
+          args: [staker, entityId]
+        },
+        {
+          address: entityAddress,
+          abi: entityAbi,
+          functionName: "entityShareToVana",
+          args: [entityId]
+        }
+      ],
+      blockNumber
+    });
+    const [positionResult, earnedRewardsResult, shareToVanaResult] = multicallResults;
+    if (positionResult.status === "failure" || earnedRewardsResult.status === "failure" || shareToVanaResult.status === "failure") {
+      throw new import_errors.BlockchainError(
+        "Failed to fetch staker summary: one or more contract calls failed"
+      );
+    }
+    const position = positionResult.result;
+    const earnedRewards = earnedRewardsResult.result;
+    const shareToVana = shareToVanaResult.result;
+    const currentTimestamp = block.timestamp;
+    const eligibilityTimestamp = position.rewardEligibilityTimestamp;
+    const remainingBondingTime = eligibilityTimestamp > currentTimestamp ? eligibilityTimestamp - currentTimestamp : 0n;
+    const isInBondingPeriod = remainingBondingTime > 0n;
+    const currentValue = position.shares * shareToVana / 10n ** 18n;
+    const unvestedRewards = currentValue > position.costBasis ? currentValue - position.costBasis : 0n;
+    return {
+      shares: position.shares,
+      costBasis: position.costBasis,
+      currentValue,
+      rewardEligibilityTimestamp: eligibilityTimestamp,
+      remainingBondingTime,
+      isInBondingPeriod,
+      vestedRewards: position.vestedRewards,
+      unvestedRewards,
+      realizedRewards: position.realizedRewards,
+      earnedRewards
+    };
+  }
+  /**
+   * Stakes VANA to an entity in the VanaPool protocol.
+   *
+   * @remarks
+   * This method stakes native VANA tokens to a specified entity. The staker will receive
+   * shares in proportion to their stake amount. A bonding period applies during which
+   * rewards cannot be fully claimed without penalty.
+   *
+   * Requires a wallet client to be configured in the Vana constructor.
+   *
+   * @param params - The staking parameters
+   * @param params.entityId - The ID of the entity to stake to
+   * @param params.amount - The amount of VANA to stake (in wei, or as a string like "1.5" for 1.5 VANA)
+   * @param params.recipient - Optional recipient address for the shares (defaults to the sender)
+   * @param params.minShares - Optional minimum shares to receive (slippage protection, defaults to 0)
+   * @returns The transaction hash
+   * @throws {BlockchainError} When wallet client is not configured
+   *
+   * @example
+   * ```typescript
+   * // Stake 100 VANA to entity 1
+   * const txHash = await vana.staking.stake({
+   *   entityId: 1n,
+   *   amount: "100", // 100 VANA
+   * });
+   * console.log(`Staked! Transaction: ${txHash}`);
+   *
+   * // Stake with slippage protection
+   * const txHash2 = await vana.staking.stake({
+   *   entityId: 1n,
+   *   amount: parseEther("50"), // 50 VANA in wei
+   *   minShares: parseEther("49"), // Expect at least 49 shares
+   * });
+   * ```
+   */
+  async stake(params, options) {
+    this.assertWallet();
+    const chainId = this.getChainId();
+    const stakingAddress = (0, import_addresses.getContractAddress)(chainId, "VanaPoolStaking");
+    const stakingAbi = (0, import_abi.getAbi)("VanaPoolStaking");
+    const amountWei = typeof params.amount === "string" ? (0, import_viem.parseEther)(params.amount) : params.amount;
+    const account = this.context.walletClient.account ?? this.context.userAddress;
+    const accountAddress = typeof account === "string" ? account : account.address;
+    const recipient = params.recipient ?? accountAddress;
+    const minShares = params.minShares ?? 0n;
+    const txHash = await this.context.walletClient.writeContract({
+      address: stakingAddress,
+      abi: stakingAbi,
+      functionName: "stake",
+      args: [params.entityId, recipient, minShares],
+      value: amountWei,
+      account,
+      chain: this.context.walletClient.chain,
+      ...this.spreadTransactionOptions(options)
+    });
+    return txHash;
+  }
+  /**
+   * Gets the maximum amount of VANA that can be unstaked in a single transaction.
+   *
+   * @remarks
+   * This calls the contract's getMaxUnstakeAmount which returns the minimum of:
+   * 1. The withdrawable VANA (costBasis if in bonding period, shareValue if eligible)
+   * 2. The entity's activeRewardPool (what the entity has available)
+   * 3. The treasury balance (what can be paid out)
+   *
+   * The limiting factor indicates what's constraining the unstake:
+   * - 0 = user shares/costBasis
+   * - 1 = activeRewardPool
+   * - 2 = treasury
+   *
+   * @param staker - The address of the staker
+   * @param entityId - The ID of the entity
+   * @returns Object containing maxVana, maxShares, limitingFactor, and isInBondingPeriod
+   *
+   * @example
+   * ```typescript
+   * const result = await vana.staking.getMaxUnstakeAmount('0x742d35...', 1n);
+   * console.log(`Max unstake: ${Number(result.maxVana) / 1e18} VANA`);
+   * console.log(`Max shares: ${result.maxShares}`);
+   * console.log(`In bonding period: ${result.isInBondingPeriod}`);
+   * ```
+   */
+  async getMaxUnstakeAmount(staker, entityId) {
+    const stakingContract = this.getStakingContract();
+    const result = await stakingContract.read.getMaxUnstakeAmount([
+      staker,
+      entityId
+    ]);
+    return {
+      maxVana: result[0],
+      maxShares: result[1],
+      limitingFactor: Number(result[2]),
+      isInBondingPeriod: result[3]
+    };
+  }
+  /**
+   * Computes the new bonding period end timestamp after adding stake.
+   *
+   * @remarks
+   * When a staker adds more stake to an existing position, the reward eligibility timestamp
+   * is recalculated as a weighted average of the existing and new positions. This function
+   * allows you to preview what the new eligibility timestamp would be without executing
+   * the stake transaction.
+   *
+   * The formula used (matching the contract):
+   * ```
+   * newEligibility = (existingShares * existingEligibility + newShares * newEligibility) / totalShares
+   * ```
+   *
+   * Where `newEligibility` for the incoming stake is `currentTimestamp + bondingPeriod`.
+   *
+   * @param params - The parameters for computing the new bonding period
+   * @param params.staker - The address of the staker
+   * @param params.entityId - The ID of the entity
+   * @param params.stakeAmount - The amount of VANA to stake (in wei)
+   * @returns Object containing the new eligibility timestamp and related info
+   *
+   * @example
+   * ```typescript
+   * // Preview bonding period after staking 100 VANA
+   * const preview = await vana.staking.computeNewBondingPeriod({
+   *   staker: '0x742d35...',
+   *   entityId: 1n,
+   *   stakeAmount: parseEther("100"),
+   * });
+   * console.log(`New eligibility: ${new Date(Number(preview.newEligibilityTimestamp) * 1000)}`);
+   * console.log(`Remaining bonding time: ${Number(preview.newRemainingBondingTime) / 86400} days`);
+   * ```
+   */
+  async computeNewBondingPeriod(params) {
+    const chainId = this.getChainId();
+    const stakingAddress = (0, import_addresses.getContractAddress)(chainId, "VanaPoolStaking");
+    const entityAddress = (0, import_addresses.getContractAddress)(chainId, "VanaPoolEntity");
+    const stakingAbi = (0, import_abi.getAbi)("VanaPoolStaking");
+    const entityAbi = (0, import_abi.getAbi)("VanaPoolEntity");
+    const block = await this.context.publicClient.getBlock();
+    const blockNumber = block.number;
+    const currentTimestamp = block.timestamp;
+    const multicallResults = await this.context.publicClient.multicall({
+      contracts: [
+        {
+          address: stakingAddress,
+          abi: stakingAbi,
+          functionName: "stakerEntities",
+          args: [params.staker, params.entityId]
+        },
+        {
+          address: stakingAddress,
+          abi: stakingAbi,
+          functionName: "bondingPeriod",
+          args: []
+        },
+        {
+          address: entityAddress,
+          abi: entityAbi,
+          functionName: "vanaToEntityShare",
+          args: [params.entityId]
+        }
+      ],
+      blockNumber
+    });
+    const [positionResult, bondingPeriodResult, vanaToShareResult] = multicallResults;
+    if (positionResult.status === "failure" || bondingPeriodResult.status === "failure" || vanaToShareResult.status === "failure") {
+      throw new import_errors.BlockchainError(
+        "Failed to compute new bonding period: one or more contract calls failed"
+      );
+    }
+    const position = positionResult.result;
+    const bondingPeriodDuration = bondingPeriodResult.result;
+    const vanaToShare = vanaToShareResult.result;
+    const currentShares = position.shares;
+    const currentEligibilityTimestamp = position.rewardEligibilityTimestamp;
+    const currentRemainingBondingTime = currentEligibilityTimestamp > currentTimestamp ? currentEligibilityTimestamp - currentTimestamp : 0n;
+    const estimatedNewShares = params.stakeAmount * vanaToShare / 10n ** 18n;
+    const totalSharesAfter = currentShares + estimatedNewShares;
+    const newStakeEligibility = currentTimestamp + bondingPeriodDuration;
+    let newEligibilityTimestamp;
+    if (currentShares === 0n) {
+      newEligibilityTimestamp = newStakeEligibility;
+    } else {
+      newEligibilityTimestamp = (currentShares * currentEligibilityTimestamp + estimatedNewShares * newStakeEligibility) / totalSharesAfter;
+    }
+    const newRemainingBondingTime = newEligibilityTimestamp > currentTimestamp ? newEligibilityTimestamp - currentTimestamp : 0n;
+    return {
+      newEligibilityTimestamp,
+      newRemainingBondingTime,
+      currentEligibilityTimestamp,
+      currentRemainingBondingTime,
+      currentShares,
+      estimatedNewShares,
+      totalSharesAfter,
+      bondingPeriodDuration,
+      currentTimestamp
+    };
+  }
+  /**
+   * Unstakes VANA from an entity in the VanaPool protocol.
+   *
+   * @remarks
+   * This method unstakes native VANA tokens from a specified entity. The amount
+   * that can be unstaked depends on whether the staker is in the bonding period:
+   *
+   * - **During bonding period**: Only cost basis can be withdrawn; rewards are forfeited
+   * - **After bonding period**: Full current value (cost basis + rewards) can be withdrawn
+   *
+   * Use `getMaxUnstakeAmount` to determine the maximum amount that can be unstaked.
+   *
+   * Requires a wallet client to be configured in the Vana constructor.
+   *
+   * @param params - The unstaking parameters
+   * @param params.entityId - The ID of the entity to unstake from
+   * @param params.amount - The amount of VANA to unstake (in wei, or as a string like "1.5" for 1.5 VANA)
+   * @param params.maxShares - Maximum shares to burn for slippage protection (defaults to 0, no protection)
+   * @returns The transaction hash
+   * @throws {BlockchainError} When wallet client is not configured
+   *
+   * @example
+   * ```typescript
+   * // Get max unstake amount first
+   * const maxUnstake = await vana.staking.getMaxUnstakeAmount(address, 1n);
+   *
+   * // Unstake the maximum amount with slippage protection
+   * const txHash = await vana.staking.unstake({
+   *   entityId: 1n,
+   *   amount: maxUnstake.maxVana,
+   *   maxShares: maxUnstake.maxShares,
+   * });
+   * console.log(`Unstaked! Transaction: ${txHash}`);
+   * ```
+   */
+  async unstake(params, options) {
+    this.assertWallet();
+    const chainId = this.getChainId();
+    const stakingAddress = (0, import_addresses.getContractAddress)(chainId, "VanaPoolStaking");
+    const stakingAbi = (0, import_abi.getAbi)("VanaPoolStaking");
+    const amountWei = typeof params.amount === "string" ? (0, import_viem.parseEther)(params.amount) : params.amount;
+    const maxShares = params.maxShares ?? 0n;
+    const account = this.context.walletClient.account ?? this.context.userAddress;
+    const txHash = await this.context.walletClient.writeContract({
+      address: stakingAddress,
+      abi: stakingAbi,
+      functionName: "unstakeVana",
+      args: [params.entityId, amountWei, maxShares],
+      account,
+      chain: this.context.walletClient.chain,
+      ...this.spreadTransactionOptions(options)
+    });
+    return txHash;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StakingController
+});
+//# sourceMappingURL=staking.cjs.map