solidity日期工具

已于 2024-03-25 17:56:10 修改
阅读量1.5k 收藏 2
点赞数
分类专栏： 智能合约 区块链学习 文章标签： 开发工具 智能合约
于 2021-08-17 17:39:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38935605/article/details/119762170
版权

给大家整理了三个 solidity智能合约的日期工具，里面包含基本的日期操作，可以直接拿去使用的。

pragma solidity ^0.5.1;

//时间工具
contract DateUtil {

    uint constant internal SECONDS_PER_DAY = 24 * 60 * 60;
    uint constant internal SECONDS_PER_HOUR = 60 * 60;
    uint constant internal SECONDS_PER_MINUTE = 60;
    uint constant internal OFFSET19700101 = 2440588;

    //每月天数
    uint8[] monthDays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

    //时间戳转日期
    function daysToDate(int timestamp, int8 timezone) public pure returns (uint year, uint month, uint day){
        return _daysToDate(timestamp + timezone * int(SECONDS_PER_HOUR));
    }

    //当月总天数
    function monthTotalDay(int timestamp, int8 timezone) public view returns (uint){
        (uint year, uint month,) = daysToDate(timestamp, timezone);
        if (month != 2) {
            return monthDays[month - 1];
        }
        return year % 4 == 0 ? 29 : 28;
    }

    //时间戳转日期，UTC时区
    function _daysToDate(int timestamp) private pure returns (uint year, uint month, uint day) {
        uint _days = uint(timestamp) / SECONDS_PER_DAY;

        uint L = _days + 68569 + OFFSET19700101;
        uint N = 4 * L / 146097;
        L = L - (146097 * N + 3) / 4;
        year = 4000 * (L + 1) / 1461001;
        L = L - 1461 * year / 4 + 31;
        month = 80 * L / 2447;
        day = L - 2447 * month / 80;
        L = month / 11;
        month = month + 2 - 12 * L;
        year = 100 * (N - 49) + year + L;
    }
}

pragma solidity ^0.4.16;

