getStakeActivation

​

参数

​

响应

​

代码示例

​

基本请求

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
      }
    }
  };
}

​

注意事项

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

​

最佳实践

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

​

常见错误

​

用例

1. 质押激活分析
   复制

   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
         }
       };
     }
   }
   
2. 质押激活监控
   复制

   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;
     }
   }
   
3. 质押激活规划
   复制

   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
         }
       };
     }
   }