getStakeActivation - OrbitFlare

参数

pubkey

string

必填

质押账户的公钥（base-58 编码）

config

object

包含以下内容的配置对象：

commitment

string

Commitment 级别（processed、confirmed、finalized）

epoch

number

用于计算质押激活的 epoch

响应

result

object

包含以下内容的对象：

state

string

激活状态（active、inactive、activating、deactivating）

active

number

活跃质押金额（以 lamports 为单位）

inactive

number

非活跃质押金额（以 lamports 为单位）

代码示例

基本请求

curl https://fra.rpc.orbitflare.com?api_key=YOUR-API-KEY -X POST -H "Content-Type: application/json" -d '{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getStakeActivation",
  "params": [
    "4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLZj"
  ]
}'

使用 web3.js

import { Connection, PublicKey } from '@solana/web3.js';

const connection = new Connection('https://fra.rpc.orbitflare.com?api_key=YOUR-API-KEY');

// Get stake activation
const stakeAccount = new PublicKey('4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLZj');
const activation = await connection.getStakeActivation(stakeAccount);
console.log('Stake activation:', activation);

// Get stake activation with analysis
async function getStakeActivationWithAnalysis(
  stakeAccount: PublicKey,
  config?: { commitment?: string; epoch?: number }
) {
  const activation = await connection.getStakeActivation(stakeAccount, config);
  
  return {
    activation,
    analysis: {
      totalStake: activation.active + activation.inactive,
      activePercentage: (activation.active / (activation.active + activation.inactive)) * 100,
      state: activation.state,
      metadata: {
        timestamp: Date.now(),
        epoch: config?.epoch,
        commitment: config?.commitment
      }
    }
  };
}

注意事项

返回给定质押账户的质押激活信息
激活状态表示质押是否为活跃、非活跃、正在激活或正在停用
响应是即时的，因为它从当前状态读取
质押激活可能根据 epoch 和 commitment 级别而变化
质押账户必须是有效的质押账户

最佳实践

根据需求使用适当的 commitment 级别
在适当时缓存结果以减少 RPC 负载
监控质押激活的变化
考虑使用 WebSocket 订阅获取实时更新
适当处理网络错误并重试

常见错误

错误码	消息	解决方案
-32601	Method not found	验证是否连接到 Solana RPC 节点
-32602	Invalid params	检查质押账户公钥
-32007	Stake account not found	验证质押账户是否存在
-32008	Invalid stake account	验证账户是否是有效的质押账户

用例

质押激活分析

interface StakeActivationAnalysis {
  account: string;
  activation: {
    state: string;
    active: number;
    inactive: number;
  };
  metrics: {
    totalStake: number;
    activePercentage: number;
    activationProgress?: number;
    deactivationProgress?: number;
  };
  metadata: {
    timestamp: number;
    epoch?: number;
    commitment?: string;
  };
}

class StakeActivationAnalyzer {
  async analyzeStakeActivation(
    stakeAccount: PublicKey,
    config?: { commitment?: string; epoch?: number }
  ): Promise<StakeActivationAnalysis> {
    const activation = await connection.getStakeActivation(stakeAccount, config);
    
    const metrics = {
      totalStake: activation.active + activation.inactive,
      activePercentage: (activation.active / (activation.active + activation.inactive)) * 100
    };
    
    if (activation.state === 'activating' || activation.state === 'deactivating') {
      const progress = (activation.active / (activation.active + activation.inactive)) * 100;
      if (activation.state === 'activating') {
        metrics.activationProgress = progress;
      } else {
        metrics.deactivationProgress = progress;
      }
    }
    
    return {
      account: stakeAccount.toBase58(),
      activation,
      metrics,
      metadata: {
        timestamp: Date.now(),
        epoch: config?.epoch,
        commitment: config?.commitment
      }
    };
  }
}

质押激活监控

interface StakeActivationChange {
  account: string;
  previousState: string;
  currentState: string;
  activeChange: number;
  inactiveChange: number;
  metadata: {
    timestamp: number;
    epoch?: number;
  };
}

class StakeActivationMonitor {
  private previousStates: Map<string, { state: string; active: number; inactive: number }> = new Map();
  
  async monitorStakeActivation(
    stakeAccount: PublicKey,
    config?: { commitment?: string; epoch?: number }
  ): Promise<StakeActivationChange | null> {
    const activation = await connection.getStakeActivation(stakeAccount, config);
    const accountKey = stakeAccount.toBase58();
    const previous = this.previousStates.get(accountKey);
    
    if (!previous) {
      this.previousStates.set(accountKey, {
        state: activation.state,
        active: activation.active,
        inactive: activation.inactive
      });
      return null;
    }
    
    if (previous.state !== activation.state ||
        previous.active !== activation.active ||
        previous.inactive !== activation.inactive) {
      const change: StakeActivationChange = {
        account: accountKey,
        previousState: previous.state,
        currentState: activation.state,
        activeChange: activation.active - previous.active,
        inactiveChange: activation.inactive - previous.inactive,
        metadata: {
          timestamp: Date.now(),
          epoch: config?.epoch
        }
      };
      
      this.previousStates.set(accountKey, {
        state: activation.state,
        active: activation.active,
        inactive: activation.inactive
      });
      
      return change;
    }
    
    return null;
  }
}

质押激活规划

interface StakeActivationPlan {
  account: string;
  currentState: string;
  targetState: string;
  steps: Array<{
    action: string;
    estimatedTime: number;
    requiredStake: number;
  }>;
  metadata: {
    timestamp: number;
    currentEpoch: number;
  };
}

class StakeActivationPlanner {
  private readonly slotsPerEpoch = 432000;
  private readonly slotsPerSecond = 2;
  
  async planStakeActivation(
    stakeAccount: PublicKey,
    targetState: string
  ): Promise<StakeActivationPlan> {
    const [activation, currentEpoch] = await Promise.all([
      connection.getStakeActivation(stakeAccount),
      connection.getEpochInfo()
    ]);
    
    const steps: Array<{
      action: string;
      estimatedTime: number;
      requiredStake: number;
    }> = [];
    
    if (activation.state !== targetState) {
      if (targetState === 'active' && activation.state === 'inactive') {
        steps.push({
          action: 'activate',
          estimatedTime: (this.slotsPerEpoch / this.slotsPerSecond) / 2,
          requiredStake: activation.active + activation.inactive
        });
      } else if (targetState === 'inactive' && activation.state === 'active') {
        steps.push({
          action: 'deactivate',
          estimatedTime: (this.slotsPerEpoch / this.slotsPerSecond) / 2,
          requiredStake: activation.active + activation.inactive
        });
      }
    }
    
    return {
      account: stakeAccount.toBase58(),
      currentState: activation.state,
      targetState,
      steps,
      metadata: {
        timestamp: Date.now(),
        currentEpoch: currentEpoch.epoch
      }
    };
  }
}

​参数

​响应

​代码示例

​基本请求

​使用 web3.js

​注意事项

​最佳实践

​常见错误

​用例

参数

响应

代码示例

基本请求

使用 web3.js

注意事项

最佳实践

常见错误

用例