contract DateTime {
    /*
     *  Date and Time utilities for ethereum contracts
     *
     */
    struct _DateTime {
        uint16 year;
        uint8 month;
        uint8 day;
        uint8 hour;
        uint8 minute;
        uint8 second;
        uint8 weekday;
    }

    uint constant DAY_IN_SECONDS = 86400;
    uint constant YEAR_IN_SECONDS = 31536000;
    uint constant LEAP_YEAR_IN_SECONDS = 31622400;

    uint constant HOUR_IN_SECONDS = 3600;
    uint constant MINUTE_IN_SECONDS = 60;

    uint16 constant ORIGIN_YEAR = 1970;

    //判断输入的年份是不是闰年
    function isLeapYear(uint16 year) public pure returns (bool) {
        if (year % 4 != 0) {
            return false;
        }
        if (year % 100 != 0) {
            return true;
        }
        if (year % 400 != 0) {
            return false;
        }
        return true;
    }

    //判断输入的年份 的闰年前
    function leapYearsBefore(uint year) public pure returns (uint) {
        year -= 1;
        return year / 4 - year / 100 + year / 400;
    }

    //输入年year   月month  得到当月的天数
    function getDaysInMonth(uint8 month, uint16 year) public pure returns (uint8) {
        if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
            return 31;
        }
        else if (month == 4 || month == 6 || month == 9 || month == 11) {
            return 30;
        }
        else if (isLeapYear(year)) {
            return 29;
        }
        else {
            return 28;
        }
    }

    function parseTimestamp(uint timestamp) internal pure returns (_DateTime dt) {
        uint secondsAccountedFor = 0;
        uint buf;
        uint8 i;

        // Year
        dt.year = getYear(timestamp);
        buf = leapYearsBefore(dt.year) - leapYearsBefore(ORIGIN_YEAR);

        secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf;
        secondsAccountedFor += YEAR_IN_SECONDS * (dt.year - ORIGIN_YEAR - buf);

        // Month
        uint secondsInMonth;
        for (i = 1; i <= 12; i++) {
            secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, dt.year);
            if (secondsInMonth + secondsAccountedFor > timestamp) {
                dt.month = i;
                break;
            }
            secondsAccountedFor += secondsInMonth;
        }

        // Day
        for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) {
            if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) {
                dt.day = i;
                break;
            }
            secondsAccountedFor += DAY_IN_SECONDS;
        }

        // Hour
        dt.hour = getHour(timestamp);

        // Minute
        dt.minute = getMinute(timestamp);

        // Second
        dt.second = getSecond(timestamp);

        // Day of week.
        dt.weekday = getWeekday(timestamp);
    }

    //根据时间戳获取年份
    function getYear(uint timestamp) public pure returns (uint16) {
        uint secondsAccountedFor = 0;
        uint16 year;
        uint numLeapYears;

        // Year
        year = uint16(ORIGIN_YEAR + timestamp / YEAR_IN_SECONDS);
        numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR);

        secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears;
        secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears);

        while (secondsAccountedFor > timestamp) {
            if (isLeapYear(uint16(year - 1))) {
                secondsAccountedFor -= LEAP_YEAR_IN_SECONDS;
            }
            else {
                secondsAccountedFor -= YEAR_IN_SECONDS;
            }
            year -= 1;
        }
        return year;
    }

    //根据时间戳获取月份
    function getMonth(uint timestamp) public pure returns (uint8) {
        return parseTimestamp(timestamp).month;
    }

    //根据时间戳获取当前天数
    function getDay(uint timestamp) public pure returns (uint8) {
        return parseTimestamp(timestamp).day;
    }

    function getHour(uint timestamp) public pure returns (uint8) {
        return uint8((timestamp / 60 / 60) % 24);
    }

    //获取分钟
    function getMinute(uint timestamp) public pure returns (uint8) {
        return uint8((timestamp / 60) % 60);
    }

    function getSecond(uint timestamp) public pure returns (uint8) {
        return uint8(timestamp % 60);
    }

    //获取星期几
    function getWeekday(uint timestamp) public pure returns (uint8) {
        return uint8((timestamp / DAY_IN_SECONDS + 4) % 7);
    }

    //根据年月日获取时间戳
    function toTimestamp(uint16 year, uint8 month, uint8 day) public pure returns (uint timestamp) {
        return toTimestamp(year, month, day, 0, 0, 0);
    }

    //根据年月日时获取时间戳
    function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour) public pure returns (uint timestamp) {
        return toTimestamp(year, month, day, hour, 0, 0);
    }

    //根据年月日时分获取时间戳
    function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute) public pure returns (uint timestamp) {
        return toTimestamp(year, month, day, hour, minute, 0);
    }

    //根据年月日时分秒获取时间戳
    function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute, uint8 second) public pure returns (uint timestamp) {
        uint16 i;

        // Year
        for (i = ORIGIN_YEAR; i < year; i++) {
            if (isLeapYear(i)) {
                timestamp += LEAP_YEAR_IN_SECONDS;
            }
            else {
                timestamp += YEAR_IN_SECONDS;
            }
        }

        // Month
        uint8[12] memory monthDayCounts;
        monthDayCounts[0] = 31;
        if (isLeapYear(year)) {
            monthDayCounts[1] = 29;
        }
        else {
            monthDayCounts[1] = 28;
        }
        monthDayCounts[2] = 31;
        monthDayCounts[3] = 30;
        monthDayCounts[4] = 31;
        monthDayCounts[5] = 30;
        monthDayCounts[6] = 31;
        monthDayCounts[7] = 31;
        monthDayCounts[8] = 30;
        monthDayCounts[9] = 31;
        monthDayCounts[10] = 30;
        monthDayCounts[11] = 31;

        for (i = 1; i < month; i++) {
            timestamp += DAY_IN_SECONDS * monthDayCounts[i - 1];
        }

        // Day
        timestamp += DAY_IN_SECONDS * (day - 1);

        // Hour
        timestamp += HOUR_IN_SECONDS * (hour);

        // Minute
        timestamp += MINUTE_IN_SECONDS * (minute);

        // Second
        timestamp += second;

        return timestamp;
    }
}

获取季度的时间

pragma solidity ^0.5.1;

