> ## Documentation Index
> Fetch the complete documentation index at: https://docs.orbitflare.com/llms.txt
> Use this file to discover all available pages before exploring further.

# minimumLedgerSlot

> 返回节点账本中拥有信息的最低 slot

## 参数

此方法不接受任何参数。

## 响应

<ResponseField name="result" type="number">
  节点账本中拥有信息的最低 slot
</ResponseField>

## 代码示例

### 基本请求

```bash theme={null}
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": "minimumLedgerSlot"
}'
```

### 使用 web3.js

```typescript theme={null}
import { Connection } from '@solana/web3.js';

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

// Get minimum ledger slot
const minSlot = await connection.minimumLedgerSlot();
console.log('Minimum ledger slot:', minSlot);

// Get minimum ledger slot with analysis
async function getMinimumLedgerSlotWithAnalysis() {
  const minSlot = await connection.minimumLedgerSlot();
  const currentSlot = await connection.getSlot();
  
  return {
    slots: {
      minimum: minSlot,
      current: currentSlot,
      difference: currentSlot - minSlot
    },
    metadata: {
      timestamp: Date.now()
    }
  };
}
```

## 注意事项

1. 返回节点账本中的最低 slot
2. 响应是即时的，因为它从当前状态读取
3. 随着账本被修剪，最低 slot 可能会改变
4. 低于此值的 slot 不可访问
5. 该值可能因节点配置不同而在不同节点之间有所差异

## 最佳实践

1. 使用此方法确定账本边界
2. 在适当时缓存结果以减少 RPC 负载
3. 监控最低 slot 的变化
4. 考虑使用 WebSocket 订阅获取实时更新
5. 适当处理网络错误并重试

## 常见错误

| 错误码    | 消息               | 解决方案                  |
| ------ | ---------------- | --------------------- |
| -32601 | Method not found | 验证是否连接到 Solana RPC 节点 |
| -32603 | Internal error   | 节点可能正在启动或同步中          |

## 用例

1. **账本分析**
   ```typescript theme={null}
   interface LedgerAnalysis {
     slots: {
       minimum: number;
       current: number;
       difference: number;
     };
     metrics: {
       pruningRate: number;
       retentionPeriod: number;
     };
     metadata: {
       timestamp: number;
     };
   }

   class LedgerAnalyzer {
     private readonly slotsPerSecond = 2; // Solana's target slots per second
     
     async analyzeLedger(): Promise<LedgerAnalysis> {
       const minSlot = await connection.minimumLedgerSlot();
       const currentSlot = await connection.getSlot();
       const difference = currentSlot - minSlot;
       
       return {
         slots: {
           minimum: minSlot,
           current: currentSlot,
           difference
         },
         metrics: {
           pruningRate: difference / this.slotsPerSecond, // seconds
           retentionPeriod: difference / (this.slotsPerSecond * 3600) // hours
         },
         metadata: {
           timestamp: Date.now()
         }
       };
     }
   }
   ```

2. **账本监控**
   ```typescript theme={null}
   interface LedgerStatus {
     slots: {
       minimum: number;
       previous: number;
       difference: number;
     };
     history: Array<{
       timestamp: number;
       minimum: number;
     }>;
   }

   class LedgerMonitor {
     private previousMinSlot: number | null = null;
     private history: Array<{
       timestamp: number;
       minimum: number;
     }> = [];
     
     async monitorLedger(): Promise<LedgerStatus | null> {
       const minSlot = await connection.minimumLedgerSlot();
       const now = Date.now();
       
       this.history.push({
         timestamp: now,
         minimum: minSlot
       });
       
       if (this.previousMinSlot === null) {
         this.previousMinSlot = minSlot;
         return null;
       }
       
       const status: LedgerStatus = {
         slots: {
           minimum: minSlot,
           previous: this.previousMinSlot,
           difference: minSlot - this.previousMinSlot
         },
         history: this.history
       };
       
       this.previousMinSlot = minSlot;
       return status;
     }
   }
   ```

3. **账本规划**
   ```typescript theme={null}
   interface LedgerPlan {
     slots: {
       minimum: number;
       current: number;
       difference: number;
     };
     recommendations: Array<{
       type: 'fetch' | 'wait' | 'error';
       reason: string;
     }>;
     metadata: {
       timestamp: number;
     };
   }

   class LedgerPlanner {
     private readonly maxSlotRange = 1000000; // Maximum slots to search
     
     async planLedgerOperation(
       targetSlot: number
     ): Promise<LedgerPlan> {
       const minSlot = await connection.minimumLedgerSlot();
       const currentSlot = await connection.getSlot();
       const now = Date.now();
       
       const recommendations: Array<{
         type: 'fetch' | 'wait' | 'error';
         reason: string;
       }> = [];
       
       if (targetSlot < minSlot) {
         recommendations.push({
           type: 'error',
           reason: `Target slot ${targetSlot} is below minimum ledger slot ${minSlot}`
         });
       } else if (targetSlot > currentSlot) {
         recommendations.push({
           type: 'wait',
           reason: `Target slot ${targetSlot} has not been reached yet`
         });
       } else if (currentSlot - targetSlot > this.maxSlotRange) {
         recommendations.push({
           type: 'error',
           reason: `Target slot ${targetSlot} is too far in the past`
         });
       } else {
         recommendations.push({
           type: 'fetch',
           reason: 'Target slot is within valid range'
         });
       }
       
       return {
         slots: {
           minimum: minSlot,
           current: currentSlot,
           difference: currentSlot - minSlot
         },
         recommendations,
         metadata: {
           timestamp: now
         }
       };
     }
   }
   ```