// 添加sp-timestamp依赖到Cargo.toml
// sp-timestamp = "38.0.0"

use sp_timestamp::{Timestamp, InherentType, InherentDataProvider};

fn main() {
    // 创建时间戳实例
    let timestamp = Timestamp::new(1625097600000); // 毫秒时间戳
    
    // 获取时间戳值
    let millis = timestamp.timestamp();
    println!("Timestamp in milliseconds: {}", millis);
    
    // 转换为秒
    let seconds = millis / 1000;
    println!("Timestamp in seconds: {}", seconds);
    
    // 创建固有数据提供者
    let inherent_data_provider = InherentDataProvider::new(1625097600000);
    
    // 生成固有数据
    let mut inherent_data = sp_inherents::InherentData::new();
    inherent_data_provider
        .provide_inherent_data(&mut inherent_data)
        .expect("Failed to provide inherent data");
    
    println!("Inherent data provided successfully");
}

完整示例代码：

// Cargo.toml 依赖配置
// [dependencies]
// sp-timestamp = "38.0.0"
// sp-inherents = "4.0.0"  # 需要添加sp-inherents依赖

use sp_timestamp::{Timestamp, InherentDataProvider};
use sp_inherents::InherentData;

fn main() {
    // 示例1: 基本时间戳操作
    println!("=== 基本时间戳操作示例 ===");
    
    // 创建时间戳实例（毫秒时间戳）
    let timestamp = Timestamp::new(1625097600000);
    
    // 获取原始时间戳值
    let millis = timestamp.timestamp();
    println!("毫秒时间戳: {}", millis);
    
    // 转换为秒级时间戳
    let seconds = millis / 1000;
    println!("秒级时间戳: {}", seconds);
    
    // 示例2: 固有数据提供功能
    println!("\n=== 固有数据提供功能示例 ===");
    
    // 创建固有数据提供者实例
    let inherent_data_provider = InherentDataProvider::new(1625097600000);
    
    // 创建空的固有数据容器
    let mut inherent_data = InherentData::new();
    
    // 提供固有数据到容器中
    inherent_data_provider
        .provide_inherent_data(&mut inherent_data)
        .expect("提供固有数据失败");
    
    println!("固有数据提供成功");
    
    // 示例3: 时间戳验证和转换
    println!("\n=== 时间戳验证和转换示例 ===");
    
    // 创建另一个时间戳实例
    let current_timestamp = Timestamp::new(1625184000000);
    
    // 验证时间戳有效性
    if current_timestamp.timestamp() > 0 {
        println!("有效时间戳: {}", current_timestamp.timestamp());
    }
    
    // 时间差计算示例
    let time_diff = current_timestamp.timestamp() - timestamp.timestamp();
    println!("时间差(毫秒): {}", time_diff);
    println!("时间差(秒): {}", time_diff / 1000);
    println!("时间差(分钟): {}", time_diff / (1000 * 60));
}

使用说明：

在Cargo.toml中添加sp-timestamp和sp-inherents依赖
时间戳使用毫秒为单位
InherentDataProvider用于生成区块链固有数据
支持时间戳的基本操作和转换功能

yuanlaile 1楼

sp-timestamp：Rust时间戳处理库

简介

sp-timestamp是一个专为Rust设计的高效时间戳处理库，提供了简单易用的API来处理时间戳转换和时间操作。该库支持从纳秒到秒的各种精度时间戳，并提供了丰富的时间计算和格式化功能。

主要特性

多精度时间戳支持（纳秒、微秒、毫秒、秒）
时间戳与日期时间相互转换
时区支持
时间算术运算
人性化的时间格式化
高性能处理

安装方法

在Cargo.toml中添加依赖：

[dependencies]
sp-timestamp = "0.3"

基本用法示例

1. 创建时间戳

use sp_timestamp::{Timestamp, TimeUnit};

// 从当前时间创建时间戳
let now = Timestamp::now();

// 从指定Unix时间戳创建
let timestamp = Timestamp::from_unix(1640995200, TimeUnit::Seconds); // 2022-01-01 00:00:00 UTC