//时间工具
contract DateUtil {

    uint constant internal SECONDS_PER_DAY = 24 * 60 * 60;
    uint constant internal SECONDS_PER_HOUR = 60 * 60;
    uint constant internal SECONDS_PER_MINUTE = 60;
    uint constant internal OFFSET19700101 = 2440588;
    uint16 constant ORIGIN_YEAR = 1970;
    uint constant LEAP_YEAR_IN_SECONDS = 31622400;
    uint constant YEAR_IN_SECONDS = 31536000;
    uint constant DAY_IN_SECONDS = 86400;

    uint constant HOUR_IN_SECONDS = 3600;
    uint constant MINUTE_IN_SECONDS = 60;


    //每月天数
    uint8[] monthDays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

    //时间戳转日期
    function daysToDate(int timestamp, int8 timezone) public pure returns (uint year, uint month, uint day){
        return _daysToDate(timestamp + timezone * int(SECONDS_PER_HOUR));
    }

    //当月总天数
    function monthTotalDay(int timestamp, int8 timezone) public view returns (uint){
        (uint year, uint month,) = daysToDate(timestamp, timezone);
        if (month != 2) {
            return monthDays[month - 1];
        }
        return year % 4 == 0 ? 29 : 28;
    }

    //时间戳转日期，UTC时区
    function _daysToDate(int timestamp) private pure returns (uint year, uint month, uint day) {
        uint _days = uint(timestamp) / SECONDS_PER_DAY;

        uint L = _days + 68569 + OFFSET19700101;
        uint N = 4 * L / 146097;
        L = L - (146097 * N + 3) / 4;
        year = 4000 * (L + 1) / 1461001;
        L = L - 1461 * year / 4 + 31;
        month = 80 * L / 2447;
        day = L - 2447 * month / 80;
        L = month / 11;
        month = month + 2 - 12 * L;
        year = 100 * (N - 49) + year + L;
    }



    //获取当个季度总天数和剩余多少天数
    function getQuarterlyDay(int timestamp) public view returns(int){
        (uint year, uint month, uint day) = _daysToDate(timestamp);
        //年 月  日  季度  总天数  时间戳
        return int(getQuarterly(uint16(year),uint8(month),uint8(day),getQuarterly(timestamp),0,timestamp));
    }


    //当日是否为季度的第一天
    function getQuarterlyFirst(int timestamp) public pure returns(bool){
        (uint year, uint month, uint day) = _daysToDate(timestamp);
        if((month == 1 || month == 4 || month == 7 || month == 10) && day == 1){
            return true;
        }else{
            return false;
        }
    }

    //输入年year   月month  得到当月的天数
    function getDaysInMonth(uint8 month, uint16 year) public pure returns (uint8) {
        if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
            return 31;
        }
        else if (month == 4 || month == 6 || month == 9 || month == 11) {
            return 30;
        }
        else if (isLeapYear(year)) {
            return 29;
        }
        else {
            return 28;
        }
    }

    //根据年月日获取时间戳
    function toTimestamp(uint16 year, uint8 month, uint8 day) public pure returns (uint timestamp) {
        return toTimestamp(year, month, day, 0, 0, 0);
    }


    //根据年月日时分秒获取时间戳
    function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute, uint8 second) public pure returns (uint timestamp) {
        uint16 i;

        // Year
        for (uint16 i = ORIGIN_YEAR; i < year; i++) {
            if (isLeapYear(i)) {
                timestamp += LEAP_YEAR_IN_SECONDS;
            }
            else {
                timestamp += YEAR_IN_SECONDS;
            }
        }
        // Month
        uint8[12] memory monthDayCounts;
        monthDayCounts[0] = 31;
        if (isLeapYear(year)) {
            monthDayCounts[1] = 29;
        }
        else {
            monthDayCounts[1] = 28;
        }
        monthDayCounts[2] = 31;
        monthDayCounts[3] = 30;
        monthDayCounts[4] = 31;
        monthDayCounts[5] = 30;
        monthDayCounts[6] = 31;
        monthDayCounts[7] = 31;
        monthDayCounts[8] = 30;
        monthDayCounts[9] = 31;
        monthDayCounts[10] = 30;
        monthDayCounts[11] = 31;
        for (i = 1; i < month; i++) {
            timestamp += DAY_IN_SECONDS  * monthDayCounts[i - 1];
        }
        // Day
        timestamp += DAY_IN_SECONDS * (day - 1);
        // Hour
        timestamp += HOUR_IN_SECONDS * (hour);
        // Minute
        timestamp += MINUTE_IN_SECONDS * (minute);
        // Second
        timestamp += second;
        return timestamp;
    }

    //判断输入的年份是不是闰年
    function isLeapYear(uint16 year) public pure returns (bool) {
        if (year % 4 != 0) {
            return false;
        }
        if (year % 100 != 0) {
            return true;
        }
        if (year % 400 != 0) {
            return false;
        }
        return true;
    }



    //传入时间搓获取当前到了第几个季度
    function getQuarterly(int timestamp) public pure returns(uint8){
        (uint year, uint month, uint day) = _daysToDate(timestamp);
        if(month >= 1 && month <= 3){
            return 1;
        }else if(month >= 4 && month <= 6){
            return 2;
        }else if(month >= 7 && month <= 9){
            return 3;
        }else if(month >= 10 && month <= 12){
            return 4;
        }
    }


    //年月日    季度   时间戳
    function getQuarterly(uint16 year, uint8 month, uint8 day,uint quarterly,uint countNumber,int timestamp) public view returns(uint){
        //获取当前日期
        (uint yearPs, uint monthPs, uint dayPs)  = _daysToDate(timestamp);
        if(countNumber == 0){
            //获取当月天数
            countNumber = monthTotalDay(timestamp,8);
            //当月天数-号数=剩余当月天数
            countNumber = countNumber - day;
            return getQuarterly(uint16(year), uint8(month), uint8(day),quarterly,countNumber,timestamp);
        }
        if(month > 12){
            month = 1;
            year++;
        }else{
            month++;
        }
        //根据年月日获取时间戳
        int time = int(toTimestamp(year,month,day));
        //获取季度
        uint8 jidu = getQuarterly(time);
        if(jidu != uint8(quarterly)){
            return countNumber;
        }else{
            //根据时间搓获取当月天数
            uint dayTime = monthTotalDay(time,8);
            countNumber = countNumber + dayTime;
            return getQuarterly(uint16(year), uint8(month), uint8(day),quarterly,countNumber,timestamp);
        }
    }


}