// 从纳秒精度创建
let ns_timestamp = Timestamp::from_nanos(1640995200000000000);

2. 时间戳转换

use sp_timestamp::{Timestamp, TimeUnit};

let timestamp = Timestamp::from_unix(1640995200, TimeUnit::Seconds);

// 转换为不同精度
println!("毫秒时间戳: {}", timestamp.as_millis());
println!("微秒时间戳: {}", timestamp.as_micros());
println!("纳秒时间戳: {}", timestamp.as_nanos());

// 转换为DateTime
let datetime = timestamp.to_utc_datetime();
println!("UTC时间: {}", datetime);

3. 时间运算

use sp_timestamp::{Timestamp, Duration};
use std::time::Duration as StdDuration;

let mut timestamp = Timestamp::now();

// 添加时间间隔
let later = timestamp + Duration::hours(2);
let tomorrow = timestamp + Duration::days(1);

// 减去时间间隔
let earlier = timestamp - Duration::minutes(30);

// 使用标准库Duration
timestamp += StdDuration::from_secs(3600);

4. 时间比较

use sp_timestamp::Timestamp;

let time1 = Timestamp::from_unix(1640995200, TimeUnit::Seconds);
let time2 = Timestamp::from_unix(1641081600, TimeUnit::Seconds);

if time1 < time2 {
    println!("time1 在 time2 之前");
}

// 计算时间差
let diff = time2 - time1;
println!("时间差: {}秒", diff.as_secs());

5. 格式化输出

use sp_timestamp::Timestamp;

let timestamp = Timestamp::now();

// 默认格式化
println!("默认格式: {}", timestamp);

// 自定义格式化
println!("ISO格式: {}", timestamp.to_iso8601());
println!("自定义格式: {}", timestamp.format("%Y-%m-%d %H:%M:%S"));

// 人性化显示
println!("相对时间: {}", timestamp.humanize());

6. 时区处理

use sp_timestamp::{Timestamp, Timezone};

let utc_time = Timestamp::now();
let beijing_time = utc_time.with_timezone(Timezone::new(8)); // UTC+8

println!("UTC时间: {}", utc_time);
println!("北京时间: {}", beijing_time);

高级用法

批量处理时间戳

use sp_timestamp::Timestamp;

let timestamps = vec![
    Timestamp::from_unix(1640995200, TimeUnit::Seconds),
    Timestamp::from_unix(1641081600, TimeUnit::Seconds),
    Timestamp::from_unix(1641168000, TimeUnit::Seconds),
];

for ts in timestamps {
    println!("处理时间戳: {}", ts.to_utc_datetime());
}

性能关键场景

use sp_timestamp::Timestamp;

// 使用低层级API避免分配
let timestamp = Timestamp::now();
let raw_nanos = timestamp.as_raw_nanos(); // 直接获取原始纳秒值

// 高性能时间比较
if timestamp.as_raw_nanos() > other_timestamp.as_raw_nanos() {
    // 处理逻辑
}

完整示例代码

use sp_timestamp::{Timestamp, TimeUnit, Duration, Timezone};
use std::time::Duration as StdDuration;

fn main() {
    // 示例1：创建时间戳
    println!("=== 创建时间戳示例 ===");
    
    // 从当前时间创建
    let now = Timestamp::now();
    println!("当前时间戳: {}", now);
    
    // 从指定Unix时间戳创建
    let specific_time = Timestamp::from_unix(1640995200, TimeUnit::Seconds);
    println!("指定时间戳: {}", specific_time);
    
    // 从纳秒精度创建
    let ns_time = Timestamp::from_nanos(1640995200000000000);
    println!("纳秒时间戳: {}", ns_time);
    
    // 示例2：时间戳转换
    println!("\n=== 时间戳转换示例 ===");
    
    let timestamp = Timestamp::from_unix(1640995200, TimeUnit::Seconds);
    println!("原始秒时间戳: {}", timestamp.as_secs());
    println!("毫秒时间戳: {}", timestamp.as_millis());
    println!("微秒时间戳: {}", timestamp.as_micros());
    println!("纳秒时间戳: {}", timestamp.as_nanos());
    
    // 转换为DateTime
    let datetime = timestamp.to_utc_datetime();
    println!("UTC日期时间: {}", datetime);
    
    // 示例3：时间运算
    println!("\n=== 时间运算示例 ===");
    
    let mut base_time = Timestamp::from_unix(1640995200, TimeUnit::Seconds);
    println!("基准时间: {}", base_time);
    
    // 添加时间间隔
    let two_hours_later = base_time + Duration::hours(2);
    println!("两小时后: {}", two_hours_later);
    
    let one_day_later = base_time + Duration::days(1);
    println!("一天后: {}", one_day_later);
    
    // 减去时间间隔
    let thirty_minutes_earlier = base_time - Duration::minutes(30);
    println!("三十分钟前: {}", thirty_minutes_earlier);
    
    // 使用标准库Duration
    base_time += StdDuration::from_secs(3600);
    println!("加一小时后: {}", base_time);
    
    // 示例4：时间比较
    println!("\n=== 时间比较示例 ===");
    
    let time_a = Timestamp::from_unix(1640995200, TimeUnit::Seconds);
    let time_b = Timestamp::from_unix(1641081600, TimeUnit::Seconds);
    
    if time_a < time_b {
        println!("time_a 在 time_b 之前");
    }
    
    // 计算时间差
    let time_diff = time_b - time_a;
    println!("时间差: {}秒", time_diff.as_secs());
    println!("时间差: {}小时", time_diff.as_hours());
    
    // 示例5：格式化输出
    println!("\n=== 格式化输出示例 ===");
    
    let current_time = Timestamp::now();
    println!("默认格式: {}", current_time);
    println!("ISO8601格式: {}", current_time.to_iso8601());
    println!("自定义格式: {}", current_time.format("%Y-%m-%d %H:%M:%S"));
    println!("相对时间: {}", current_time.humanize());
    
    // 示例6：时区处理
    println!("\n=== 时区处理示例 ===");
    
    let utc_time = Timestamp::now();
    let beijing_time = utc_time.with_timezone(Timezone::new(8)); // UTC+8
    let newyork_time = utc_time.with_timezone(Timezone::new(-5)); // UTC-5
    
    println!("UTC时间: {}", utc_time);
    println!("北京时间: {}", beijing_time);
    println!("纽约时间: {}", newyork_time);
    
    // 示例7：批量处理
    println!("\n=== 批量处理示例 ===");
    
    let time_list = vec![
        Timestamp::from_unix(1640995200, TimeUnit::Seconds),
        Timestamp::from_unix(1641081600, TimeUnit::Seconds),
        Timestamp::from_unix(1641168000, TimeUnit::Seconds),
    ];
    
    for (i, ts) in time_list.iter().enumerate() {
        println!("时间戳 {}: {} -> {}", i + 1, ts, ts.to_utc_datetime());
    }
    
    // 示例8：高性能操作
    println!("\n=== 高性能操作示例 ===");
    
    let start_time = Timestamp::now();
    
    // 使用原始纳秒值进行高性能比较
    let time1 = Timestamp::now();
    std::thread::sleep(StdDuration::from_millis(100));
    let time2 = Timestamp::now();
    
    if time1.as_raw_nanos() < time2.as_raw_nanos() {
        println!("高性能比较: time1 < time2");
    }
    
    let end_time = Timestamp::now();
    let elapsed = end_time - start_time;
    println!("操作耗时: {}微秒", elapsed.as_micros());
}

注意事项

时间戳默认使用UTC时区
所有时间运算都会自动处理溢出情况
库内部使用64位整数存储纳秒精度时间戳
支持的时间范围：公元1677年至2262年

sp-timestamp库提供了完整而高效的时间处理解决方案，适合需要处理时间戳的各种应用场景。

Rust时间戳处理库sp-timestamp的使用，高效处理时间戳转换与时间操作的Rust插件库

sp-timestamp：Rust时间戳处理库

简介

主要特性

安装方法

基本用法示例

1. 创建时间戳

2. 时间戳转换

3. 时间运算

4. 时间比较

5. 格式化输出

6. 时区处理

高级用法

批量处理时间戳

性能关键场景

完整示例代码

注意事项