破 风
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
solidity 中的时间_智能合约语言 Solidity 以太单位及时间单位
weixin_39907713的博客
12-20 755
链客，专为开发者而生，有问必答！Solidity是以太坊智能合约编程语言，当然你在阅读这篇文章之前，你应该对以太坊、智能合约有初步或者深入的了解，当然你还是不了解的话，建议你先去看以太坊是什么。时间单位时间单位: seconds, minutes, hours, days, weeks, years均可做为后缀，并进行相互转换，规则如下：1 == 1 seconds (默认是seconds为单位)...
Solidity_获取区块当前时间
weixin_43520099的博客
06-19 7180
now变量可以返回区块时间,时间是unix的绝对时间戳（自1970-01-01以来的秒数） 注意： 获得时间改变了区块里的内容，因此该过程需要gas pragma solidity >=0.4.22 <0.6.0; contract date{ uint public time; function getDate() public { time = now; } } ...
9、Solidity的时间、单位转换。
weixin_34405925的博客
09-04 2099
2019独角兽企业重金招聘Python工程师标准>>> ...
python-函数的定义和使用
weixin_50108437的博客
09-11 547
函数 #定义函数的方法 def 函数名（参数列表）: 函数体 return 返回值 #调用函数 函数名（具有实际值的参数列表） 1.一般规则 (1) 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。 （2）任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。 （3）函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。 （4）函数内容以冒号起始，并且缩进。 （5）return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 N
solidity 中的时间_solidity基础知识
weixin_39929153的博客
01-30 2445
1、solidity是一种语法类似JavaScript的高级语言，它被设计成以编译的方式生成以太坊虚拟机代码。在后续的内容中你将会发现，使用它很容易创建用于投票、众筹、封闭拍卖、多重签名钱包等等的合约。solidity在线IDE：https://ethereum.github.io/browser-solidity/#optimize=false&version=soljson-v0.4....
vue中如何改变时间戳或标准格式的时间为几天前的形式
Missxu1895的博客
09-09 1104
如果你在vue当中得到的是时间格式是时间戳格式或者是标准的时间格式(比如：2020-09-08 12:12:34)，然后想让这些种格式变成几天前、几小时前的这种输出的话，我们需要做的是什么？ 首先写一个函数，该函数用来处理当前时间减去得到的时间最后显示出来的‘几天前、几小时前’的格式，那这个函数我是把它放在了外面然后在组件中通过过滤方式来进行调用 export function timeago(dateTimeStamp) { // dateTimeStamp是一个时间毫秒，注意时间戳是秒的形式，在
solidity 中的时间_Solidity快速了解
weixin_34397537的博客
12-30 1541
合约的基本结构程序版本(Version Pragma)：Solidity 大多都是开源的程序，在代码中加上程序版本是为了方便社区合作。描述程序版本的规则和 npm 的一样。pragmasolidity^0.4.19;合同(contract)声明：合同类似于面向对象语言中的类(Class)。contractSimpleStorage{}状态变量(State variable)声明：状态变量是...
solidity时间处理函数集
Harry Wong的博客
08-23 1054
摘要智能合约，solidity关于时间处理的函数库。 国外有个哥们写了详细的时间处理函数 地址：https://github.com/bokkypoobah/BokkyPooBahsDateTimeLibrary 可直接使用，代码如下： pragma solidity ^0.6.0; // ---------------...
Solidity学习之时间单位
明明的博客
07-11 993
变量now返回当前的Unix时间戳（自1970年1月1日以来经过的秒数），Unix时间传统用一个32位的整数进行存储 Solidity还包含秒(seconds)，分钟(minutes)，小时(hours)，天(days)，周(weeks) 和 年(years) 等时间单位。它们都会转换成对应的秒数放入 uint 中。 ...
Solidity
03-11
坚固性利润分配的动机利润分配用于使用预授权地址平均分配资金，这些资金将自动分配到这些地址中，而无需手动为每个人计算存入金额。创建智能合约创建一个新合同，名称为AssociateProfitSplitter.sol 成功创建合同后...
solidity
01-07
pragma solidity ^0.4.0; contract StringTest{ string name = xms; function getName() public view returns(string){ return name; } function setName(string _name) public{ name = _name; } function ...
Solidity编程实例
01-27
接下来的合约非常复杂，但展示了很多Solidity的特性。它实现了一个投票合约。当然，电子选举的主要问题是如何赋予投票权给准确的人，并防止操纵。我们不能解决所有的问题，但至少我们会展示如何委托投票可以同时做到...
Solidity教程
05-23
在Solidity教程中，我们将深入理解这种以太坊智能合约编程语言的基础——变量类型。Solidity是一种静态类型语言，这意味着每个变量必须在编译时指定其类型。它提供了丰富的基本类型，可以组合成复杂的结构。 首先，...
Solidity基础七
最新发布
尽欢的博客
05-27 2258
Solidity的单位、地址的形成、以太坊的账户、消息调用和余额查询、交易、Solidity的this和msg.sender和msg.value、Solidity的转账函数、Solidity的接收函数、Solidity发送ETH、Solidity支付ETH、Solidity回退函数
【区块链】以太坊Solidity编程：智能合约实现之基本语法
小哲的博客
02-28 1760
以太坊Soliddity编程：智能合约实现 基本数据类型 array类型 mapping类型 struct类型 数据的位置和引用类型 特殊变量和函数 函数及基本控制结构 实战：课程积分 ...
solidity高级理论(三)：时间单位与view
D256
06-21 4013
solidity高级理论(三)：时间单位与view 关键字：时间单位、view、Gas优化 solidity使用自己的本地时间单位 变量 now 将返回当前的unix时间戳（自1970年1月1日以来经过的秒数）。 注意：Unix时间传统用一个32位的整数进行存储。这会导致“2038年”问题，当这个32位的unix时间戳不够用，产生溢出，使用这个时间的遗留系统就麻烦了。所以，如果我们...
智能合约安全漏洞之区块链的时间戳依赖漏洞与解决方法
StevenX5
04-15 4868
时间戳依赖是指智能合约的执行依赖于当前区块的时间戳，如果时间戳不同，那么合约的执行结果也有差别。因此，如果在智能合约中不正确地使用区块时间戳，这将是非常危险的。本文通过对时间戳依赖漏洞原理的阐述，并结合 Solidity 智能合约实例代码的演示，介绍了一种区块链时间戳依赖漏洞及其解决方法。
solidity语言类型
mongo_node的专栏
04-30 561
类型 Solidity是一种静态类型语言，意思是每个变量（声明和本地）在编译时刻都要定义 （或者至少要知晓，参看 后面的类型导出 ）。 Solidity提供几个基本类型组合成复杂类型。 变量类型 以下类型被叫做值类型，因为这些类型的变量总是要被赋值，作为函数参数或者在赋值中，总需要拷贝。 布尔类型 布尔：可能的常量值 是 真或假 操作符： ！（逻辑非） &amp;&amp...
java通过web3j获取ETH交易明细
热门推荐
qq_38935605的博客
03-31 1万+
我们在项目里面如果想要得到用户的ETH交易明细怎么做呢？有两种方式： 1、直接获取ETH最新块的交易明细。 2、通过块获取用户的交易明细。 废话不多说，直接贴代码看了 package com.example.demo.web3jLog; import org.springframework.stereotype.Component; import org.web3j.protocol.Web3j; import org.web3j.protocol.c...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值